SYMBOL INDEX (9625 symbols across 598 files)

FILE: asv_benchmarks/benchmarks/cluster.py
  class KMeansBenchmark (line 8) | class KMeansBenchmark(Predictor, Transformer, Estimator, Benchmark):
    method setup_cache (line 16) | def setup_cache(self):
    method make_data (line 19) | def make_data(self, params):
    method make_estimator (line 29) | def make_estimator(self, params):
    method make_scorers (line 46) | def make_scorers(self):
  class MiniBatchKMeansBenchmark (line 57) | class MiniBatchKMeansBenchmark(Predictor, Transformer, Estimator, Benchm...
    method setup_cache (line 65) | def setup_cache(self):
    method make_data (line 68) | def make_data(self, params):
    method make_estimator (line 78) | def make_estimator(self, params):
    method make_scorers (line 96) | def make_scorers(self):

FILE: asv_benchmarks/benchmarks/common.py
  function get_from_config (line 13) | def get_from_config():
  function get_estimator_path (line 59) | def get_estimator_path(benchmark, directory, params, save=False):
  function clear_tmp (line 74) | def clear_tmp():
  class Benchmark (line 81) | class Benchmark(ABC):
    method params (line 116) | def params(self):
  class Estimator (line 120) | class Estimator(ABC):
    method make_data (line 124) | def make_data(self, params):
    method make_estimator (line 131) | def make_estimator(self, params):
    method skip (line 135) | def skip(self, params):
    method setup_cache (line 139) | def setup_cache(self):
    method setup (line 162) | def setup(self, *params):
    method time_fit (line 180) | def time_fit(self, *args):
    method peakmem_fit (line 183) | def peakmem_fit(self, *args):
    method track_train_score (line 186) | def track_train_score(self, *args):
    method track_test_score (line 193) | def track_test_score(self, *args):
  class Predictor (line 201) | class Predictor(ABC):
    method time_predict (line 206) | def time_predict(self, *args):
    method peakmem_predict (line 209) | def peakmem_predict(self, *args):
    method track_same_prediction (line 214) | def track_same_prediction(self, *args):
    method params (line 226) | def params(self):
  class Transformer (line 230) | class Transformer(ABC):
    method time_transform (line 235) | def time_transform(self, *args):
    method peakmem_transform (line 238) | def peakmem_transform(self, *args):
    method track_same_transform (line 243) | def track_same_transform(self, *args):
    method params (line 255) | def params(self):

FILE: asv_benchmarks/benchmarks/datasets.py
  function _blobs_dataset (line 25) | def _blobs_dataset(n_samples=500000, n_features=3, n_clusters=100, dtype...
  function _20newsgroups_highdim_dataset (line 36) | def _20newsgroups_highdim_dataset(n_samples=None, ngrams=(1, 1), dtype=n...
  function _20newsgroups_lowdim_dataset (line 47) | def _20newsgroups_lowdim_dataset(n_components=100, ngrams=(1, 1), dtype=...
  function _mnist_dataset (line 61) | def _mnist_dataset(dtype=np.float32):
  function _digits_dataset (line 71) | def _digits_dataset(n_samples=None, dtype=np.float32):
  function _synth_regression_dataset (line 83) | def _synth_regression_dataset(n_samples=100000, n_features=100, dtype=np...
  function _synth_regression_sparse_dataset (line 99) | def _synth_regression_sparse_dataset(
  function _synth_classification_dataset (line 117) | def _synth_classification_dataset(
  function _olivetti_faces_dataset (line 136) | def _olivetti_faces_dataset():
  function _random_dataset (line 150) | def _random_dataset(

FILE: asv_benchmarks/benchmarks/decomposition.py
  class PCABenchmark (line 8) | class PCABenchmark(Transformer, Estimator, Benchmark):
    method setup_cache (line 16) | def setup_cache(self):
    method make_data (line 19) | def make_data(self, params):
    method make_estimator (line 22) | def make_estimator(self, params):
    method make_scorers (line 29) | def make_scorers(self):
  class DictionaryLearningBenchmark (line 33) | class DictionaryLearningBenchmark(Transformer, Estimator, Benchmark):
    method setup_cache (line 41) | def setup_cache(self):
    method make_data (line 44) | def make_data(self, params):
    method make_estimator (line 47) | def make_estimator(self, params):
    method make_scorers (line 62) | def make_scorers(self):
  class MiniBatchDictionaryLearningBenchmark (line 66) | class MiniBatchDictionaryLearningBenchmark(Transformer, Estimator, Bench...
    method setup_cache (line 74) | def setup_cache(self):
    method make_data (line 77) | def make_data(self, params):
    method make_estimator (line 80) | def make_estimator(self, params):
    method make_scorers (line 94) | def make_scorers(self):

FILE: asv_benchmarks/benchmarks/ensemble.py
  class RandomForestClassifierBenchmark (line 16) | class RandomForestClassifierBenchmark(Predictor, Estimator, Benchmark):
    method setup_cache (line 24) | def setup_cache(self):
    method make_data (line 27) | def make_data(self, params):
    method make_estimator (line 37) | def make_estimator(self, params):
    method make_scorers (line 52) | def make_scorers(self):
  class GradientBoostingClassifierBenchmark (line 56) | class GradientBoostingClassifierBenchmark(Predictor, Estimator, Benchmark):
    method setup_cache (line 64) | def setup_cache(self):
    method make_data (line 67) | def make_data(self, params):
    method make_estimator (line 77) | def make_estimator(self, params):
    method make_scorers (line 91) | def make_scorers(self):
  class HistGradientBoostingClassifierBenchmark (line 95) | class HistGradientBoostingClassifierBenchmark(Predictor, Estimator, Benc...
    method setup_cache (line 103) | def setup_cache(self):
    method make_data (line 106) | def make_data(self, params):
    method make_estimator (line 113) | def make_estimator(self, params):
    method make_scorers (line 120) | def make_scorers(self):

FILE: asv_benchmarks/benchmarks/linear_model.py
  class LogisticRegressionBenchmark (line 20) | class LogisticRegressionBenchmark(Predictor, Estimator, Benchmark):
    method setup_cache (line 28) | def setup_cache(self):
    method make_data (line 31) | def make_data(self, params):
    method make_estimator (line 47) | def make_estimator(self, params):
    method make_scorers (line 63) | def make_scorers(self):
  class RidgeBenchmark (line 67) | class RidgeBenchmark(Predictor, Estimator, Benchmark):
    method setup_cache (line 78) | def setup_cache(self):
    method make_data (line 81) | def make_data(self, params):
    method make_estimator (line 93) | def make_estimator(self, params):
    method make_scorers (line 100) | def make_scorers(self):
    method skip (line 103) | def skip(self, params):
  class LinearRegressionBenchmark (line 111) | class LinearRegressionBenchmark(Predictor, Estimator, Benchmark):
    method setup_cache (line 119) | def setup_cache(self):
    method make_data (line 122) | def make_data(self, params):
    method make_estimator (line 134) | def make_estimator(self, params):
    method make_scorers (line 139) | def make_scorers(self):
  class SGDRegressorBenchmark (line 143) | class SGDRegressorBenchmark(Predictor, Estimator, Benchmark):
    method setup_cache (line 151) | def setup_cache(self):
    method make_data (line 154) | def make_data(self, params):
    method make_estimator (line 166) | def make_estimator(self, params):
    method make_scorers (line 171) | def make_scorers(self):
  class ElasticNetBenchmark (line 175) | class ElasticNetBenchmark(Predictor, Estimator, Benchmark):
    method setup_cache (line 183) | def setup_cache(self):
    method make_data (line 186) | def make_data(self, params):
    method make_estimator (line 198) | def make_estimator(self, params):
    method make_scorers (line 205) | def make_scorers(self):
    method skip (line 208) | def skip(self, params):
  class LassoBenchmark (line 216) | class LassoBenchmark(Predictor, Estimator, Benchmark):
    method setup_cache (line 224) | def setup_cache(self):
    method make_data (line 227) | def make_data(self, params):
    method make_estimator (line 239) | def make_estimator(self, params):
    method make_scorers (line 246) | def make_scorers(self):
    method skip (line 249) | def skip(self, params):

FILE: asv_benchmarks/benchmarks/manifold.py
  class TSNEBenchmark (line 7) | class TSNEBenchmark(Estimator, Benchmark):
    method setup_cache (line 15) | def setup_cache(self):
    method make_data (line 18) | def make_data(self, params):
    method make_estimator (line 25) | def make_estimator(self, params):
    method make_scorers (line 32) | def make_scorers(self):

FILE: asv_benchmarks/benchmarks/metrics.py
  class PairwiseDistancesBenchmark (line 7) | class PairwiseDistancesBenchmark(Benchmark):
    method setup (line 19) | def setup(self, *params):
    method time_pairwise_distances (line 41) | def time_pairwise_distances(self, *args):
    method peakmem_pairwise_distances (line 44) | def peakmem_pairwise_distances(self, *args):

FILE: asv_benchmarks/benchmarks/model_selection.py
  class CrossValidationBenchmark (line 9) | class CrossValidationBenchmark(Benchmark):
    method setup (line 19) | def setup(self, *params):
    method time_crossval (line 31) | def time_crossval(self, *args):
    method peakmem_crossval (line 34) | def peakmem_crossval(self, *args):
    method track_crossval (line 37) | def track_crossval(self, *args):
  class GridSearchBenchmark (line 41) | class GridSearchBenchmark(Predictor, Estimator, Benchmark):
    method setup_cache (line 51) | def setup_cache(self):
    method make_data (line 54) | def make_data(self, params):
    method make_estimator (line 59) | def make_estimator(self, params):
    method make_scorers (line 83) | def make_scorers(self):

FILE: asv_benchmarks/benchmarks/neighbors.py
  class KNeighborsClassifierBenchmark (line 8) | class KNeighborsClassifierBenchmark(Predictor, Estimator, Benchmark):
    method setup_cache (line 16) | def setup_cache(self):
    method make_data (line 19) | def make_data(self, params):
    method make_estimator (line 31) | def make_estimator(self, params):
    method make_scorers (line 38) | def make_scorers(self):

FILE: asv_benchmarks/benchmarks/svm.py
  class SVCBenchmark (line 8) | class SVCBenchmark(Predictor, Estimator, Benchmark):
    method setup_cache (line 14) | def setup_cache(self):
    method make_data (line 17) | def make_data(self, params):
    method make_estimator (line 20) | def make_estimator(self, params):
    method make_scorers (line 29) | def make_scorers(self):

FILE: asv_benchmarks/benchmarks/utils.py
  function neg_mean_inertia (line 6) | def neg_mean_inertia(X, labels, centers):
  function make_gen_classif_scorers (line 10) | def make_gen_classif_scorers(caller):
  function make_gen_reg_scorers (line 15) | def make_gen_reg_scorers(caller):
  function neg_mean_data_error (line 20) | def neg_mean_data_error(X, U, V):
  function make_dict_learning_scorers (line 24) | def make_dict_learning_scorers(caller):
  function explained_variance_ratio (line 39) | def explained_variance_ratio(Xt, X):
  function make_pca_scorers (line 43) | def make_pca_scorers(caller):

FILE: benchmarks/bench_covertype.py
  function load_data (line 72) | def load_data(dtype=np.float32, order="C", random_state=13):

FILE: benchmarks/bench_glmnet.py
  function rmse (line 28) | def rmse(a, b):
  function bench (line 32) | def bench(factory, X, Y, X_test, Y_test, ref_coef):

FILE: benchmarks/bench_hist_gradient_boosting.py
  function get_estimator_and_data (line 53) | def get_estimator_and_data():
  function one_run (line 92) | def one_run(n_samples):

FILE: benchmarks/bench_hist_gradient_boosting_adult.py
  function fit (line 28) | def fit(est, data_train, target_train, libname, **fit_params):
  function predict (line 36) | def predict(est, data_test, target_test):

FILE: benchmarks/bench_hist_gradient_boosting_categorical_only.py
  function fit (line 33) | def fit(est, data_train, target_train, libname, **fit_params):
  function predict (line 41) | def predict(est, data_test):

FILE: benchmarks/bench_hist_gradient_boosting_higgsboson.py
  function load_data (line 41) | def load_data():
  function fit (line 57) | def fit(est, data_train, target_train, libname):
  function predict (line 65) | def predict(est, data_test, target_test):

FILE: benchmarks/bench_hist_gradient_boosting_threading.py
  function get_estimator_and_data (line 69) | def get_estimator_and_data():
  function one_run (line 144) | def one_run(n_threads, n_samples):

FILE: benchmarks/bench_isolation_forest.py
  function print_outlier_ratio (line 32) | def print_outlier_ratio(y):

FILE: benchmarks/bench_isotonic.py
  function generate_perturbed_logarithm_dataset (line 22) | def generate_perturbed_logarithm_dataset(size):
  function generate_logistic_dataset (line 26) | def generate_logistic_dataset(size):
  function generate_pathological_dataset (line 31) | def generate_pathological_dataset(size):
  function bench_isotonic_regression (line 45) | def bench_isotonic_regression(Y):

FILE: benchmarks/bench_lasso.py
  function compute_bench (line 21) | def compute_bench(alpha, n_samples, n_features, precompute):

FILE: benchmarks/bench_mnist.py
  function load_data (line 60) | def load_data(dtype=np.float32, order="F"):

FILE: benchmarks/bench_multilabel_metrics.py
  function benchmark (line 43) | def benchmark(
  function _tabulate (line 106) | def _tabulate(results, metrics, formats):
  function _plot (line 120) | def _plot(

FILE: benchmarks/bench_online_ocsvm.py
  function print_outlier_ratio (line 41) | def print_outlier_ratio(y):
  function autolabel_auc (line 235) | def autolabel_auc(rects, ax):
  function autolabel_time (line 248) | def autolabel_time(rects, ax):

FILE: benchmarks/bench_plot_fastkmeans.py
  function compute_bench (line 10) | def compute_bench(samples_range, features_range):
  function compute_bench_2 (line 57) | def compute_bench_2(chunks):

FILE: benchmarks/bench_plot_hierarchical.py
  function compute_bench (line 10) | def compute_bench(samples_range, features_range):

FILE: benchmarks/bench_plot_incremental_pca.py
  function plot_results (line 19) | def plot_results(X, y, label):
  function benchmark (line 23) | def benchmark(estimator, data):
  function plot_feature_times (line 35) | def plot_feature_times(all_times, batch_size, all_components, data):
  function plot_feature_errors (line 50) | def plot_feature_errors(all_errors, batch_size, all_components, data):
  function plot_batch_times (line 64) | def plot_batch_times(all_times, n_features, all_batch_sizes, data):
  function plot_batch_errors (line 77) | def plot_batch_errors(all_errors, n_features, all_batch_sizes, data):
  function fixed_batch_size_comparison (line 90) | def fixed_batch_size_comparison(data):
  function variable_batch_size_comparison (line 113) | def variable_batch_size_comparison(data):

FILE: benchmarks/bench_plot_lasso_path.py
  function compute_bench (line 17) | def compute_bench(samples_range, features_range):

FILE: benchmarks/bench_plot_neighbors.py
  function get_data (line 13) | def get_data(N, D, dataset="dense"):
  function barplot_neighbors (line 26) | def barplot_neighbors(

FILE: benchmarks/bench_plot_nmf.py
  function _norm (line 42) | def _norm(x):
  function _nls_subproblem (line 49) | def _nls_subproblem(
  function _fit_projected_gradient (line 151) | def _fit_projected_gradient(X, W, H, tol, max_iter, nls_max_iter, alpha,...
  class _PGNMF (line 195) | class _PGNMF(NMF):
    method __init__ (line 203) | def __init__(
    method fit (line 227) | def fit(self, X, y=None, **params):
    method transform (line 231) | def transform(self, X):
    method inverse_transform (line 237) | def inverse_transform(self, W):
    method fit_transform (line 241) | def fit_transform(self, X, y=None, W=None, H=None):
    method _fit_transform (line 246) | def _fit_transform(self, X, y=None, W=None, H=None, update_H=True):
  function plot_results (line 323) | def plot_results(results_df, plot_name):
  function bench_one (line 359) | def bench_one(
  function run_bench (line 376) | def run_bench(X, clfs, plot_name, n_components, tol, alpha, l1_ratio):
  function load_20news (line 414) | def load_20news():
  function load_faces (line 427) | def load_faces():
  function build_clfs (line 436) | def build_clfs(cd_iters, pg_iters, mu_iters):

FILE: benchmarks/bench_plot_omp_lars.py
  function compute_bench (line 16) | def compute_bench(samples_range, features_range):

FILE: benchmarks/bench_plot_parallel_pairwise.py
  function plot (line 12) | def plot(func):
  function euclidean_distances (line 38) | def euclidean_distances(X, n_jobs):
  function rbf_kernels (line 42) | def rbf_kernels(X, n_jobs):

FILE: benchmarks/bench_plot_randomized_svd.py
  function unpickle (line 132) | def unpickle(file_name):
  function handle_missing_dataset (line 137) | def handle_missing_dataset(file_folder):
  function get_data (line 143) | def get_data(dataset_name):
  function plot_time_vs_s (line 197) | def plot_time_vs_s(time, norm, point_labels, title):
  function scatter_time_vs_s (line 221) | def scatter_time_vs_s(time, norm, point_labels, title):
  function plot_power_iter_vs_s (line 260) | def plot_power_iter_vs_s(power_iter, s, title):
  function svd_timing (line 270) | def svd_timing(
  function norm_diff (line 302) | def norm_diff(A, norm=2, msg=True, random_state=None):
  function scalable_frobenius_norm_discrepancy (line 324) | def scalable_frobenius_norm_discrepancy(X, U, s, V):
  function bench_a (line 340) | def bench_a(X, dataset_name, power_iter, n_oversamples, n_comps):
  function bench_b (line 396) | def bench_b(power_list):
  function bench_c (line 443) | def bench_c(datasets, n_comps):

FILE: benchmarks/bench_plot_svd.py
  function compute_bench (line 15) | def compute_bench(samples_range, features_range, n_iter=3, rank=50):

FILE: benchmarks/bench_random_projections.py
  function type_auto_or_float (line 26) | def type_auto_or_float(val):
  function type_auto_or_int (line 33) | def type_auto_or_int(val):
  function compute_time (line 40) | def compute_time(t_start, delta):
  function bench_scikit_transformer (line 46) | def bench_scikit_transformer(X, transformer):
  function make_sparse_random_data (line 70) | def make_sparse_random_data(n_samples, n_features, n_nonzeros, random_st...
  function print_row (line 85) | def print_row(clf_type, time_fit, time_transform):

FILE: benchmarks/bench_rcv1_logreg_convergence.py
  function get_loss (line 25) | def get_loss(w, intercept, myX, myy, C):
  function bench_one (line 38) | def bench_one(name, clf_type, clf_params, n_iter):
  function bench (line 67) | def bench(clfs):
  function plot_train_losses (line 103) | def plot_train_losses(clfs):
  function plot_train_scores (line 112) | def plot_train_scores(clfs):
  function plot_test_scores (line 122) | def plot_test_scores(clfs):
  function plot_dloss (line 132) | def plot_dloss(clfs):
  function get_max_squared_sum (line 150) | def get_max_squared_sum(X):

FILE: benchmarks/bench_saga.py
  function fit_single (line 28) | def fit_single(
  function _predict_proba (line 137) | def _predict_proba(lr, X):
  function exp (line 144) | def exp(
  function plot (line 238) | def plot(outname=None):

FILE: benchmarks/bench_sample_without_replacement.py
  function compute_time (line 18) | def compute_time(t_start, delta):
  function bench_sample (line 24) | def bench_sample(sampling, n_population, n_samples):

FILE: benchmarks/bench_sparsify.py
  function sparsity_ratio (line 54) | def sparsity_ratio(X):
  function benchmark_dense_predict (line 86) | def benchmark_dense_predict():
  function benchmark_sparse_predict (line 91) | def benchmark_sparse_predict():
  function score (line 97) | def score(y_test, y_pred, case):

FILE: benchmarks/bench_text_vectorizers.py
  function run_vectorizer (line 28) | def run_vectorizer(Vectorizer, X, **params):

FILE: benchmarks/bench_tree.py
  function bench_scikit_tree_classifier (line 28) | def bench_scikit_tree_classifier(X, Y):
  function bench_scikit_tree_regressor (line 45) | def bench_scikit_tree_regressor(X, Y):

FILE: benchmarks/bench_tsne_mnist.py
  function load_data (line 35) | def load_data(dtype=np.float32, order="C", shuffle=True, seed=0):
  function nn_accuracy (line 51) | def nn_accuracy(X, X_embedded, k=1):
  function tsne_fit_transform (line 59) | def tsne_fit_transform(model, data):
  function sanitize (line 64) | def sanitize(filename):
  function bhtsne (line 146) | def bhtsne(X):

FILE: build_tools/circle/list_versions.py
  function json_urlread (line 12) | def json_urlread(url):
  function human_readable_data_quantity (line 20) | def human_readable_data_quantity(quantity, multiple=1024):
  function get_file_extension (line 35) | def get_file_extension(version):
  function get_file_size (line 46) | def get_file_size(version):

FILE: build_tools/generate_authors_table.py
  function get (line 25) | def get(url):
  function get_contributors (line 41) | def get_contributors():
  function get_profile (line 97) | def get_profile(login):
  function key (line 122) | def key(profile):
  function generate_table (line 128) | def generate_table(contributors):
  function generate_list (line 149) | def generate_list(contributors):

FILE: build_tools/github/vendor.py
  function make_distributor_init_32_bits (line 22) | def make_distributor_init_32_bits(
  function make_distributor_init_64_bits (line 63) | def make_distributor_init_64_bits(
  function main (line 112) | def main(wheel_dirname, bitness):

FILE: doc/conf.py
  class SubSectionTitleOrder (line 326) | class SubSectionTitleOrder:
    method __init__ (line 333) | def __init__(self, src_dir):
    method __repr__ (line 337) | def __repr__(self):
    method __call__ (line 340) | def __call__(self, directory):
  function make_carousel_thumbs (line 396) | def make_carousel_thumbs(app, exception):
  function filter_search_index (line 410) | def filter_search_index(app, exception):
  function generate_min_dependency_table (line 431) | def generate_min_dependency_table(app):
  function generate_min_dependency_substitutions (line 481) | def generate_min_dependency_substitutions(app):
  function setup (line 504) | def setup(app):

FILE: doc/conftest.py
  function setup_labeled_faces (line 16) | def setup_labeled_faces():
  function setup_rcv1 (line 22) | def setup_rcv1():
  function setup_twenty_newsgroups (line 30) | def setup_twenty_newsgroups():
  function setup_working_with_text_data (line 36) | def setup_working_with_text_data():
  function setup_loading_other_datasets (line 45) | def setup_loading_other_datasets():
  function setup_compose (line 60) | def setup_compose():
  function setup_impute (line 67) | def setup_impute():
  function setup_grid_search (line 74) | def setup_grid_search():
  function setup_preprocessing (line 81) | def setup_preprocessing():
  function setup_unsupervised_learning (line 91) | def setup_unsupervised_learning():
  function skip_if_matplotlib_not_installed (line 102) | def skip_if_matplotlib_not_installed(fname):
  function pytest_runtest_setup (line 110) | def pytest_runtest_setup(item):
  function pytest_configure (line 153) | def pytest_configure(config):

FILE: doc/sphinxext/add_toctree_functions.py
  function add_toctree_functions (line 37) | def add_toctree_functions(app, pagename, templatename, context, doctree):
  function docutils_node_to_jinja (line 94) | def docutils_node_to_jinja(list_item, only_pages=False, numbered=False):
  function setup (line 157) | def setup(app):

FILE: doc/sphinxext/custom_references_resolver.py
  class CustomReferencesResolver (line 42) | class CustomReferencesResolver(ReferencesResolver):
    method resolve_anyref (line 43) | def resolve_anyref(self, refdoc, node, contnode):
    method create_node (line 102) | def create_node(self, result):
  function setup (line 117) | def setup(app):

FILE: doc/sphinxext/doi_role.py
  function reference_role (line 23) | def reference_role(typ, rawtext, text, lineno, inliner, options={}, cont...
  function setup_link_role (line 40) | def setup_link_role(app):
  function setup (line 47) | def setup(app):

FILE: doc/sphinxext/github_link.py
  function _get_git_revision (line 11) | def _get_git_revision():
  function _linkcode_resolve (line 20) | def _linkcode_resolve(domain, info, package, url_fmt, revision):
  function make_linkcode_resolve (line 70) | def make_linkcode_resolve(package, url_fmt):

FILE: doc/sphinxext/sphinx_issues.py
  function user_role (line 32) | def user_role(name, rawtext, text, lineno, inliner, options=None, conten...
  function cve_role (line 61) | def cve_role(name, rawtext, text, lineno, inliner, options=None, content...
  class IssueRole (line 78) | class IssueRole(object):
    method __init__ (line 82) | def __init__(
    method default_format_text (line 91) | def default_format_text(issue_no):
    method make_node (line 94) | def make_node(self, name, issue_no, config, options=None):
    method __call__ (line 133) | def __call__(
  function format_commit_text (line 177) | def format_commit_text(sha):
  function setup (line 195) | def setup(app):

FILE: doc/themes/scikit-learn-modern/static/js/searchtools.js
  function splitQuery (line 56) | function splitQuery(query) {
  function pulse (line 128) | function pulse() {
  function displayNextItem (line 272) | function displayNextItem() {

FILE: doc/tutorial/machine_learning_map/parse_path.py
  function Command (line 18) | def Command(char):
  function Arguments (line 22) | def Arguments(token):
  class CaselessPreservingLiteral (line 26) | class CaselessPreservingLiteral(CaselessLiteral):
    method __init__ (line 30) | def __init__( self, matchString ):
    method parseImpl (line 36) | def parseImpl( self, instring, loc, doActions=True ):
  function Sequence (line 46) | def Sequence(token):
  function convertToFloat (line 54) | def convertToFloat(s, loc, toks):
  function get_points (line 149) | def get_points(d):

FILE: doc/tutorial/machine_learning_map/pyparsing.py
  function _ustr (line 132) | def _ustr(obj):
  function _xml_escape (line 163) | def _xml_escape(data):
  class _Constants (line 173) | class _Constants(object):
  class ParseBaseException (line 183) | class ParseBaseException(Exception):
    method __init__ (line 187) | def __init__( self, pstr, loc=0, msg=None, elem=None ):
    method _from_exception (line 199) | def _from_exception(cls, pe):
    method __getattr__ (line 206) | def __getattr__( self, aname ):
    method __str__ (line 221) | def __str__( self ):
    method __repr__ (line 224) | def __repr__( self ):
    method markInputline (line 226) | def markInputline( self, markerString = ">!<" ):
    method __dir__ (line 236) | def __dir__(self):
  class ParseException (line 239) | class ParseException(ParseBaseException):
  class ParseFatalException (line 260) | class ParseFatalException(ParseBaseException):
  class ParseSyntaxException (line 265) | class ParseSyntaxException(ParseFatalException):
  class RecursiveGrammarException (line 284) | class RecursiveGrammarException(Exception):
    method __init__ (line 286) | def __init__( self, parseElementList ):
    method __str__ (line 289) | def __str__( self ):
  class _ParseResultsWithOffset (line 292) | class _ParseResultsWithOffset(object):
    method __init__ (line 293) | def __init__(self,p1,p2):
    method __getitem__ (line 295) | def __getitem__(self,i):
    method __repr__ (line 297) | def __repr__(self):
    method setOffset (line 299) | def setOffset(self,i):
  class ParseResults (line 302) | class ParseResults(object):
    method __new__ (line 341) | def __new__(cls, toklist=None, name=None, asList=True, modal=True ):
    method __init__ (line 350) | def __init__( self, toklist=None, name=None, asList=True, modal=True, ...
    method __getitem__ (line 389) | def __getitem__( self, i ):
    method __setitem__ (line 398) | def __setitem__( self, k, v, isinstance=isinstance ):
    method __delitem__ (line 411) | def __delitem__( self, i ):
    method __contains__ (line 432) | def __contains__( self, k ):
    method __len__ (line 435) | def __len__( self ): return len( self.__toklist )
    method __bool__ (line 436) | def __bool__(self): return ( not not self.__toklist )
    method __iter__ (line 438) | def __iter__( self ): return iter( self.__toklist )
    method __reversed__ (line 439) | def __reversed__( self ): return iter( self.__toklist[::-1] )
    method _iterkeys (line 440) | def _iterkeys( self ):
    method _itervalues (line 446) | def _itervalues( self ):
    method _iteritems (line 449) | def _iteritems( self ):
    method keys (line 472) | def keys( self ):
    method values (line 476) | def values( self ):
    method items (line 480) | def items( self ):
    method haskeys (line 484) | def haskeys( self ):
    method pop (line 489) | def pop( self, *args, **kwargs):
    method get (line 541) | def get(self, key, defaultValue=None):
    method insert (line 563) | def insert( self, index, insStr ):
    method append (line 583) | def append( self, item ):
    method extend (line 597) | def extend( self, itemseq ):
    method clear (line 615) | def clear( self ):
    method __getattr__ (line 622) | def __getattr__( self, name ):
    method __add__ (line 636) | def __add__( self, other ):
    method __iadd__ (line 641) | def __iadd__( self, other ):
    method __radd__ (line 657) | def __radd__(self, other):
    method __repr__ (line 665) | def __repr__( self ):
    method __str__ (line 668) | def __str__( self ):
    method _asStringList (line 671) | def _asStringList( self, sep='' ):
    method asList (line 682) | def asList( self ):
    method asDict (line 698) | def asDict( self ):
    method copy (line 733) | def copy( self ):
    method asXML (line 744) | def asXML( self, doctag=None, namedItemsOnly=False, indent="", formatt...
    method __lookup (line 805) | def __lookup(self,sub):
    method getName (line 812) | def getName(self):
    method dump (line 849) | def dump(self, indent='', depth=0, full=True):
    method pprint (line 894) | def pprint(self, *args, **kwargs):
    method __getstate__ (line 918) | def __getstate__(self):
    method __setstate__ (line 925) | def __setstate__(self,state):
    method __getnewargs__ (line 938) | def __getnewargs__(self):
    method __dir__ (line 941) | def __dir__(self):
  function col (line 946) | def col (loc,strg):
  function lineno (line 959) | def lineno(loc,strg):
  function line (line 971) | def line( loc, strg ):
  function _defaultStartDebugAction (line 981) | def _defaultStartDebugAction( instring, loc, expr ):
  function _defaultSuccessDebugAction (line 984) | def _defaultSuccessDebugAction( instring, startloc, endloc, expr, toks ):
  function _defaultExceptionDebugAction (line 987) | def _defaultExceptionDebugAction( instring, loc, expr, exc ):
  function nullDebugAction (line 990) | def nullDebugAction(*args):
  function _trim_arity (line 1017) | def _trim_arity(func, maxargs=2):
  class ParserElement (line 1075) | class ParserElement(object):
    method setDefaultWhitespaceChars (line 1081) | def setDefaultWhitespaceChars( chars ):
    method inlineLiteralsUsing (line 1096) | def inlineLiteralsUsing(cls):
    method __init__ (line 1116) | def __init__( self, savelist=False ):
    method copy (line 1139) | def copy( self ):
    method setName (line 1162) | def setName( self, name ):
    method setResultsName (line 1176) | def setResultsName( self, name, listAllMatches=False ):
    method setBreak (line 1204) | def setBreak(self,breakFlag = True):
    method setParseAction (line 1222) | def setParseAction( self, *fns, **kwargs ):
    method addParseAction (line 1260) | def addParseAction( self, *fns, **kwargs ):
    method addCondition (line 1270) | def addCondition(self, *fns, **kwargs):
    method setFailAction (line 1297) | def setFailAction( self, fn ):
    method _skipIgnorables (line 1310) | def _skipIgnorables( self, instring, loc ):
    method preParse (line 1323) | def preParse( self, instring, loc ):
    method parseImpl (line 1335) | def parseImpl( self, instring, loc, doActions=True ):
    method postParse (line 1338) | def postParse( self, instring, loc, tokenlist ):
    method _parseNoCache (line 1342) | def _parseNoCache( self, instring, loc, doActions=True, callPreParse=T...
    method tryParse (line 1414) | def tryParse( self, instring, loc ):
    method canParseNext (line 1420) | def canParseNext(self, instring, loc):
    class _UnboundedCache (line 1428) | class _UnboundedCache(object):
      method __init__ (line 1429) | def __init__(self):
    class _FifoCache (line 1451) | class _FifoCache(object):
      method __init__ (line 1452) | def __init__(self, size):
      method __init__ (line 1481) | def __init__(self, size):
    class _FifoCache (line 1480) | class _FifoCache(object):
      method __init__ (line 1452) | def __init__(self, size):
      method __init__ (line 1481) | def __init__(self, size):
    method _parseCache (line 1515) | def _parseCache( self, instring, loc, doActions=True, callPreParse=Tru...
    method resetCache (line 1541) | def resetCache():
    method enablePackrat (line 1547) | def enablePackrat(cache_size_limit=128):
    method parseString (line 1581) | def parseString( self, instring, parseAll=False ):
    method scanString (line 1631) | def scanString( self, instring, maxMatches=_MAX_INT, overlap=False ):
    method transformString (line 1702) | def transformString( self, instring ):
    method searchString (line 1745) | def searchString( self, instring, maxMatches=_MAX_INT ):
    method split (line 1772) | def split(self, instring, maxsplit=_MAX_INT, includeSeparators=False):
    method __add__ (line 1794) | def __add__(self, other ):
    method __radd__ (line 1814) | def __radd__(self, other ):
    method __sub__ (line 1826) | def __sub__(self, other):
    method __rsub__ (line 1838) | def __rsub__(self, other ):
    method __mul__ (line 1850) | def __mul__(self,other):
    method __rmul__ (line 1918) | def __rmul__(self, other):
    method __or__ (line 1921) | def __or__(self, other ):
    method __ror__ (line 1933) | def __ror__(self, other ):
    method __xor__ (line 1945) | def __xor__(self, other ):
    method __rxor__ (line 1957) | def __rxor__(self, other ):
    method __and__ (line 1969) | def __and__(self, other ):
    method __rand__ (line 1981) | def __rand__(self, other ):
    method __invert__ (line 1993) | def __invert__( self ):
    method __call__ (line 1999) | def __call__(self, name=None):
    method suppress (line 2018) | def suppress( self ):
    method leaveWhitespace (line 2025) | def leaveWhitespace( self ):
    method setWhitespaceChars (line 2034) | def setWhitespaceChars( self, chars ):
    method parseWithTabs (line 2043) | def parseWithTabs( self ):
    method ignore (line 2052) | def ignore( self, other ):
    method setDebugActions (line 2075) | def setDebugActions( self, startAction, successAction, exceptionAction ):
    method setDebug (line 2085) | def setDebug( self, flag=True ):
    method __str__ (line 2126) | def __str__( self ):
    method __repr__ (line 2129) | def __repr__( self ):
    method streamline (line 2132) | def streamline( self ):
    method checkRecursion (line 2137) | def checkRecursion( self, parseElementList ):
    method validate (line 2140) | def validate( self, validateTrace=[] ):
    method parseFile (line 2146) | def parseFile( self, file_or_filename, parseAll=False ):
    method __eq__ (line 2166) | def __eq__(self,other):
    method __ne__ (line 2174) | def __ne__(self,other):
    method __hash__ (line 2177) | def __hash__(self):
    method __req__ (line 2180) | def __req__(self,other):
    method __rne__ (line 2183) | def __rne__(self,other):
    method matches (line 2186) | def matches(self, testString, parseAll=True):
    method runTests (line 2205) | def runTests(self, tests, parseAll=True, comment='#', fullDump=True, p...
  class Token (line 2337) | class Token(ParserElement):
    method __init__ (line 2341) | def __init__( self ):
  class Empty (line 2345) | class Empty(Token):
    method __init__ (line 2349) | def __init__( self ):
  class NoMatch (line 2356) | class NoMatch(Token):
    method __init__ (line 2360) | def __init__( self ):
    method parseImpl (line 2367) | def parseImpl( self, instring, loc, doActions=True ):
  class Literal (line 2371) | class Literal(Token):
    method __init__ (line 2385) | def __init__( self, matchString ):
    method parseImpl (line 2404) | def parseImpl( self, instring, loc, doActions=True ):
  class Keyword (line 2412) | class Keyword(Token):
    method __init__ (line 2431) | def __init__( self, matchString, identChars=None, caseless=False ):
    method parseImpl (line 2452) | def parseImpl( self, instring, loc, doActions=True ):
    method copy (line 2466) | def copy(self):
    method setDefaultKeywordChars (line 2472) | def setDefaultKeywordChars( chars ):
  class CaselessLiteral (line 2477) | class CaselessLiteral(Literal):
    method __init__ (line 2488) | def __init__( self, matchString ):
    method parseImpl (line 2495) | def parseImpl( self, instring, loc, doActions=True ):
  class CaselessKeyword (line 2500) | class CaselessKeyword(Keyword):
    method __init__ (line 2509) | def __init__( self, matchString, identChars=None ):
    method parseImpl (line 2512) | def parseImpl( self, instring, loc, doActions=True ):
  class CloseMatch (line 2518) | class CloseMatch(Token):
    method __init__ (line 2543) | def __init__(self, match_string, maxMismatches=1):
    method parseImpl (line 2552) | def parseImpl( self, instring, loc, doActions=True ):
  class Word (line 2579) | class Word(Token):
    method __init__ (line 2626) | def __init__( self, initChars, bodyChars=None, min=1, max=0, exact=0, ...
    method parseImpl (line 2680) | def parseImpl( self, instring, loc, doActions=True ):
    method __str__ (line 2715) | def __str__( self ):
  class Regex (line 2738) | class Regex(Token):
    method __init__ (line 2752) | def __init__( self, pattern, flags=0):
    method parseImpl (line 2786) | def parseImpl( self, instring, loc, doActions=True ):
    method __str__ (line 2799) | def __str__( self ):
  class QuotedString (line 2811) | class QuotedString(Token):
    method __init__ (line 2836) | def __init__( self, quoteChar, escChar=None, escQuote=None, multiline=...
    method parseImpl (line 2901) | def parseImpl( self, instring, loc, doActions=True ):
    method __str__ (line 2936) | def __str__( self ):
  class CharsNotIn (line 2948) | class CharsNotIn(Token):
    method __init__ (line 2964) | def __init__( self, notChars, min=1, max=0, exact=0 ):
    method parseImpl (line 2988) | def parseImpl( self, instring, loc, doActions=True ):
    method __str__ (line 3005) | def __str__( self ):
  class White (line 3019) | class White(Token):
    method __init__ (line 3034) | def __init__(self, ws=" \t\r\n", min=1, max=0, exact=0):
    method parseImpl (line 3054) | def parseImpl( self, instring, loc, doActions=True ):
  class _PositionToken (line 3070) | class _PositionToken(Token):
    method __init__ (line 3071) | def __init__( self ):
  class GoToColumn (line 3077) | class GoToColumn(_PositionToken):
    method __init__ (line 3081) | def __init__( self, colno ):
    method preParse (line 3085) | def preParse( self, instring, loc ):
    method parseImpl (line 3094) | def parseImpl( self, instring, loc, doActions=True ):
  class LineStart (line 3103) | class LineStart(_PositionToken):
    method __init__ (line 3124) | def __init__( self ):
    method parseImpl (line 3128) | def parseImpl( self, instring, loc, doActions=True ):
  class LineEnd (line 3133) | class LineEnd(_PositionToken):
    method __init__ (line 3137) | def __init__( self ):
    method parseImpl (line 3142) | def parseImpl( self, instring, loc, doActions=True ):
  class StringStart (line 3153) | class StringStart(_PositionToken):
    method __init__ (line 3157) | def __init__( self ):
    method parseImpl (line 3161) | def parseImpl( self, instring, loc, doActions=True ):
  class StringEnd (line 3168) | class StringEnd(_PositionToken):
    method __init__ (line 3172) | def __init__( self ):
    method parseImpl (line 3176) | def parseImpl( self, instring, loc, doActions=True ):
  class WordStart (line 3186) | class WordStart(_PositionToken):
    method __init__ (line 3194) | def __init__(self, wordChars = printables):
    method parseImpl (line 3199) | def parseImpl(self, instring, loc, doActions=True ):
  class WordEnd (line 3206) | class WordEnd(_PositionToken):
    method __init__ (line 3214) | def __init__(self, wordChars = printables):
    method parseImpl (line 3220) | def parseImpl(self, instring, loc, doActions=True ):
  class ParseExpression (line 3229) | class ParseExpression(ParserElement):
    method __init__ (line 3233) | def __init__( self, exprs, savelist = False ):
    method __getitem__ (line 3253) | def __getitem__( self, i ):
    method append (line 3256) | def append( self, other ):
    method leaveWhitespace (line 3261) | def leaveWhitespace( self ):
    method ignore (line 3270) | def ignore( self, other ):
    method __str__ (line 3282) | def __str__( self ):
    method streamline (line 3292) | def streamline( self ):
    method setResultsName (line 3326) | def setResultsName( self, name, listAllMatches=False ):
    method validate (line 3330) | def validate( self, validateTrace=[] ):
    method copy (line 3336) | def copy(self):
  class And (line 3341) | class And(ParseExpression):
    class _ErrorStop (line 3357) | class _ErrorStop(Empty):
      method __init__ (line 3358) | def __init__(self, *args, **kwargs):
    method __init__ (line 3363) | def __init__( self, exprs, savelist = True ):
    method parseImpl (line 3370) | def parseImpl( self, instring, loc, doActions=True ):
    method __iadd__ (line 3395) | def __iadd__(self, other ):
    method checkRecursion (line 3400) | def checkRecursion( self, parseElementList ):
    method __str__ (line 3407) | def __str__( self ):
  class Or (line 3417) | class Or(ParseExpression):
    method __init__ (line 3431) | def __init__( self, exprs, savelist = False ):
    method parseImpl (line 3438) | def parseImpl( self, instring, loc, doActions=True ):
    method __ixor__ (line 3476) | def __ixor__(self, other ):
    method __str__ (line 3481) | def __str__( self ):
    method checkRecursion (line 3490) | def checkRecursion( self, parseElementList ):
  class MatchFirst (line 3496) | class MatchFirst(ParseExpression):
    method __init__ (line 3513) | def __init__( self, exprs, savelist = False ):
    method parseImpl (line 3520) | def parseImpl( self, instring, loc, doActions=True ):
    method __ior__ (line 3544) | def __ior__(self, other ):
    method __str__ (line 3549) | def __str__( self ):
    method checkRecursion (line 3558) | def checkRecursion( self, parseElementList ):
  class Each (line 3564) | class Each(ParseExpression):
    method __init__ (line 3618) | def __init__( self, exprs, savelist = True ):
    method parseImpl (line 3624) | def parseImpl( self, instring, loc, doActions=True ):
    method __str__ (line 3673) | def __str__( self ):
    method checkRecursion (line 3682) | def checkRecursion( self, parseElementList ):
  class ParseElementEnhance (line 3688) | class ParseElementEnhance(ParserElement):
    method __init__ (line 3692) | def __init__( self, expr, savelist=False ):
    method parseImpl (line 3710) | def parseImpl( self, instring, loc, doActions=True ):
    method leaveWhitespace (line 3716) | def leaveWhitespace( self ):
    method ignore (line 3723) | def ignore( self, other ):
    method streamline (line 3735) | def streamline( self ):
    method checkRecursion (line 3741) | def checkRecursion( self, parseElementList ):
    method validate (line 3748) | def validate( self, validateTrace=[] ):
    method __str__ (line 3754) | def __str__( self ):
  class FollowedBy (line 3765) | class FollowedBy(ParseElementEnhance):
    method __init__ (line 3782) | def __init__( self, expr ):
    method parseImpl (line 3786) | def parseImpl( self, instring, loc, doActions=True ):
  class NotAny (line 3791) | class NotAny(ParseElementEnhance):
    method __init__ (line 3802) | def __init__( self, expr ):
    method parseImpl (line 3809) | def parseImpl( self, instring, loc, doActions=True ):
    method __str__ (line 3814) | def __str__( self ):
  class _MultipleMatch (line 3823) | class _MultipleMatch(ParseElementEnhance):
    method __init__ (line 3824) | def __init__( self, expr, stopOn=None):
    method parseImpl (line 3832) | def parseImpl( self, instring, loc, doActions=True ):
  class OneOrMore (line 3861) | class OneOrMore(_MultipleMatch):
    method __str__ (line 3887) | def __str__( self ):
  class ZeroOrMore (line 3896) | class ZeroOrMore(_MultipleMatch):
    method __init__ (line 3908) | def __init__( self, expr, stopOn=None):
    method parseImpl (line 3912) | def parseImpl( self, instring, loc, doActions=True ):
    method __str__ (line 3918) | def __str__( self ):
  class _NullToken (line 3927) | class _NullToken(object):
    method __bool__ (line 3928) | def __bool__(self):
    method __str__ (line 3931) | def __str__(self):
  class Optional (line 3935) | class Optional(ParseElementEnhance):
    method __init__ (line 3970) | def __init__( self, expr, default=_optionalNotMatched ):
    method parseImpl (line 3976) | def parseImpl( self, instring, loc, doActions=True ):
    method __str__ (line 3990) | def __str__( self ):
  class SkipTo (line 3999) | class SkipTo(ParseElementEnhance):
    method __init__ (line 4054) | def __init__( self, other, include=False, ignore=None, failOn=None ):
    method parseImpl (line 4067) | def parseImpl( self, instring, loc, doActions=True ):
  class Forward (line 4114) | class Forward(ParseElementEnhance):
    method __init__ (line 4133) | def __init__( self, other=None ):
    method __lshift__ (line 4136) | def __lshift__( self, other ):
    method __ilshift__ (line 4149) | def __ilshift__(self, other):
    method leaveWhitespace (line 4152) | def leaveWhitespace( self ):
    method streamline (line 4156) | def streamline( self ):
    method validate (line 4163) | def validate( self, validateTrace=[] ):
    method __str__ (line 4170) | def __str__( self ):
    method copy (line 4187) | def copy(self):
  class _ForwardNoRecurse (line 4195) | class _ForwardNoRecurse(Forward):
    method __str__ (line 4196) | def __str__( self ):
  class TokenConverter (line 4199) | class TokenConverter(ParseElementEnhance):
    method __init__ (line 4203) | def __init__( self, expr, savelist=False ):
  class Combine (line 4207) | class Combine(TokenConverter):
    method __init__ (line 4224) | def __init__( self, expr, joinString="", adjacent=True ):
    method ignore (line 4234) | def ignore( self, other ):
    method postParse (line 4241) | def postParse( self, instring, loc, tokenlist ):
  class Group (line 4251) | class Group(TokenConverter):
    method __init__ (line 4265) | def __init__( self, expr ):
    method postParse (line 4269) | def postParse( self, instring, loc, tokenlist ):
  class Dict (line 4272) | class Dict(TokenConverter):
    method __init__ (line 4308) | def __init__( self, expr ):
    method postParse (line 4312) | def postParse( self, instring, loc, tokenlist ):
  class Suppress (line 4337) | class Suppress(TokenConverter):
    method postParse (line 4356) | def postParse( self, instring, loc, tokenlist ):
    method suppress (line 4359) | def suppress( self ):
  class OnlyOnce (line 4363) | class OnlyOnce(object):
    method __init__ (line 4367) | def __init__(self, methodCall):
    method __call__ (line 4370) | def __call__(self,s,l,t):
    method reset (line 4376) | def reset(self):
  function traceParseAction (line 4379) | def traceParseAction(f):
  function delimitedList (line 4423) | def delimitedList( expr, delim=",", combine=False ):
  function countedArray (line 4442) | def countedArray( expr, intExpr=None ):
  function _flatten (line 4473) | def _flatten(L):
  function matchPreviousLiteral (line 4482) | def matchPreviousLiteral(expr):
  function matchPreviousExpr (line 4510) | def matchPreviousExpr(expr):
  function _escapeRegexRangeChars (line 4538) | def _escapeRegexRangeChars(s):
  function oneOf (line 4546) | def oneOf( strs, caseless=False, useRegex=True ):
  function dictOf (line 4619) | def dictOf( key, value ):
  function originalTextFor (line 4654) | def originalTextFor(expr, asString=True):
  function ungroup (line 4691) | def ungroup(expr):
  function locatedExpr (line 4698) | def locatedExpr(expr):
  function srange (line 4736) | def srange(s):
  function matchOnlyAtCol (line 4760) | def matchOnlyAtCol(n):
  function replaceWith (line 4770) | def replaceWith(replStr):
  function removeQuotes (line 4784) | def removeQuotes(s,l,t):
  function tokenMap (line 4798) | def tokenMap(func, *args):
  function _makeTags (line 4848) | def _makeTags(tagStr, xml):
  function makeHTMLTags (line 4877) | def makeHTMLTags(tagStr):
  function makeXMLTags (line 4896) | def makeXMLTags(tagStr):
  function withAttribute (line 4905) | def withAttribute(*args,**attrDict):
  function withClass (line 4970) | def withClass(classname, namespace=''):
  function infixNotation (line 5009) | def infixNotation( baseExpr, opList, lpar=Suppress('('), rpar=Suppress('...
  function nestedExpr (line 5130) | def nestedExpr(opener="(", closer=")", content=None, ignoreExpr=quotedSt...
  function indentedBlock (line 5220) | def indentedBlock(blockStatementExpr, indentStack, indent=True):
  function replaceHTMLEntity (line 5340) | def replaceHTMLEntity(t):
  class pyparsing_common (line 5372) | class pyparsing_common:
    method convertToDate (line 5566) | def convertToDate(fmt="%Y-%m-%d"):
    method convertToDatetime (line 5588) | def convertToDatetime(fmt="%Y-%m-%dT%H:%M:%S.%f"):
    method stripHTMLTags (line 5620) | def stripHTMLTags(s, l, tokens):

FILE: examples/applications/plot_cyclical_feature_engineering.py
  function evaluate (line 222) | def evaluate(model, X, y, cv):
  function sin_transformer (line 354) | def sin_transformer(period):
  function cos_transformer (line 358) | def cos_transformer(period):
  function periodic_spline_transformer (line 431) | def periodic_spline_transformer(period, n_splines=None, degree=3):

FILE: examples/applications/plot_digits_denoising.py
  function plot_digits (line 73) | def plot_digits(X, title):

FILE: examples/applications/plot_face_recognition.py
  function plot_gallery (line 134) | def plot_gallery(images, titles, h, w, n_row=3, n_col=4):
  function title (line 149) | def title(y_pred, y_test, target_names, i):

FILE: examples/applications/plot_model_complexity_influence.py
  function generate_data (line 71) | def generate_data(case):
  function benchmark_influence (line 102) | def benchmark_influence(conf):
  function _count_nonzero_coefficients (line 154) | def _count_nonzero_coefficients(estimator):
  function plot_influence (line 228) | def plot_influence(conf, mse_values, prediction_times, complexities):

FILE: examples/applications/plot_out_of_core_classification.py
  function _not_in_sphinx (line 43) | def _not_in_sphinx():
  class ReutersParser (line 57) | class ReutersParser(HTMLParser):
    method __init__ (line 60) | def __init__(self, encoding="latin-1"):
    method handle_starttag (line 65) | def handle_starttag(self, tag, attrs):
    method handle_endtag (line 69) | def handle_endtag(self, tag):
    method _reset (line 73) | def _reset(self):
    method parse (line 83) | def parse(self, fd):
    method handle_data (line 92) | def handle_data(self, data):
    method start_reuters (line 100) | def start_reuters(self, attributes):
    method end_reuters (line 103) | def end_reuters(self):
    method start_title (line 110) | def start_title(self, attributes):
    method end_title (line 113) | def end_title(self):
    method start_body (line 116) | def start_body(self, attributes):
    method end_body (line 119) | def end_body(self):
    method start_topics (line 122) | def start_topics(self, attributes):
    method end_topics (line 125) | def end_topics(self):
    method start_d (line 128) | def start_d(self, attributes):
    method end_d (line 131) | def end_d(self):
  function stream_reuters_documents (line 137) | def stream_reuters_documents(data_path=None):
  function get_minibatch (line 212) | def get_minibatch(doc_iter, size, pos_class=positive_class):
  function iter_minibatches (line 229) | def iter_minibatches(doc_iter, minibatch_size):
  function progress (line 253) | def progress(cls_name, stats):
  function plot_accuracy (line 336) | def plot_accuracy(x, y, x_legend):
  function autolabel (line 389) | def autolabel(rectangles):

FILE: examples/applications/plot_prediction_latency.py
  function _not_in_sphinx (line 36) | def _not_in_sphinx():
  function atomic_benchmark_estimator (line 41) | def atomic_benchmark_estimator(estimator, X_test, verbose=False):
  function bulk_benchmark_estimator (line 60) | def bulk_benchmark_estimator(estimator, X_test, n_bulk_repeats, verbose):
  function benchmark_estimator (line 79) | def benchmark_estimator(estimator, X_test, n_bulk_repeats=30, verbose=Fa...
  function generate_dataset (line 100) | def generate_dataset(n_train, n_test, n_features, noise=0.1, verbose=Fal...
  function boxplot_runtimes (line 129) | def boxplot_runtimes(runtimes, pred_type, configuration):
  function benchmark (line 172) | def benchmark(configuration):
  function n_feature_influence (line 195) | def n_feature_influence(estimators, n_train, n_test, n_features, percent...
  function plot_n_features_influence (line 227) | def plot_n_features_influence(percentiles, percentile):
  function benchmark_throughputs (line 246) | def benchmark_throughputs(configuration, duration_secs=0.1):
  function plot_benchmark_throughput (line 263) | def plot_benchmark_throughput(throughputs, configuration):

FILE: examples/applications/plot_species_distribution_modeling.py
  function construct_grids (line 63) | def construct_grids(batch):
  function create_species_bunch (line 90) | def create_species_bunch(species_name, train, test, coverages, xgrid, yg...
  function plot_species_distribution (line 113) | def plot_species_distribution(

FILE: examples/applications/plot_tomography_l1_reconstruction.py
  function _weights (line 50) | def _weights(x, dx=1, orig=0):
  function _generate_center_coordinates (line 57) | def _generate_center_coordinates(l_x):
  function build_projection_operator (line 65) | def build_projection_operator(l_x, n_dir):
  function generate_synthetic_data (line 97) | def generate_synthetic_data():

FILE: examples/applications/plot_topics_extraction_with_nmf_lda.py
  function plot_top_words (line 42) | def plot_top_words(model, feature_names, n_top_words, title):

FILE: examples/applications/svm_gui.py
  class Model (line 47) | class Model:
    method __init__ (line 53) | def __init__(self):
    method changed (line 60) | def changed(self, event):
    method add_observer (line 65) | def add_observer(self, observer):
    method set_surface (line 69) | def set_surface(self, surface):
    method dump_svmlight_file (line 72) | def dump_svmlight_file(self, file):
  class Controller (line 79) | class Controller:
    method __init__ (line 80) | def __init__(self, model):
    method fit (line 87) | def fit(self):
    method decision_surface (line 124) | def decision_surface(self, cls):
    method clear_data (line 133) | def clear_data(self):
    method add_example (line 138) | def add_example(self, x, y, label):
    method refit (line 145) | def refit(self):
  class View (line 151) | class View:
    method __init__ (line 154) | def __init__(self, root, controller):
    method plot_kernels (line 181) | def plot_kernels(self):
    method onclick (line 186) | def onclick(self, event):
    method update_example (line 193) | def update_example(self, model, idx):
    method update (line 201) | def update(self, event, model):
    method remove_surface (line 224) | def remove_surface(self):
    method plot_support_vectors (line 235) | def plot_support_vectors(self, support_vectors):
    method plot_decision_surface (line 248) | def plot_decision_surface(self, surface, type):
  class ControllBar (line 270) | class ControllBar:
    method __init__ (line 271) | def __init__(self, root, controller):
  function get_parser (line 353) | def get_parser():
  function main (line 367) | def main(argv):

FILE: examples/applications/wikipedia_principal_eigenvector.py
  function index (line 75) | def index(redirects, index_map, k):
  function short_name (line 85) | def short_name(nt_uri):
  function get_redirects (line 90) | def get_redirects(redirects_filename):
  function get_adjacency_matrix (line 122) | def get_adjacency_matrix(redirects_filename, page_links_filename, limit=...
  function centrality_scores (line 181) | def centrality_scores(X, alpha=0.85, max_iter=100, tol=1e-10):

FILE: examples/bicluster/plot_bicluster_newsgroups.py
  function number_normalizer (line 39) | def number_normalizer(tokens):
  class NumberNormalizingVectorizer (line 49) | class NumberNormalizingVectorizer(TfidfVectorizer):
    method build_tokenizer (line 50) | def build_tokenizer(self):
  function bicluster_ncut (line 112) | def bicluster_ncut(i):
  function most_common (line 127) | def most_common(d):

FILE: examples/calibration/plot_calibration_curve.py
  class NaivelyCalibratedLinearSVC (line 203) | class NaivelyCalibratedLinearSVC(LinearSVC):
    method fit (line 207) | def fit(self, X, y):
    method predict_proba (line 213) | def predict_proba(self, X):

FILE: examples/calibration/plot_compare_calibration.py
  class NaivelyCalibratedLinearSVC (line 65) | class NaivelyCalibratedLinearSVC(LinearSVC):
    method fit (line 69) | def fit(self, X, y):
    method predict_proba (line 75) | def predict_proba(self, X):

FILE: examples/classification/plot_lda.py
  function generate_data (line 26) | def generate_data(n_samples, n_features):

FILE: examples/classification/plot_lda_qda.py
  function dataset_fixed_cov (line 38) | def dataset_fixed_cov():
  function dataset_cov (line 51) | def dataset_cov():
  function plot_data (line 66) | def plot_data(lda, X, y, y_pred, fig_index):
  function plot_ellipse (line 125) | def plot_ellipse(splot, mean, cov, color):
  function plot_lda_cov (line 147) | def plot_lda_cov(lda, splot):
  function plot_qda_cov (line 152) | def plot_qda_cov(qda, splot):

FILE: examples/cluster/plot_adjusted_for_chance_measures.py
  function uniform_labelings_scores (line 33) | def uniform_labelings_scores(
  function ami_score (line 59) | def ami_score(U, V):

FILE: examples/cluster/plot_agglomerative_clustering_metrics.py
  function sqr (line 53) | def sqr(x):

FILE: examples/cluster/plot_agglomerative_dendrogram.py
  function plot_dendrogram (line 20) | def plot_dendrogram(model, **kwargs):

FILE: examples/cluster/plot_color_quantization.py
  function recreate_image (line 72) | def recreate_image(codebook, labels, w, h):

FILE: examples/cluster/plot_digits_linkage.py
  function plot_clustering (line 48) | def plot_clustering(X_red, labels, title=None):

FILE: examples/cluster/plot_inductive_clustering.py
  function _classifier_has (line 40) | def _classifier_has(attr):
  class InductiveClusterer (line 53) | class InductiveClusterer(BaseEstimator):
    method __init__ (line 54) | def __init__(self, clusterer, classifier):
    method fit (line 58) | def fit(self, X, y=None):
    method predict (line 66) | def predict(self, X):
    method decision_function (line 71) | def decision_function(self, X):
  function plot_scatter (line 76) | def plot_scatter(X, color, alpha=0.5):

FILE: examples/cluster/plot_kmeans_digits.py
  function bench_k_means (line 61) | def bench_k_means(kmeans, name, data, labels):

FILE: examples/cluster/plot_kmeans_stability_low_dim_dense.py
  function make_data (line 55) | def make_data(random_state, n_samples_per_center, grid_size, scale):

FILE: examples/compose/plot_column_transformer.py
  function subject_body_extractor (line 81) | def subject_body_extractor(posts):
  function text_stats (line 110) | def text_stats(posts):

FILE: examples/datasets/plot_random_multilabel_dataset.py
  function plot_2d (line 61) | def plot_2d(ax, n_labels=1, n_classes=3, length=50):

FILE: examples/decomposition/plot_faces_decomposition.py
  function plot_gallery (line 47) | def plot_gallery(title, images, n_col=n_col, n_row=n_row, cmap=plt.cm.gr...

FILE: examples/decomposition/plot_ica_vs_pca.py
  function plot_samples (line 64) | def plot_samples(S, axis_list=None):

FILE: examples/decomposition/plot_image_denoising.py
  function show_with_diff (line 105) | def show_with_diff(image, reference, title):

FILE: examples/decomposition/plot_pca_3d.py
  function pdf (line 33) | def pdf(x):
  function plot_figs (line 57) | def plot_figs(fig_num, elev, azim):

FILE: examples/decomposition/plot_pca_vs_fa_model_selection.py
  function compute_scores (line 63) | def compute_scores(X):
  function shrunk_cov_score (line 77) | def shrunk_cov_score(X):
  function lw_score (line 83) | def lw_score(X):

FILE: examples/decomposition/plot_sparse_coding.py
  function ricker_function (line 26) | def ricker_function(resolution, center, width):
  function ricker_matrix (line 37) | def ricker_matrix(width, resolution, n_components):

FILE: examples/ensemble/plot_bias_variance.py
  function f (line 94) | def f(x):
  function generate (line 100) | def generate(n_samples, noise, n_repeat=1):

FILE: examples/ensemble/plot_feature_transformation.py
  function rf_apply (line 111) | def rf_apply(X, model):
  function gbdt_apply (line 126) | def gbdt_apply(X, model):

FILE: examples/ensemble/plot_gradient_boosting_categorical.py
  function plot_results (line 143) | def plot_results(figure_title):

FILE: examples/ensemble/plot_gradient_boosting_early_stopping.py
  function autolabel (line 113) | def autolabel(rects, n_estimators):

FILE: examples/ensemble/plot_gradient_boosting_oob.py
  function heldout_score (line 75) | def heldout_score(clf, X_test, y_test):
  function cv_estimate (line 83) | def cv_estimate(n_splits=None):

FILE: examples/ensemble/plot_gradient_boosting_quantile.py
  function f (line 18) | def f(x):
  function highlight_min (line 132) | def highlight_min(x):
  function coverage_fraction (line 197) | def coverage_fraction(y, y_low, y_high):

FILE: examples/ensemble/plot_stack_predictors.py
  function load_ames_housing (line 51) | def load_ames_housing():
  function plot_regression_results (line 219) | def plot_regression_results(ax, y_true, y_pred, title, scores, elapsed_t...

FILE: examples/gaussian_process/plot_gpc_isoprobability.py
  function g (line 29) | def g(x):

FILE: examples/gaussian_process/plot_gpr_noisy.py
  function target_generator (line 26) | def target_generator(X, add_noise=False):

FILE: examples/gaussian_process/plot_gpr_on_structured_data.py
  class SequenceKernel (line 50) | class SequenceKernel(GenericKernelMixin, Kernel):
    method __init__ (line 55) | def __init__(self, baseline_similarity=0.5, baseline_similarity_bounds...
    method hyperparameter_baseline_similarity (line 60) | def hyperparameter_baseline_similarity(self):
    method _f (line 65) | def _f(self, s1, s2):
    method _g (line 73) | def _g(self, s1, s2):
    method __call__ (line 79) | def __call__(self, X, Y=None, eval_gradient=False):
    method diag (line 91) | def diag(self, X):
    method is_stationary (line 94) | def is_stationary(self):
    method clone_with_theta (line 97) | def clone_with_theta(self, theta):

FILE: examples/gaussian_process/plot_gpr_prior_posterior.py
  function plot_gpr_samples (line 37) | def plot_gpr_samples(gpr_model, n_samples, ax):

FILE: examples/impute/plot_missing_values.py
  function add_missing_values (line 59) | def add_missing_values(X_full, y_full):
  function get_scores_for_imputer (line 113) | def get_scores_for_imputer(imputer, X_missing, y_missing):
  function get_full_score (line 135) | def get_full_score(X_full, y_full):
  function get_impute_zero_score (line 156) | def get_impute_zero_score(X_missing, y_missing):
  function get_impute_knn_score (line 182) | def get_impute_knn_score(X_missing, y_missing):
  function get_impute_mean (line 203) | def get_impute_mean(X_missing, y_missing):
  function get_impute_iterative (line 229) | def get_impute_iterative(X_missing, y_missing):

FILE: examples/linear_model/plot_ard.py
  function f (line 98) | def f(x, noise_amount):

FILE: examples/linear_model/plot_bayesian_ridge.py
  function f (line 93) | def f(x, noise_amount):

FILE: examples/linear_model/plot_bayesian_ridge_curvefit.py
  function func (line 37) | def func(x):

FILE: examples/linear_model/plot_lasso_model_selection.py
  function plot_ic_criterion (line 82) | def plot_ic_criterion(model, name, color):

FILE: examples/linear_model/plot_logistic_multinomial.py
  function plot_hyperplane (line 64) | def plot_hyperplane(c, color):

FILE: examples/linear_model/plot_ols_3d.py
  function plot_figs (line 38) | def plot_figs(fig_num, elev, azim, X_train, clf):

FILE: examples/linear_model/plot_poisson_regression_non_normal_loss.py
  function score_estimator (line 160) | def score_estimator(estimator, df_test):
  function _mean_frequency_by_risk_group (line 389) | def _mean_frequency_by_risk_group(y_true, y_pred, sample_weight=None, n_...
  function lorenz_curve (line 491) | def lorenz_curve(y_true, y_pred, exposure):

FILE: examples/linear_model/plot_polynomial_interpolation.py
  function f (line 58) | def f(x):
  function g (line 172) | def g(x):

FILE: examples/linear_model/plot_sgd_early_stopping.py
  function load_mnist (line 59) | def load_mnist(n_samples=None, class_0="0", class_1="8"):
  function fit_and_score (line 74) | def fit_and_score(estimator, max_iter, X_train, X_test, y_train, y_test):

FILE: examples/linear_model/plot_sgd_iris.py
  function plot_hyperplane (line 77) | def plot_hyperplane(c, color):

FILE: examples/linear_model/plot_sgd_loss_functions.py
  function modified_huber_loss (line 15) | def modified_huber_loss(y_true, y_pred):

FILE: examples/linear_model/plot_tweedie_regression_insurance_claims.py
  function load_mtpl2 (line 65) | def load_mtpl2(n_samples=100000):
  function plot_obs_pred (line 94) | def plot_obs_pred(
  function score_estimator (line 150) | def score_estimator(
  function lorenz_curve (line 573) | def lorenz_curve(y_true, y_pred, exposure):

FILE: examples/manifold/plot_lle_digits.py
  function plot_embedding (line 51) | def plot_embedding(X, title, ax):

FILE: examples/miscellaneous/plot_multilabel.py
  function plot_hyperplane (line 45) | def plot_hyperplane(clf, min_x, max_x, linestyle, label):
  function plot_subfigure (line 54) | def plot_subfigure(X, Y, subplot, title, transform):

FILE: examples/mixture/plot_concentration_prior.py
  function plot_ellipses (line 43) | def plot_ellipses(ax, weights, means, covars):
  function plot_results (line 61) | def plot_results(ax1, ax2, estimator, X, y, title, plot_title=False):

FILE: examples/mixture/plot_gmm.py
  function plot_results (line 39) | def plot_results(X, Y_, means, covariances, index, title):

FILE: examples/mixture/plot_gmm_covariances.py
  function make_ellipses (line 46) | def make_ellipses(gmm, ax):

FILE: examples/mixture/plot_gmm_sin.py
  function plot_results (line 54) | def plot_results(X, Y, means, covariances, index, title):
  function plot_samples (line 82) | def plot_samples(X, Y, n_components, index, title):

FILE: examples/model_selection/plot_cv_indices.py
  function visualize_groups (line 59) | def visualize_groups(classes, groups, name):
  function plot_cv_indices (line 98) | def plot_cv_indices(cv, X, y, group, ax, n_splits, lw=10):

FILE: examples/model_selection/plot_grid_search_refit_callable.py
  function lower_bound (line 33) | def lower_bound(cv_results):
  function best_low_complexity (line 57) | def best_low_complexity(cv_results):

FILE: examples/model_selection/plot_grid_search_stats.py
  function corrected_std (line 168) | def corrected_std(differences, n_train, n_test):
  function compute_corrected_ttest (line 193) | def compute_corrected_ttest(differences, df, n_train, n_test):

FILE: examples/model_selection/plot_learning_curve.py
  function plot_learning_curve (line 29) | def plot_learning_curve(

FILE: examples/model_selection/plot_randomized_search.py
  function report (line 41) | def report(results, n_top=3):

FILE: examples/model_selection/plot_successive_halving_heatmap.py
  function make_heatmap (line 55) | def make_heatmap(ax, gs, is_sh=False, make_cbar=False):

FILE: examples/model_selection/plot_underfitting_overfitting.py
  function true_fun (line 32) | def true_fun(X):

FILE: examples/neighbors/approximate_nearest_neighbors.py
  class NMSlibTransformer (line 72) | class NMSlibTransformer(TransformerMixin, BaseEstimator):
    method __init__ (line 75) | def __init__(self, n_neighbors=5, metric="euclidean", method="sw-graph...
    method fit (line 81) | def fit(self, X):
    method transform (line 98) | def transform(self, X):
  class AnnoyTransformer (line 118) | class AnnoyTransformer(TransformerMixin, BaseEstimator):
    method __init__ (line 121) | def __init__(self, n_neighbors=5, metric="euclidean", n_trees=10, sear...
    method fit (line 127) | def fit(self, X):
    method transform (line 135) | def transform(self, X):
    method fit_transform (line 138) | def fit_transform(self, X, y=None):
    method _transform (line 141) | def _transform(self, X):
  function test_transformers (line 175) | def test_transformers():
  function load_mnist (line 192) | def load_mnist(n_samples):
  function run_benchmark (line 199) | def run_benchmark():

FILE: examples/neighbors/plot_kde_1d.py
  function format_func (line 99) | def format_func(x, loc):

FILE: examples/neighbors/plot_nca_illustration.py
  function link_thickness_i (line 53) | def link_thickness_i(X, i):
  function relate_point (line 64) | def relate_point(X, i, ax):

FILE: examples/neighbors/plot_species_kde.py
  function construct_grids (line 58) | def construct_grids(batch):

FILE: examples/neural_networks/plot_mlp_training_curves.py
  function plot_on_dataset (line 92) | def plot_on_dataset(X, y, ax, name):

FILE: examples/neural_networks/plot_rbm_logistic_classification.py
  function nudge_dataset (line 48) | def nudge_dataset(X, Y):

FILE: examples/preprocessing/plot_all_scaling.py
  function create_axes (line 122) | def create_axes(title, figsize=(16, 6)):
  function plot_distribution (line 165) | def plot_distribution(axes, X, y, hist_nbins=50, title="", x0_label="", ...
  function make_plot (line 208) | def make_plot(item_idx):

FILE: examples/preprocessing/plot_discretization_classification.py
  function get_name (line 55) | def get_name(estimator):

FILE: examples/release_highlights/plot_release_highlights_0_22_0.py
  function test_sklearn_compatible_estimator (line 248) | def test_sklearn_compatible_estimator(estimator, check):

FILE: examples/semi_supervised/plot_semi_supervised_newsgroups.py
  function eval_and_print_metrics (line 66) | def eval_and_print_metrics(clf, X_train, y_train, X_test, y_test):

FILE: examples/svm/plot_custom_kernel.py
  function my_kernel (line 22) | def my_kernel(X, Y):

FILE: examples/svm/plot_iris_svc.py
  function make_meshgrid (line 42) | def make_meshgrid(x, y, h=0.02):
  function plot_contours (line 61) | def plot_contours(ax, clf, xx, yy, **params):

FILE: examples/svm/plot_rbf_parameters.py
  class MidpointNormalize (line 93) | class MidpointNormalize(Normalize):
    method __init__ (line 94) | def __init__(self, vmin=None, vmax=None, midpoint=None, clip=False):
    method __call__ (line 98) | def __call__(self, value, clip=None):

FILE: examples/svm/plot_weighted_samples.py
  function plot_decision_function (line 22) | def plot_decision_function(classifier, sample_weight, axis, title):

FILE: examples/text/plot_document_classification_20newsgroups.py
  function is_interactive (line 101) | def is_interactive():
  function size_mb (line 154) | def size_mb(docs):
  function trim (line 213) | def trim(s):
  function benchmark (line 223) | def benchmark(clf):

FILE: examples/text/plot_document_clustering.py
  function is_interactive (line 125) | def is_interactive():

FILE: examples/text/plot_hashing_vs_dict_vectorizer.py
  function n_nonzero_columns (line 33) | def n_nonzero_columns(X):
  function tokens (line 38) | def tokens(doc):
  function token_freqs (line 47) | def token_freqs(doc):

FILE: maint_tools/create_issue_from_juint.py
  function get_issue (line 38) | def get_issue():
  function create_or_update_issue (line 48) | def create_or_update_issue(body):

FILE: maint_tools/sort_whats_new.py
  function entry_sort_key (line 12) | def entry_sort_key(s):

FILE: maint_tools/test_docstrings.py
  function get_all_methods (line 223) | def get_all_methods():
  function _is_checked_function (line 242) | def _is_checked_function(item):
  function get_all_functions_names (line 256) | def get_all_functions_names():
  function filter_errors (line 287) | def filter_errors(errors, method, Estimator=None):
  function repr_errors (line 326) | def repr_errors(res, estimator=None, method: Optional[str] = None) -> str:
  function test_function_docstring (line 382) | def test_function_docstring(function_name, request):
  function test_docstring (line 400) | def test_docstring(Estimator, method, request):

FILE: setup.py
  class CleanCommand (line 91) | class CleanCommand(Clean):
    method run (line 94) | def run(self):
  class build_ext_subclass (line 130) | class build_ext_subclass(build_ext):
    method finalize_options (line 131) | def finalize_options(self):
    method build_extensions (line 143) | def build_extensions(self):
  function configuration (line 177) | def configuration(parent_package="", top_path=None):
  function check_package_status (line 206) | def check_package_status(package, min_version):
  function setup_package (line 246) | def setup_package():

FILE: sklearn/__check_build/__init__.py
  function raise_build_error (line 16) | def raise_build_error(e):

FILE: sklearn/__check_build/setup.py
  function configuration (line 7) | def configuration(parent_package="", top_path=None):

FILE: sklearn/__init__.py
  function setup_module (line 132) | def setup_module(module):

FILE: sklearn/_build_utils/__init__.py
  function _check_cython_version (line 22) | def _check_cython_version():
  function cythonize_extensions (line 40) | def cythonize_extensions(top_path, config):
  function gen_from_templates (line 90) | def gen_from_templates(templates):

FILE: sklearn/_build_utils/openmp_helpers.py
  function get_openmp_flag (line 18) | def get_openmp_flag(compiler):
  function check_openmp_support (line 47) | def check_openmp_support():

FILE: sklearn/_build_utils/pre_build_helpers.py
  function _get_compiler (line 17) | def _get_compiler():
  function compile_test_program (line 46) | def compile_test_program(code, extra_preargs=[], extra_postargs=[]):
  function basic_check_build (line 100) | def basic_check_build():

FILE: sklearn/_config.py
  function _get_threadlocal_config (line 16) | def _get_threadlocal_config():
  function get_config (line 24) | def get_config():
  function set_config (line 42) | def set_config(
  function config_context (line 101) | def config_context(

FILE: sklearn/_loss/glm_distribution.py
  class ExponentialDispersionModel (line 19) | class ExponentialDispersionModel(metaclass=ABCMeta):
    method in_y_range (line 48) | def in_y_range(self, y):
    method unit_variance (line 69) | def unit_variance(self, y_pred):
    method unit_deviance (line 91) | def unit_deviance(self, y, y_pred, check_input=False):
    method unit_deviance_derivative (line 116) | def unit_deviance_derivative(self, y, y_pred):
    method deviance (line 134) | def deviance(self, y, y_pred, weights=1):
    method deviance_derivative (line 158) | def deviance_derivative(self, y, y_pred, weights=1):
  class TweedieDistribution (line 178) | class TweedieDistribution(ExponentialDispersionModel):
    method __init__ (line 204) | def __init__(self, power=0):
    method power (line 208) | def power(self):
    method power (line 212) | def power(self, power):
    method unit_variance (line 238) | def unit_variance(self, y_pred):
    method unit_deviance (line 249) | def unit_deviance(self, y, y_pred, check_input=False):
  class NormalDistribution (line 336) | class NormalDistribution(TweedieDistribution):
    method __init__ (line 339) | def __init__(self):
  class PoissonDistribution (line 343) | class PoissonDistribution(TweedieDistribution):
    method __init__ (line 346) | def __init__(self):
  class GammaDistribution (line 350) | class GammaDistribution(TweedieDistribution):
    method __init__ (line 353) | def __init__(self):
  class InverseGaussianDistribution (line 357) | class InverseGaussianDistribution(TweedieDistribution):
    method __init__ (line 360) | def __init__(self):

FILE: sklearn/_loss/tests/test_glm_distribution.py
  function test_family_bounds (line 33) | def test_family_bounds(family, expected):
  function test_invalid_distribution_bound (line 39) | def test_invalid_distribution_bound():
  function test_tweedie_distribution_power (line 46) | def test_tweedie_distribution_power():
  function test_deviance_zero (line 81) | def test_deviance_zero(family, chk_values):
  function test_deviance_derivative (line 102) | def test_deviance_derivative(family):

FILE: sklearn/base.py
  function clone (line 33) | def clone(estimator, *, safe=True):
  function _pprint (line 99) | def _pprint(params, offset=0, printer=repr):
  class BaseEstimator (line 149) | class BaseEstimator:
    method _get_param_names (line 160) | def _get_param_names(cls):
    method get_params (line 190) | def get_params(self, deep=True):
    method set_params (line 214) | def set_params(self, **params):
    method __repr__ (line 258) | def __repr__(self, N_CHAR_MAX=700):
    method __getstate__ (line 310) | def __getstate__(self):
    method __setstate__ (line 321) | def __setstate__(self, state):
    method _more_tags (line 341) | def _more_tags(self):
    method _get_tags (line 344) | def _get_tags(self):
    method _check_n_features (line 355) | def _check_n_features(self, X, reset):
    method _check_feature_names (line 401) | def _check_feature_names(self, X, *, reset):
    method _validate_data (line 491) | def _validate_data(
    method _repr_html_ (line 601) | def _repr_html_(self):
    method _repr_html_inner (line 616) | def _repr_html_inner(self):
    method _repr_mimebundle_ (line 623) | def _repr_mimebundle_(self, **kwargs):
  class ClassifierMixin (line 631) | class ClassifierMixin:
    method score (line 636) | def score(self, X, y, sample_weight=None):
    method _more_tags (line 664) | def _more_tags(self):
  class RegressorMixin (line 668) | class RegressorMixin:
    method score (line 673) | def score(self, X, y, sample_weight=None):
    method _more_tags (line 719) | def _more_tags(self):
  class ClusterMixin (line 723) | class ClusterMixin:
    method fit_predict (line 728) | def fit_predict(self, X, y=None):
    method _more_tags (line 750) | def _more_tags(self):
  class BiclusterMixin (line 754) | class BiclusterMixin:
    method biclusters_ (line 758) | def biclusters_(self):
    method get_indices (line 765) | def get_indices(self, i):
    method get_shape (line 786) | def get_shape(self, i):
    method get_submatrix (line 805) | def get_submatrix(self, i, data):
  class TransformerMixin (line 832) | class TransformerMixin:
    method fit_transform (line 835) | def fit_transform(self, X, y=None, **fit_params):
  class _OneToOneFeatureMixin (line 869) | class _OneToOneFeatureMixin:
    method get_feature_names_out (line 876) | def get_feature_names_out(self, input_features=None):
  class _ClassNamePrefixFeaturesOutMixin (line 898) | class _ClassNamePrefixFeaturesOutMixin:
    method get_feature_names_out (line 904) | def get_feature_names_out(self, input_features=None):
  class DensityMixin (line 923) | class DensityMixin:
    method score (line 928) | def score(self, X, y=None):
  class OutlierMixin (line 946) | class OutlierMixin:
    method fit_predict (line 951) | def fit_predict(self, X, y=None):
  class MetaEstimatorMixin (line 973) | class MetaEstimatorMixin:
  class MultiOutputMixin (line 978) | class MultiOutputMixin:
    method _more_tags (line 981) | def _more_tags(self):
  class _UnstableArchMixin (line 985) | class _UnstableArchMixin:
    method _more_tags (line 988) | def _more_tags(self):
  function is_classifier (line 996) | def is_classifier(estimator):
  function is_regressor (line 1012) | def is_regressor(estimator):
  function is_outlier_detector (line 1028) | def is_outlier_detector(estimator):
  function _is_pairwise (line 1044) | def _is_pairwise(estimator):

FILE: sklearn/calibration.py
  class CalibratedClassifierCV (line 53) | class CalibratedClassifierCV(ClassifierMixin, MetaEstimatorMixin, BaseEs...
    method __init__ (line 238) | def __init__(
    method fit (line 253) | def fit(self, X, y, sample_weight=None):
    method predict_proba (line 402) | def predict_proba(self, X):
    method predict (line 430) | def predict(self, X):
    method _more_tags (line 449) | def _more_tags(self):
  function _fit_classifier_calibrator_pair (line 461) | def _fit_classifier_calibrator_pair(
  function _get_prediction_method (line 527) | def _get_prediction_method(clf):
  function _compute_predictions (line 557) | def _compute_predictions(pred_method, method_name, X, n_classes):
  function _fit_calibrator (line 595) | def _fit_calibrator(clf, predictions, y, classes, method, sample_weight=...
  class _CalibratedClassifier (line 647) | class _CalibratedClassifier:
    method __init__ (line 670) | def __init__(self, base_estimator, calibrators, *, classes, method="si...
    method predict_proba (line 676) | def predict_proba(self, X):
  function _sigmoid_calibration (line 728) | def _sigmoid_calibration(predictions, y, sample_weight=None):
  class _SigmoidCalibration (line 798) | class _SigmoidCalibration(RegressorMixin, BaseEstimator):
    method fit (line 810) | def fit(self, X, y, sample_weight=None):
    method predict (line 836) | def predict(self, T):
  function calibration_curve (line 853) | def calibration_curve(
  class CalibrationDisplay (line 969) | class CalibrationDisplay:
    method __init__ (line 1043) | def __init__(
    method plot (line 1052) | def plot(self, *, ax=None, name=None, ref_line=True, **kwargs):
    method from_estimator (line 1114) | def from_estimator(
    method from_predictions (line 1240) | def from_predictions(

FILE: sklearn/cluster/_affinity_propagation.py
  function _equal_similarities_and_preferences (line 24) | def _equal_similarities_and_preferences(S, preference):
  function affinity_propagation (line 38) | def affinity_propagation(
  class AffinityPropagation (line 267) | class AffinityPropagation(ClusterMixin, BaseEstimator):
    method __init__ (line 397) | def __init__(
    method _pairwise (line 426) | def _pairwise(self):
    method _more_tags (line 429) | def _more_tags(self):
    method fit (line 432) | def fit(self, X, y=None):
    method predict (line 503) | def predict(self, X):
    method fit_predict (line 536) | def fit_predict(self, X, y=None):

FILE: sklearn/cluster/_agglomerative.py
  function _fix_connectivity (line 35) | def _fix_connectivity(X, connectivity, affinity):
  function _single_linkage_tree (line 110) | def _single_linkage_tree(
  function ward_tree (line 170) | def ward_tree(X, *, connectivity=None, n_clusters=None, return_distance=...
  function linkage_tree (line 385) | def linkage_tree(
  function _complete_linkage (line 663) | def _complete_linkage(*args, **kwargs):
  function _average_linkage (line 668) | def _average_linkage(*args, **kwargs):
  function _single_linkage (line 673) | def _single_linkage(*args, **kwargs):
  function _hc_cut (line 689) | def _hc_cut(n_clusters, children, n_leaves):
  class AgglomerativeClustering (line 740) | class AgglomerativeClustering(ClusterMixin, BaseEstimator):
    method __init__ (line 878) | def __init__(
    method fit (line 899) | def fit(self, X, y=None):
    method _fit (line 920) | def _fit(self, X):
    method fit_predict (line 1033) | def fit_predict(self, X, y=None):
  class FeatureAgglomeration (line 1057) | class FeatureAgglomeration(AgglomerativeClustering, AgglomerationTransfo...
    method __init__ (line 1196) | def __init__(
    method fit (line 1221) | def fit(self, X, y=None):
    method fit_predict (line 1242) | def fit_predict(self):

FILE: sklearn/cluster/_bicluster.py
  function _scale_normalize (line 25) | def _scale_normalize(X):
  function _bistochastic_normalize (line 46) | def _bistochastic_normalize(X, max_iter=1000, tol=1e-5):
  function _log_normalize (line 67) | def _log_normalize(X):
  class BaseSpectral (line 83) | class BaseSpectral(BiclusterMixin, BaseEstimator, metaclass=ABCMeta):
    method __init__ (line 87) | def __init__(
    method _check_parameters (line 105) | def _check_parameters(self):
    method fit (line 114) | def fit(self, X, y=None):
    method _svd (line 135) | def _svd(self, array, n_components, n_discard):
    method _k_means (line 172) | def _k_means(self, data, n_clusters):
    method _more_tags (line 192) | def _more_tags(self):
  class SpectralCoclustering (line 206) | class SpectralCoclustering(BaseSpectral):
    method __init__ (line 316) | def __init__(
    method _fit (line 331) | def _fit(self, X):
  class SpectralBiclustering (line 349) | class SpectralBiclustering(BaseSpectral):
    method __init__ (line 474) | def __init__(
    method _check_parameters (line 495) | def _check_parameters(self):
    method _fit (line 536) | def _fit(self, X):
    method _fit_best_piecewise (line 579) | def _fit_best_piecewise(self, vectors, n_best, n_clusters):
    method _project_and_cluster (line 597) | def _project_and_cluster(self, data, vectors, n_clusters):

FILE: sklearn/cluster/_birch.py
  function _iterate_sparse_X (line 23) | def _iterate_sparse_X(X):
  function _split_node (line 41) | def _split_node(node, threshold, branching_factor):
  class _CFNode (line 97) | class _CFNode:
    method __init__ (line 145) | def __init__(self, *, threshold, branching_factor, is_leaf, n_features):
    method append_subcluster (line 160) | def append_subcluster(self, subcluster):
    method update_split_subclusters (line 172) | def update_split_subclusters(self, subcluster, new_subcluster1, new_su...
    method insert_cf_subcluster (line 182) | def insert_cf_subcluster(self, subcluster):
  class _CFSubcluster (line 250) | class _CFSubcluster:
    method __init__ (line 286) | def __init__(self, *, linear_sum=None):
    method update (line 299) | def update(self, subcluster):
    method merge_subcluster (line 306) | def merge_subcluster(self, nominee_cluster, threshold):
    method radius (line 338) | def radius(self):
  class Birch (line 345) | class Birch(ClusterMixin, TransformerMixin, BaseEstimator):
    method __init__ (line 465) | def __init__(
    method fit_ (line 486) | def fit_(self):
    method partial_fit_ (line 495) | def partial_fit_(self):
    method fit (line 498) | def fit(self, X, y=None):
    method _fit (line 543) | def _fit(self, X, partial):
    method _get_leaves (line 606) | def _get_leaves(self):
    method partial_fit (line 622) | def partial_fit(self, X=None, y=None):
    method _check_fit (line 650) | def _check_fit(self, X):
    method predict (line 661) | def predict(self, X):
    method transform (line 687) | def transform(self, X):
    method _global_clustering (line 709) | def _global_clustering(self, X=None):

FILE: sklearn/cluster/_dbscan.py
  function dbscan (line 25) | def dbscan(
  class DBSCAN (line 166) | class DBSCAN(ClusterMixin, BaseEstimator):
    method __init__ (line 302) | def __init__(
    method fit (line 323) | def fit(self, X, y=None, sample_weight=None):
    method fit_predict (line 434) | def fit_predict(self, X, y=None, sample_weight=None):

FILE: sklearn/cluster/_feature_agglomeration.py
  class AgglomerationTransform (line 18) | class AgglomerationTransform(TransformerMixin):
    method transform (line 23) | def transform(self, X):
    method inverse_transform (line 57) | def inverse_transform(self, Xred):

FILE: sklearn/cluster/_kmeans.py
  function kmeans_plusplus (line 52) | def kmeans_plusplus(
  function _kmeans_plusplus (line 148) | def _kmeans_plusplus(X, n_clusters, x_squared_norms, random_state, n_loc...
  function _tolerance (line 246) | def _tolerance(X, tol):
  function k_means (line 257) | def k_means(
  function _kmeans_single_elkan (line 383) | def _kmeans_single_elkan(
  function _kmeans_single_lloyd (line 544) | def _kmeans_single_lloyd(
  function _labels_inertia (line 684) | def _labels_inertia(X, sample_weight, x_squared_norms, centers, n_thread...
  function _labels_inertia_threadpool_limit (line 751) | def _labels_inertia_threadpool_limit(
  class KMeans (line 763) | class KMeans(TransformerMixin, ClusterMixin, BaseEstimator):
    method __init__ (line 911) | def __init__(
    method _check_params (line 935) | def _check_params(self, X):
    method _validate_center_shape (line 993) | def _validate_center_shape(self, X, centers):
    method _check_test_data (line 1006) | def _check_test_data(self, X):
    method _check_mkl_vcomp (line 1017) | def _check_mkl_vcomp(self, X, n_samples):
    method _init_centroids (line 1052) | def _init_centroids(self, X, x_squared_norms, init, random_state, init...
    method fit (line 1111) | def fit(self, X, y=None, sample_weight=None):
    method fit_predict (line 1232) | def fit_predict(self, X, y=None, sample_weight=None):
    method fit_transform (line 1257) | def fit_transform(self, X, y=None, sample_weight=None):
    method transform (line 1281) | def transform(self, X):
    method _transform (line 1303) | def _transform(self, X):
    method predict (line 1307) | def predict(self, X, sample_weight=None):
    method score (line 1338) | def score(self, X, y=None, sample_weight=None):
    method _more_tags (line 1368) | def _more_tags(self):
  function _mini_batch_step (line 1378) | def _mini_batch_step(
  class MiniBatchKMeans (line 1502) | class MiniBatchKMeans(KMeans):
    method __init__ (line 1687) | def __init__(
    method counts_ (line 1725) | def counts_(self):
    method init_size_ (line 1733) | def init_size_(self):
    method random_state_ (line 1741) | def random_state_(self):
    method _check_params (line 1744) | def _check_params(self, X):
    method _mini_batch_convergence (line 1787) | def _mini_batch_convergence(
    method _random_reassign (line 1852) | def _random_reassign(self):
    method fit (line 1868) | def fit(self, X, y=None, sample_weight=None):
    method partial_fit (line 2024) | def partial_fit(self, X, y=None, sample_weight=None):
    method predict (line 2124) | def predict(self, X, sample_weight=None):
    method _more_tags (line 2161) | def _more_tags(self):

FILE: sklearn/cluster/_mean_shift.py
  function estimate_bandwidth (line 31) | def estimate_bandwidth(X, *, quantile=0.3, n_samples=None, random_state=...
  function _mean_shift_single_seed (line 87) | def _mean_shift_single_seed(my_mean, X, nbrs, max_iter):
  function mean_shift (line 110) | def mean_shift(
  function get_bin_seeds (line 203) | def get_bin_seeds(X, bin_size, min_bin_freq=1):
  class MeanShift (line 256) | class MeanShift(ClusterMixin, BaseEstimator):
    method __init__ (line 383) | def __init__(
    method fit (line 402) | def fit(self, X, y=None):
    method predict (line 499) | def predict(self, X):

FILE: sklearn/cluster/_optics.py
  class OPTICS (line 26) | class OPTICS(ClusterMixin, BaseEstimator):
    method __init__ (line 224) | def __init__(
    method fit (line 257) | def fit(self, X, y=None):
  function _validate_size (line 348) | def _validate_size(size, n_samples, param_name):
  function _compute_core_distances_ (line 362) | def _compute_core_distances_(X, neighbors, min_samples, working_memory):
  function compute_optics_graph (line 398) | def compute_optics_graph(
  function _set_reach_dist (line 578) | def _set_reach_dist(
  function cluster_optics_dbscan (line 623) | def cluster_optics_dbscan(*, reachability, core_distances, ordering, eps):
  function cluster_optics_xi (line 661) | def cluster_optics_xi(
  function _extend_region (line 741) | def _extend_region(steep_point, xward_point, start, min_samples):
  function _update_filter_sdas (line 804) | def _update_filter_sdas(sdas, mib, xi_complement, reachability_plot):
  function _correct_predecessor (line 818) | def _correct_predecessor(reachability_plot, predecessor_plot, ordering, ...
  function _xi_cluster (line 840) | def _xi_cluster(
  function _extract_xi_labels (line 995) | def _extract_xi_labels(ordering, clusters):

FILE: sklearn/cluster/_spectral.py
  function cluster_qr (line 25) | def cluster_qr(vectors):
  function discretize (line 57) | def discretize(
  function spectral_clustering (line 193) | def spectral_clustering(
  class SpectralClustering (line 379) | class SpectralClustering(ClusterMixin, BaseEstimator):
    method __init__ (line 590) | def __init__(
    method fit (line 625) | def fit(self, X, y=None):
    method fit_predict (line 704) | def fit_predict(self, X, y=None):
    method _more_tags (line 728) | def _more_tags(self):
    method _pairwise (line 741) | def _pairwise(self):

FILE: sklearn/cluster/setup.py
  function configuration (line 8) | def configuration(parent_package="", top_path=None):

FILE: sklearn/cluster/tests/common.py
  function generate_clustered_data (line 13) | def generate_clustered_data(

FILE: sklearn/cluster/tests/test_affinity_propagation.py
  function test_affinity_propagation (line 31) | def test_affinity_propagation():
  function test_affinity_propagation_affinity_shape (line 68) | def test_affinity_propagation_affinity_shape():
  function test_affinity_propagation_params_validation (line 92) | def test_affinity_propagation_params_validation(input, params, err_type,...
  function test_affinity_propagation_predict (line 98) | def test_affinity_propagation_predict():
  function test_affinity_propagation_predict_error (line 106) | def test_affinity_propagation_predict_error():
  function test_affinity_propagation_fit_non_convergence (line 121) | def test_affinity_propagation_fit_non_convergence():
  function test_affinity_propagation_equal_mutual_similarities (line 136) | def test_affinity_propagation_equal_mutual_similarities():
  function test_affinity_propagation_predict_non_convergence (line 168) | def test_affinity_propagation_predict_non_convergence():
  function test_affinity_propagation_non_convergence_regressiontest (line 185) | def test_affinity_propagation_non_convergence_regressiontest():
  function test_equal_similarities_and_preferences (line 191) | def test_equal_similarities_and_preferences():
  function test_affinity_propagation_random_state (line 212) | def test_affinity_propagation_random_state():
  function test_affinity_propagation_convergence_warning_dense_sparse (line 233) | def test_affinity_propagation_convergence_warning_dense_sparse(centers):
  function test_affinity_propagation_float32 (line 246) | def test_affinity_propagation_float32():
  function test_sparse_input_for_predict (line 259) | def test_sparse_input_for_predict():
  function test_sparse_input_for_fit_predict (line 268) | def test_sparse_input_for_fit_predict():
  function test_affinity_propagation_pairwise_is_deprecated (line 279) | def test_affinity_propagation_pairwise_is_deprecated():

FILE: sklearn/cluster/tests/test_bicluster.py
  class MockBiclustering (line 26) | class MockBiclustering(BiclusterMixin, BaseEstimator):
    method __init__ (line 28) | def __init__(self):
    method get_indices (line 31) | def get_indices(self, i):
  function test_get_submatrix (line 39) | def test_get_submatrix():
  function _test_shape_indices (line 54) | def _test_shape_indices(model):
  function test_spectral_coclustering (line 63) | def test_spectral_coclustering():
  function test_spectral_biclustering (line 91) | def test_spectral_biclustering():
  function _do_scale_test (line 131) | def _do_scale_test(scaled):
  function _do_bistochastic_test (line 142) | def _do_bistochastic_test(scaled):
  function test_scale_normalize (line 148) | def test_scale_normalize():
  function test_bistochastic_normalize (line 158) | def test_bistochastic_normalize():
  function test_log_normalize (line 168) | def test_log_normalize():
  function test_fit_best_piecewise (line 177) | def test_fit_best_piecewise():
  function test_project_and_cluster (line 184) | def test_project_and_cluster():
  function test_perfect_checkerboard (line 193) | def test_perfect_checkerboard():
  function test_errors (line 223) | def test_errors(args):
  function test_wrong_shape (line 231) | def test_wrong_shape():
  function test_n_features_in_ (line 239) | def test_n_features_in_(est):

FILE: sklearn/cluster/tests/test_birch.py
  function test_n_samples_leaves_roots (line 22) | def test_n_samples_leaves_roots():
  function test_partial_fit (line 35) | def test_partial_fit():
  function test_birch_predict (line 52) | def test_birch_predict():
  function test_n_clusters (line 69) | def test_n_clusters():
  function test_sparse_X (line 98) | def test_sparse_X():
  function test_partial_fit_second_call_error_checks (line 112) | def test_partial_fit_second_call_error_checks():
  function check_branching_factor (line 124) | def check_branching_factor(node, branching_factor):
  function test_branching_factor (line 132) | def test_branching_factor():
  function check_threshold (line 146) | def check_threshold(birch_instance, threshold):
  function test_threshold (line 156) | def test_threshold():
  function test_birch_n_clusters_long_int (line 168) | def test_birch_n_clusters_long_int():
  function test_birch_fit_attributes_deprecated (line 178) | def test_birch_fit_attributes_deprecated(attribute):
  function test_birch_params_validation (line 217) | def test_birch_params_validation(params, err_type, err_msg):

FILE: sklearn/cluster/tests/test_dbscan.py
  function test_dbscan_similarity (line 28) | def test_dbscan_similarity():
  function test_dbscan_feature (line 52) | def test_dbscan_feature():
  function test_dbscan_sparse (line 74) | def test_dbscan_sparse():
  function test_dbscan_sparse_precomputed (line 82) | def test_dbscan_sparse_precomputed(include_self):
  function test_dbscan_sparse_precomputed_different_eps (line 97) | def test_dbscan_sparse_precomputed_different_eps():
  function test_dbscan_input_not_modified (line 116) | def test_dbscan_input_not_modified(use_sparse, metric):
  function test_dbscan_no_core_samples (line 129) | def test_dbscan_no_core_samples():
  function test_dbscan_callable (line 141) | def test_dbscan_callable():
  function test_dbscan_metric_params (line 166) | def test_dbscan_metric_params():
  function test_dbscan_balltree (line 227) | def test_dbscan_balltree():
  function test_input_validation (line 266) | def test_input_validation():
  function test_dbscan_badargs (line 279) | def test_dbscan_badargs(args):
  function test_pickle (line 285) | def test_pickle():
  function test_boundaries (line 291) | def test_boundaries():
  function test_weighted_dbscan (line 302) | def test_weighted_dbscan():
  function test_dbscan_core_samples_toy (line 371) | def test_dbscan_core_samples_toy(algorithm):
  function test_dbscan_precomputed_metric_with_degenerate_input_arrays (line 400) | def test_dbscan_precomputed_metric_with_degenerate_input_arrays():
  function test_dbscan_precomputed_metric_with_initial_rows_zero (line 412) | def test_dbscan_precomputed_metric_with_initial_rows_zero():
  function test_dbscan_params_validation (line 460) | def test_dbscan_params_validation(params, err_type, err_msg):

FILE: sklearn/cluster/tests/test_feature_agglomeration.py
  function test_feature_agglomeration (line 11) | def test_feature_agglomeration():

FILE: sklearn/cluster/tests/test_hierarchical.py
  function test_linkage_misc (line 53) | def test_linkage_misc():
  function test_structured_linkage_tree (line 80) | def test_structured_linkage_tree():
  function test_unstructured_linkage_tree (line 103) | def test_unstructured_linkage_tree():
  function test_height_linkage_tree (line 127) | def test_height_linkage_tree():
  function test_agglomerative_clustering_wrong_arg_memory (line 141) | def test_agglomerative_clustering_wrong_arg_memory():
  function test_zero_cosine_linkage_tree (line 153) | def test_zero_cosine_linkage_tree():
  function test_agglomerative_clustering_distances (line 165) | def test_agglomerative_clustering_distances(
  function test_agglomerative_clustering (line 193) | def test_agglomerative_clustering():
  function test_agglomerative_clustering_memory_mapped (line 287) | def test_agglomerative_clustering_memory_mapped():
  function test_ward_agglomeration (line 297) | def test_ward_agglomeration():
  function test_single_linkage_clustering (line 318) | def test_single_linkage_clustering():
  function assess_same_labelling (line 335) | def assess_same_labelling(cut1, cut2):
  function test_sparse_scikit_vs_scipy (line 347) | def test_sparse_scikit_vs_scipy():
  function test_vector_scikit_single_vs_scipy_single (line 388) | def test_vector_scikit_single_vs_scipy_single(seed):
  function test_mst_linkage_core_memory_mapped (line 414) | def test_mst_linkage_core_memory_mapped(metric):
  function test_identical_points (line 432) | def test_identical_points():
  function test_connectivity_propagation (line 452) | def test_connectivity_propagation():
  function test_ward_tree_children_order (line 483) | def test_ward_tree_children_order():
  function test_ward_linkage_tree_return_distance (line 503) | def test_ward_linkage_tree_return_distance():
  function test_connectivity_fixing_non_lil (line 621) | def test_connectivity_fixing_non_lil():
  function test_int_float_dict (line 634) | def test_int_float_dict():
  function test_connectivity_callable (line 651) | def test_connectivity_callable():
  function test_connectivity_ignores_diagonal (line 664) | def test_connectivity_ignores_diagonal():
  function test_compute_full_tree (line 676) | def test_compute_full_tree():
  function test_n_components (line 702) | def test_n_components():
  function test_agg_n_clusters (line 714) | def test_agg_n_clusters():
  function test_affinity_passed_to_fix_connectivity (line 728) | def test_affinity_passed_to_fix_connectivity():
  function test_agglomerative_clustering_with_distance_threshold (line 755) | def test_agglomerative_clustering_with_distance_threshold(linkage):
  function test_small_distance_threshold (line 793) | def test_small_distance_threshold():
  function test_cluster_distances_with_distance_threshold (line 810) | def test_cluster_distances_with_distance_threshold():
  function test_agglomerative_clustering_with_distance_threshold_edge_case (line 841) | def test_agglomerative_clustering_with_distance_threshold_edge_case(
  function test_dist_threshold_invalid_parameters (line 853) | def test_dist_threshold_invalid_parameters():
  function test_invalid_shape_precomputed_dist_matrix (line 868) | def test_invalid_shape_precomputed_dist_matrix():
  function test_precomputed_connectivity_affinity_with_2_connected_components (line 877) | def test_precomputed_connectivity_affinity_with_2_connected_components():

FILE: sklearn/cluster/tests/test_k_means.py
  function test_kmeans_results (line 57) | def test_kmeans_results(array_constr, algo, dtype):
  function test_kmeans_relocated_clusters (line 82) | def test_kmeans_relocated_clusters(array_constr, algo):
  function test_relocate_empty_clusters (line 106) | def test_relocate_empty_clusters(array_constr):
  function test_kmeans_elkan_results (line 152) | def test_kmeans_elkan_results(distribution, array_constr, tol):
  function test_kmeans_convergence (line 176) | def test_kmeans_convergence(algorithm):
  function test_minibatch_update_consistency (line 194) | def test_minibatch_update_consistency():
  function _check_fitted_model (line 266) | def _check_fitted_model(km):
  function test_all_init (line 287) | def test_all_init(Estimator, data, init):
  function test_minibatch_kmeans_partial_fit_init (line 301) | def test_minibatch_kmeans_partial_fit_init(init):
  function test_fortran_aligned_data (line 314) | def test_fortran_aligned_data(Estimator):
  function test_k_means_fit_predict (line 341) | def test_k_means_fit_predict(algo, dtype, constructor, seed, max_iter, t...
  function test_minibatch_kmeans_verbose (line 359) | def test_minibatch_kmeans_verbose():
  function test_kmeans_verbose (line 372) | def test_kmeans_verbose(algorithm, tol, capsys):
  function test_minibatch_kmeans_warning_init_size (line 397) | def test_minibatch_kmeans_warning_init_size():
  function test_warning_n_init_precomputed_centers (line 406) | def test_warning_n_init_precomputed_centers(Estimator):
  function test_minibatch_sensible_reassign (line 416) | def test_minibatch_sensible_reassign():
  function test_minibatch_reassign (line 445) | def test_minibatch_reassign(data):
  function test_minibatch_with_many_reassignments (line 498) | def test_minibatch_with_many_reassignments():
  function test_minibatch_kmeans_init_size (line 512) | def test_minibatch_kmeans_init_size():
  function test_minibatch_declared_convergence (line 531) | def test_minibatch_declared_convergence(capsys, tol, max_no_improvement):
  function test_minibatch_iter_steps (line 558) | def test_minibatch_iter_steps():
  function test_kmeans_copyx (line 583) | def test_kmeans_copyx():
  function test_score_max_iter (line 595) | def test_score_max_iter(Estimator):
  function test_predict (line 616) | def test_predict(Estimator, algorithm, init, dtype, array_constr):
  function test_dense_sparse (line 642) | def test_dense_sparse(Estimator):
  function test_predict_dense_sparse (line 658) | def test_predict_dense_sparse(Estimator, init):
  function test_integer_input (line 677) | def test_integer_input(Estimator, array_constr, dtype, init):
  function test_transform (line 704) | def test_transform(Estimator):
  function test_fit_transform (line 722) | def test_fit_transform(Estimator):
  function test_n_init (line 729) | def test_n_init():
  function test_k_means_function (line 745) | def test_k_means_function():
  function test_float_precision (line 761) | def test_float_precision(Estimator, data):
  function test_centers_not_mutated (line 797) | def test_centers_not_mutated(Estimator, dtype):
  function test_kmeans_init_fitted_centers (line 811) | def test_kmeans_init_fitted_centers(data):
  function test_kmeans_warns_less_centers_than_unique_points (line 820) | def test_kmeans_warns_less_centers_than_unique_points():
  function _sort_centers (line 837) | def _sort_centers(centers):
  function test_weighted_vs_repeated (line 841) | def test_weighted_vs_repeated():
  function test_unit_weights_vs_no_weights (line 865) | def test_unit_weights_vs_no_weights(Estimator, data):
  function test_scaled_weights (line 880) | def test_scaled_weights(Estimator, data):
  function test_kmeans_elkan_iter_attribute (line 893) | def test_kmeans_elkan_iter_attribute():
  function test_kmeans_empty_cluster_relocated (line 903) | def test_kmeans_empty_cluster_relocated(array_constr):
  function test_result_equal_in_diff_n_threads (line 918) | def test_result_equal_in_diff_n_threads(Estimator):
  function test_minibatch_kmeans_deprecated_attributes (line 932) | def test_minibatch_kmeans_deprecated_attributes(attr):
  function test_warning_elkan_1_cluster (line 945) | def test_warning_elkan_1_cluster():
  function test_k_means_1_iteration (line 958) | def test_k_means_1_iteration(array_constr, algo):
  function test_euclidean_distance (line 987) | def test_euclidean_distance(dtype, squared):
  function test_inertia (line 1012) | def test_inertia(dtype):
  function test_sample_weight_unchanged (line 1037) | def test_sample_weight_unchanged(Estimator):
  function test_wrong_params (line 1080) | def test_wrong_params(Estimator, param, match):
  function test_kmeans_wrong_params (line 1093) | def test_kmeans_wrong_params(param, match):
  function test_minibatch_kmeans_wrong_params (line 1109) | def test_minibatch_kmeans_wrong_params(param, match):
  function test_kmeans_plusplus_wrong_params (line 1131) | def test_kmeans_plusplus_wrong_params(param, match):
  function test_kmeans_plusplus_output (line 1138) | def test_kmeans_plusplus_output(data, dtype):
  function test_kmeans_plusplus_norms (line 1161) | def test_kmeans_plusplus_norms(x_squared_norms):
  function test_kmeans_plusplus_dataorder (line 1168) | def test_kmeans_plusplus_dataorder():
  function test_is_same_clustering (line 1179) | def test_is_same_clustering():

FILE: sklearn/cluster/tests/test_mean_shift.py
  function test_estimate_bandwidth (line 36) | def test_estimate_bandwidth():
  function test_estimate_bandwidth_1sample (line 42) | def test_estimate_bandwidth_1sample():
  function test_mean_shift (line 53) | def test_mean_shift(bandwidth, cluster_all, expected, first_cluster_label):
  function test_mean_shift_negative_bandwidth (line 69) | def test_mean_shift_negative_bandwidth():
  function test_estimate_bandwidth_with_sparse_matrix (line 77) | def test_estimate_bandwidth_with_sparse_matrix():
  function test_parallel (line 85) | def test_parallel():
  function test_meanshift_predict (line 106) | def test_meanshift_predict():
  function test_meanshift_all_orphans (line 114) | def test_meanshift_all_orphans():
  function test_unfitted (line 124) | def test_unfitted():
  function test_cluster_intensity_tie (line 131) | def test_cluster_intensity_tie():
  function test_bin_seeds (line 141) | def test_bin_seeds():
  function test_max_iter (line 182) | def test_max_iter(max_iter):
  function test_mean_shift_zero_bandwidth (line 194) | def test_mean_shift_zero_bandwidth():

FILE: sklearn/cluster/tests/test_optics.py
  function test_extend_downward (line 41) | def test_extend_downward(r_plot, end):
  function test_extend_upward (line 60) | def test_extend_upward(r_plot, end):
  function test_the_extract_xi_labels (line 79) | def test_the_extract_xi_labels(ordering, clusters, expected):
  function test_extract_xi (line 85) | def test_extract_xi():
  function test_cluster_hierarchy_ (line 138) | def test_cluster_hierarchy_():
  function test_correct_number_of_clusters (line 152) | def test_correct_number_of_clusters():
  function test_minimum_number_of_sample_check (line 180) | def test_minimum_number_of_sample_check():
  function test_bad_extract (line 193) | def test_bad_extract():
  function test_bad_reachability (line 207) | def test_bad_reachability():
  function test_nowarn_if_metric_bool_data_bool (line 219) | def test_nowarn_if_metric_bool_data_bool():
  function test_warn_if_metric_bool_data_no_bool (line 232) | def test_warn_if_metric_bool_data_no_bool():
  function test_nowarn_if_metric_no_bool (line 247) | def test_nowarn_if_metric_no_bool():
  function test_close_extract (line 262) | def test_close_extract():
  function test_dbscan_optics_parity (line 278) | def test_dbscan_optics_parity(eps, min_samples):
  function test_min_samples_edge_case (line 304) | def test_min_samples_edge_case():
  function test_min_cluster_size (line 326) | def test_min_cluster_size(min_cluster_size):
  function test_min_cluster_size_invalid (line 341) | def test_min_cluster_size_invalid(min_cluster_size):
  function test_min_cluster_size_invalid2 (line 347) | def test_min_cluster_size_invalid2():
  function test_processing_order (line 353) | def test_processing_order():
  function test_compare_to_ELKI (line 363) | def test_compare_to_ELKI():
  function test_wrong_cluster_method (line 765) | def test_wrong_cluster_method():
  function test_extract_dbscan (line 771) | def test_extract_dbscan():
  function test_precomputed_dists (line 786) | def test_precomputed_dists():

FILE: sklearn/cluster/tests/test_spectral.py
  function test_spectral_clustering (line 34) | def test_spectral_clustering(eigen_solver, assign_labels):
  function test_spectral_unknown_mode (line 67) | def test_spectral_unknown_mode():
  function test_spectral_unknown_assign_labels (line 86) | def test_spectral_unknown_assign_labels():
  function test_spectral_clustering_sparse (line 106) | def test_spectral_clustering_sparse(assign_labels):
  function test_precomputed_nearest_neighbors_filtering (line 128) | def test_precomputed_nearest_neighbors_filtering():
  function test_affinities (line 154) | def test_affinities():
  function test_cluster_qr (line 201) | def test_cluster_qr():
  function test_cluster_qr_permutation_invariance (line 219) | def test_cluster_qr_permutation_invariance():
  function test_discretize (line 232) | def test_discretize(n_samples):
  function test_spectral_clustering_with_arpack_amg_solvers (line 264) | def test_spectral_clustering_with_arpack_amg_solvers():
  function test_n_components (line 300) | def test_n_components():
  function test_verbose (line 324) | def test_verbose(assign_labels, capsys):
  function test_pairwise_is_deprecated (line 343) | def test_pairwise_is_deprecated(affinity):
  function test_spectral_clustering_np_matrix_raises (line 350) | def test_spectral_clustering_np_matrix_raises():
  function test_spectral_clustering_not_infinite_loop (line 360) | def test_spectral_clustering_not_infinite_loop(capsys, monkeypatch):

FILE: sklearn/compose/_column_transformer.py
  class ColumnTransformer (line 40) | class ColumnTransformer(TransformerMixin, _BaseComposition):
    method __init__ (line 198) | def __init__(
    method _transformers (line 218) | def _transformers(self):
    method _transformers (line 228) | def _transformers(self, value):
    method get_params (line 234) | def get_params(self, deep=True):
    method set_params (line 254) | def set_params(self, **kwargs):
    method _iter (line 274) | def _iter(self, fitted=False, replace_strings=False, column_as_strings...
    method _validate_transformers (line 320) | def _validate_transformers(self):
    method _validate_column_callables (line 342) | def _validate_column_callables(self, X):
    method _validate_remainder (line 357) | def _validate_remainder(self, X):
    method named_transformers_ (line 379) | def named_transformers_(self):
    method get_feature_names (line 393) | def get_feature_names(self):
    method _get_feature_name_out_for_transformer (line 426) | def _get_feature_name_out_for_transformer(
    method get_feature_names_out (line 456) | def get_feature_names_out(self, input_features=None):
    method _update_fitted_transformers (line 527) | def _update_fitted_transformers(self, transformers):
    method _validate_output (line 550) | def _validate_output(self, result):
    method _record_output_indices (line 565) | def _record_output_indices(self, Xs):
    method _log_message (line 587) | def _log_message(self, name, idx, total):
    method _fit_transform (line 592) | def _fit_transform(self, X, y, func, fitted=False, column_as_strings=F...
    method fit (line 623) | def fit(self, X, y=None):
    method fit_transform (line 645) | def fit_transform(self, X, y=None):
    method transform (line 701) | def transform(self, X):
    method _hstack (line 763) | def _hstack(self, Xs):
    method _sk_visual_block_ (line 793) | def _sk_visual_block_(self):
  function _check_X (line 816) | def _check_X(X):
  function _is_empty_column_selection (line 823) | def _is_empty_column_selection(column):
  function _get_transformer_list (line 841) | def _get_transformer_list(estimators):
  function make_column_transformer (line 853) | def make_column_transformer(
  class make_column_selector (line 966) | class make_column_selector:
    method __init__ (line 1021) | def __init__(self, pattern=None, *, dtype_include=None, dtype_exclude=...
    method __call__ (line 1026) | def __call__(self, df):

FILE: sklearn/compose/_target.py
  class TransformedTargetRegressor (line 19) | class TransformedTargetRegressor(RegressorMixin, BaseEstimator):
    method __init__ (line 130) | def __init__(
    method _fit_transformer (line 145) | def _fit_transformer(self, y):
    method fit (line 189) | def fit(self, X, y, **fit_params):
    method predict (line 254) | def predict(self, X, **predict_params):
    method _more_tags (line 289) | def _more_tags(self):
    method n_features_in_ (line 302) | def n_features_in_(self):

FILE: sklearn/compose/tests/test_column_transformer.py
  class Trans (line 28) | class Trans(BaseEstimator):
    method fit (line 29) | def fit(self, X, y=None):
    method transform (line 32) | def transform(self, X, y=None):
  class DoubleTrans (line 42) | class DoubleTrans(BaseEstimator):
    method fit (line 43) | def fit(self, X, y=None):
    method transform (line 46) | def transform(self, X):
  class SparseMatrixTrans (line 50) | class SparseMatrixTrans(BaseEstimator):
    method fit (line 51) | def fit(self, X, y=None):
    method transform (line 54) | def transform(self, X, y=None):
  class TransNo2D (line 59) | class TransNo2D(BaseEstimator):
    method fit (line 60) | def fit(self, X, y=None):
    method transform (line 63) | def transform(self, X, y=None):
  class TransRaise (line 67) | class TransRaise(BaseEstimator):
    method fit (line 68) | def fit(self, X, y=None):
    method transform (line 71) | def transform(self, X, y=None):
  function test_column_transformer (line 75) | def test_column_transformer():
  function test_column_transformer_dataframe (line 141) | def test_column_transformer_dataframe():
  function test_column_transformer_empty_columns (line 272) | def test_column_transformer_empty_columns(pandas, column_selection, call...
  function test_column_transformer_output_indices (line 319) | def test_column_transformer_output_indices():
  function test_column_transformer_output_indices_df (line 362) | def test_column_transformer_output_indices_df():
  function test_column_transformer_sparse_array (line 393) | def test_column_transformer_sparse_array():
  function test_column_transformer_list (line 416) | def test_column_transformer_list():
  function test_column_transformer_sparse_stacking (line 436) | def test_column_transformer_sparse_stacking():
  function test_column_transformer_mixed_cols_sparse (line 461) | def test_column_transformer_mixed_cols_sparse():
  function test_column_transformer_sparse_threshold (line 483) | def test_column_transformer_sparse_threshold():
  function test_column_transformer_error_msg_1D (line 535) | def test_column_transformer_error_msg_1D():
  function test_2D_transformer_output (line 552) | def test_2D_transformer_output():
  function test_2D_transformer_output_pandas (line 566) | def test_2D_transformer_output_pandas():
  function test_column_transformer_invalid_columns (line 583) | def test_column_transformer_invalid_columns(remainder):
  function test_column_transformer_invalid_transformer (line 618) | def test_column_transformer_invalid_transformer():
  function test_make_column_transformer (line 633) | def test_make_column_transformer():
  function test_make_column_transformer_pandas (line 643) | def test_make_column_transformer_pandas():
  function test_make_column_transformer_kwargs (line 653) | def test_make_column_transformer_kwargs():
  function test_make_column_transformer_remainder_transformer (line 683) | def test_make_column_transformer_remainder_transformer():
  function test_column_transformer_get_set_params (line 693) | def test_column_transformer_get_set_params():
  function test_column_transformer_named_estimators (line 740) | def test_column_transformer_named_estimators():
  function test_column_transformer_cloning (line 760) | def test_column_transformer_cloning():
  function test_column_transformer_get_feature_names (line 777) | def test_column_transformer_get_feature_names(get_names):
  function test_column_transformer_get_feature_names_pipeline (line 808) | def test_column_transformer_get_feature_names_pipeline(X, keys):
  function test_column_transformer_get_feature_names_dataframe (line 854) | def test_column_transformer_get_feature_names_dataframe():
  function test_column_transformer_special_strings (line 904) | def test_column_transformer_special_strings():
  function test_column_transformer_remainder (line 941) | def test_column_transformer_remainder():
  function test_column_transformer_remainder_numpy (line 1001) | def test_column_transformer_remainder_numpy(key):
  function test_column_transformer_remainder_pandas (line 1029) | def test_column_transformer_remainder_pandas(key):
  function test_column_transformer_remainder_transformer (line 1051) | def test_column_transformer_remainder_transformer(key):
  function test_column_transformer_no_remaining_remainder_transformer (line 1068) | def test_column_transformer_no_remaining_remainder_transformer():
  function test_column_transformer_drops_all_remainder_transformer (line 1079) | def test_column_transformer_drops_all_remainder_transformer():
  function test_column_transformer_sparse_remainder_transformer (line 1095) | def test_column_transformer_sparse_remainder_transformer():
  function test_column_transformer_drop_all_sparse_remainder_transformer (line 1116) | def test_column_transformer_drop_all_sparse_remainder_transformer():
  function test_column_transformer_get_set_params_with_remainder (line 1134) | def test_column_transformer_get_set_params_with_remainder():
  function test_column_transformer_no_estimators (line 1178) | def test_column_transformer_no_estimators():
  function test_column_transformer_verbose (line 1261) | def test_column_transformer_verbose(est, pattern, method, capsys):
  function test_column_transformer_no_estimators_set_params (line 1274) | def test_column_transformer_no_estimators_set_params():
  function test_column_transformer_callable_specifier (line 1279) | def test_column_transformer_callable_specifier():
  function test_column_transformer_callable_specifier_dataframe (line 1295) | def test_column_transformer_callable_specifier_dataframe():
  function test_column_transformer_negative_column_indexes (line 1315) | def test_column_transformer_negative_column_indexes():
  function test_column_transformer_mask_indexing (line 1328) | def test_column_transformer_mask_indexing(array_type):
  function test_n_features_in (line 1341) | def test_n_features_in():
  function test_make_column_selector_with_select_dtypes (line 1370) | def test_make_column_selector_with_select_dtypes(cols, pattern, include,...
  function test_column_transformer_with_make_column_selector (line 1389) | def test_column_transformer_with_make_column_selector():
  function test_make_column_selector_error (line 1420) | def test_make_column_selector_error():
  function test_make_column_selector_pickle (line 1428) | def test_make_column_selector_pickle():
  function test_feature_names_empty_columns (line 1460) | def test_feature_names_empty_columns(empty_col, get_names, expected_names):
  function test_feature_names_out_pandas (line 1487) | def test_feature_names_out_pandas(selector):
  function test_feature_names_out_non_pandas (line 1500) | def test_feature_names_out_non_pandas(selector):
  function test_sk_visual_block_remainder (line 1510) | def test_sk_visual_block_remainder(remainder):
  function test_sk_visual_block_remainder_drop (line 1522) | def test_sk_visual_block_remainder_drop():
  function test_sk_visual_block_remainder_fitted_pandas (line 1533) | def test_sk_visual_block_remainder_fitted_pandas(remainder):
  function test_sk_visual_block_remainder_fitted_numpy (line 1556) | def test_sk_visual_block_remainder_fitted_numpy(remainder):
  function test_column_transformers_get_feature_names_deprecated (line 1571) | def test_column_transformers_get_feature_names_deprecated():
  function test_column_transformer_reordered_column_names_remainder (line 1584) | def test_column_transformer_reordered_column_names_remainder(
  function test_feature_name_validation_missing_columns_drop_passthough (line 1620) | def test_feature_name_validation_missing_columns_drop_passthough():
  function test_get_feature_names_empty_selection (line 1657) | def test_get_feature_names_empty_selection(selector):
  function test_feature_names_in_ (line 1666) | def test_feature_names_in_():
  class TransWithNames (line 1686) | class TransWithNames(Trans):
    method __init__ (line 1687) | def __init__(self, feature_names_out=None):
    method get_feature_names_out (line 1690) | def get_feature_names_out(self, input_features=None):
  function test_verbose_feature_names_out_true (line 1763) | def test_verbose_feature_names_out_true(transformers, remainder, expecte...
  function test_verbose_feature_names_out_false (line 1838) | def test_verbose_feature_names_out_false(transformers, remainder, expect...
  function test_verbose_feature_names_out_false_errors (line 1926) | def test_verbose_feature_names_out_false_errors(

FILE: sklearn/compose/tests/test_target.py
  function test_transform_target_regressor_error (line 27) | def test_transform_target_regressor_error():
  function test_transform_target_regressor_invertible (line 60) | def test_transform_target_regressor_invertible():
  function _check_standard_scaled (line 83) | def _check_standard_scaled(y, y_pred):
  function _check_shifted_by_one (line 89) | def _check_shifted_by_one(y, y_pred):
  function test_transform_target_regressor_functions (line 93) | def test_transform_target_regressor_functions():
  function test_transform_target_regressor_functions_multioutput (line 112) | def test_transform_target_regressor_functions_multioutput():
  function test_transform_target_regressor_1d_transformer (line 133) | def test_transform_target_regressor_1d_transformer(X, y):
  function test_transform_target_regressor_2d_transformer (line 164) | def test_transform_target_regressor_2d_transformer(X, y):
  function test_transform_target_regressor_2d_transformer_multioutput (line 198) | def test_transform_target_regressor_2d_transformer_multioutput():
  function test_transform_target_regressor_3d_target (line 224) | def test_transform_target_regressor_3d_target():
  function test_transform_target_regressor_multi_to_single (line 245) | def test_transform_target_regressor_multi_to_single():
  class DummyCheckerArrayTransformer (line 277) | class DummyCheckerArrayTransformer(TransformerMixin, BaseEstimator):
    method fit (line 278) | def fit(self, X, y=None):
    method transform (line 282) | def transform(self, X):
    method inverse_transform (line 286) | def inverse_transform(self, X):
  class DummyCheckerListRegressor (line 291) | class DummyCheckerListRegressor(DummyRegressor):
    method fit (line 292) | def fit(self, X, y, sample_weight=None):
    method predict (line 296) | def predict(self, X):
  function test_transform_target_regressor_ensure_y_array (line 301) | def test_transform_target_regressor_ensure_y_array():
  class DummyTransformer (line 319) | class DummyTransformer(TransformerMixin, BaseEstimator):
    method __init__ (line 322) | def __init__(self, fit_counter=0):
    method fit (line 325) | def fit(self, X, y=None):
    method transform (line 329) | def transform(self, X):
    method inverse_transform (line 332) | def inverse_transform(self, X):
  function test_transform_target_regressor_count_fit (line 337) | def test_transform_target_regressor_count_fit(check_inverse):
  class DummyRegressorWithExtraFitParams (line 348) | class DummyRegressorWithExtraFitParams(DummyRegressor):
    method fit (line 349) | def fit(self, X, y, sample_weight=None, check_input=True):
  function test_transform_target_regressor_pass_fit_parameters (line 356) | def test_transform_target_regressor_pass_fit_parameters():
  function test_transform_target_regressor_route_pipeline (line 366) | def test_transform_target_regressor_route_pipeline():
  class DummyRegressorWithExtraPredictParams (line 380) | class DummyRegressorWithExtraPredictParams(DummyRegressor):
    method predict (line 381) | def predict(self, X, check_input=True):
  function test_transform_target_regressor_pass_extra_predict_parameters (line 389) | def test_transform_target_regressor_pass_extra_predict_parameters():

FILE: sklearn/conftest.py
  function _fetch_fixture (line 41) | def _fetch_fixture(f):
  function pytest_collection_modifyitems (line 68) | def pytest_collection_modifyitems(config, items):
  function pyplot (line 186) | def pyplot():
  function pytest_runtest_setup (line 204) | def pytest_runtest_setup(item):
  function pytest_configure (line 225) | def pytest_configure(config):

FILE: sklearn/covariance/_elliptic_envelope.py
  class EllipticEnvelope (line 12) | class EllipticEnvelope(OutlierMixin, MinCovDet):
    method __init__ (line 141) | def __init__(
    method fit (line 158) | def fit(self, X, y=None):
    method decision_function (line 184) | def decision_function(self, X):
    method score_samples (line 204) | def score_samples(self, X):
    method predict (line 220) | def predict(self, X):
    method score (line 240) | def score(self, X, y, sample_weight=None):

FILE: sklearn/covariance/_empirical_covariance.py
  function log_likelihood (line 24) | def log_likelihood(emp_cov, precision):
  function empirical_covariance (line 51) | def empirical_covariance(X, *, assume_centered=False):
  class EmpiricalCovariance (line 100) | class EmpiricalCovariance(BaseEstimator):
    method __init__ (line 170) | def __init__(self, *, store_precision=True, assume_centered=False):
    method _set_covariance (line 174) | def _set_covariance(self, covariance):
    method get_precision (line 195) | def get_precision(self):
    method fit (line 209) | def fit(self, X, y=None):
    method score (line 236) | def score(self, X_test, y=None):
    method error_norm (line 267) | def error_norm(self, comp_cov, norm="frobenius", scaling=True, squared...
    method mahalanobis (line 318) | def mahalanobis(self, X):

FILE: sklearn/covariance/_graph_lasso.py
  function _objective (line 33) | def _objective(mle, precision_, alpha):
  function _dual_gap (line 46) | def _dual_gap(emp_cov, precision_, alpha):
  function alpha_max (line 58) | def alpha_max(emp_cov):
  class _DictWithDeprecatedKeys (line 77) | class _DictWithDeprecatedKeys(dict):
    method __init__ (line 82) | def __init__(self, **kwargs):
    method __getitem__ (line 86) | def __getitem__(self, key):
    method _set_deprecated (line 95) | def _set_deprecated(self, value, *, new_key, deprecated_key):
  function graphical_lasso (line 101) | def graphical_lasso(
  class GraphicalLasso (line 336) | class GraphicalLasso(EmpiricalCovariance):
    method __init__ (line 432) | def __init__(
    method fit (line 451) | def fit(self, X, y=None):
  function graphical_lasso_path (line 489) | def graphical_lasso_path(
  class GraphicalLassoCV (line 608) | class GraphicalLassoCV(GraphicalLasso):
    method __init__ (line 813) | def __init__(
    method fit (line 840) | def fit(self, X, y=None):
    method grid_scores_ (line 1018) | def grid_scores_(self):
    method cv_alphas_ (line 1038) | def cv_alphas_(self):

FILE: sklearn/covariance/_robust_covariance.py
  function c_step (line 29) | def c_step(
  function _c_step (line 107) | def _c_step(
  function select_candidates (line 208) | def select_candidates(
  function fast_mcd (line 354) | def fast_mcd(
  class MinCovDet (line 576) | class MinCovDet(EmpiricalCovariance):
    method __init__ (line 703) | def __init__(
    method fit (line 716) | def fit(self, X, y=None):
    method correct_covariance (line 769) | def correct_covariance(self, data):
    method reweight_covariance (line 809) | def reweight_covariance(self, data):

FILE: sklearn/covariance/_shrunk_covariance.py
  function shrunk_covariance (line 27) | def shrunk_covariance(emp_cov, shrinkage=0.1):
  class ShrunkCovariance (line 64) | class ShrunkCovariance(EmpiricalCovariance):
    method __init__ (line 148) | def __init__(self, *, store_precision=True, assume_centered=False, shr...
    method fit (line 154) | def fit(self, X, y=None):
  function ledoit_wolf_shrinkage (line 188) | def ledoit_wolf_shrinkage(X, assume_centered=False, block_size=1000):
  function ledoit_wolf (line 283) | def ledoit_wolf(X, *, assume_centered=False, block_size=1000):
  class LedoitWolf (line 347) | class LedoitWolf(EmpiricalCovariance):
    method __init__ (line 448) | def __init__(self, *, store_precision=True, assume_centered=False, blo...
    method fit (line 454) | def fit(self, X, y=None):
  function oas (line 488) | def oas(X, *, assume_centered=False):
  class OAS (line 553) | class OAS(EmpiricalCovariance):
    method fit (line 656) | def fit(self, X, y=None):

FILE: sklearn/covariance/tests/test_covariance.py
  function test_covariance (line 32) | def test_covariance():
  function test_shrunk_covariance (line 79) | def test_shrunk_covariance():
  function test_ledoit_wolf (line 112) | def test_ledoit_wolf():
  function _naive_ledoit_wolf_shrinkage (line 198) | def _naive_ledoit_wolf_shrinkage(X):
  function test_ledoit_wolf_small (line 223) | def test_ledoit_wolf_small():
  function test_ledoit_wolf_large (line 233) | def test_ledoit_wolf_large():
  function test_ledoit_wolf_empty_array (line 251) | def test_ledoit_wolf_empty_array(ledoit_wolf_fitting_function):
  function test_oas (line 258) | def test_oas():
  function test_EmpiricalCovariance_validates_mahalanobis (line 331) | def test_EmpiricalCovariance_validates_mahalanobis():

FILE: sklearn/covariance/tests/test_elliptic_envelope.py
  function test_elliptic_envelope (line 15) | def test_elliptic_envelope():
  function test_score_samples (line 36) | def test_score_samples():

FILE: sklearn/covariance/tests/test_graphical_lasso.py
  function test_graphical_lasso (line 25) | def test_graphical_lasso(random_state=0):
  function test_graphical_lasso_iris (line 68) | def test_graphical_lasso_iris():
  function test_graph_lasso_2D (line 95) | def test_graph_lasso_2D():
  function test_graphical_lasso_iris_singular (line 109) | def test_graphical_lasso_iris_singular():
  function test_graphical_lasso_cv (line 141) | def test_graphical_lasso_cv(random_state=1):
  function test_graphical_lasso_cv_grid_scores_and_cv_alphas_deprecated (line 163) | def test_graphical_lasso_cv_grid_scores_and_cv_alphas_deprecated():
  function test_graphical_lasso_cv_scores (line 202) | def test_graphical_lasso_cv_scores(suffix):
  function test_graphical_lasso_cv_scores_deprecated (line 239) | def test_graphical_lasso_cv_scores_deprecated():

FILE: sklearn/covariance/tests/test_robust_covariance.py
  function test_mcd (line 23) | def test_mcd():
  function test_fast_mcd_on_invalid_input (line 43) | def test_fast_mcd_on_invalid_input():
  function test_mcd_class_on_invalid_input (line 50) | def test_mcd_class_on_invalid_input():
  function launch_mcd_on_dataset (line 58) | def launch_mcd_on_dataset(
  function test_mcd_issue1127 (line 86) | def test_mcd_issue1127():
  function test_mcd_issue3367 (line 95) | def test_mcd_issue3367():
  function test_mcd_support_covariance_is_zero (line 127) | def test_mcd_support_covariance_is_zero():
  function test_mcd_increasing_det_warning (line 143) | def test_mcd_increasing_det_warning():

FILE: sklearn/cross_decomposition/_pls.py
  function _pinv2_old (line 35) | def _pinv2_old(a):
  function _get_first_singular_vectors_power_method (line 53) | def _get_first_singular_vectors_power_method(
  function _get_first_singular_vectors_svd (line 112) | def _get_first_singular_vectors_svd(X, Y):
  function _center_scale_xy (line 122) | def _center_scale_xy(X, Y, scale=True):
  function _svd_flip_1d (line 148) | def _svd_flip_1d(u, v):
  class _PLS (line 158) | class _PLS(
    method __init__ (line 171) | def __init__(
    method fit (line 192) | def fit(self, X, Y):
    method transform (line 366) | def transform(self, X, Y=None, copy=True):
    method inverse_transform (line 405) | def inverse_transform(self, X, Y=None):
    method predict (line 449) | def predict(self, X, copy=True):
    method fit_transform (line 479) | def fit_transform(self, X, y=None):
    method norm_y_weights (line 505) | def norm_y_weights(self):
    method x_mean_ (line 513) | def x_mean_(self):
    method y_mean_ (line 521) | def y_mean_(self):
    method x_std_ (line 529) | def x_std_(self):
    method y_std_ (line 537) | def y_std_(self):
    method x_scores_ (line 541) | def x_scores_(self):
    method y_scores_ (line 555) | def y_scores_(self):
    method _more_tags (line 567) | def _more_tags(self):
  class PLSRegression (line 571) | class PLSRegression(_PLS):
    method __init__ (line 670) | def __init__(
  class PLSCanonical (line 685) | class PLSCanonical(_PLS):
    method __init__ (line 799) | def __init__(
  class CCA (line 821) | class CCA(_PLS):
    method __init__ (line 919) | def __init__(
  class PLSSVD (line 934) | class PLSSVD(TransformerMixin, BaseEstimator):
    method __init__ (line 1018) | def __init__(self, n_components=2, *, scale=True, copy=True):
    method fit (line 1023) | def fit(self, X, Y):
    method x_scores_ (line 1091) | def x_scores_(self):
    method y_scores_ (line 1101) | def y_scores_(self):
    method x_mean_ (line 1109) | def x_mean_(self):
    method y_mean_ (line 1117) | def y_mean_(self):
    method x_std_ (line 1125) | def x_std_(self):
    method y_std_ (line 1133) | def y_std_(self):
    method transform (line 1136) | def transform(self, X, Y=None):
    method fit_transform (line 1168) | def fit_transform(self, X, y=None):

FILE: sklearn/cross_decomposition/tests/test_pls.py
  function assert_matrix_orthogonal (line 21) | def assert_matrix_orthogonal(M):
  function test_pls_canonical_basics (line 26) | def test_pls_canonical_basics():
  function test_sanity_check_pls_regression (line 66) | def test_sanity_check_pls_regression():
  function test_sanity_check_pls_regression_constant_column_Y (line 124) | def test_sanity_check_pls_regression_constant_column_Y():
  function test_sanity_check_pls_canonical (line 174) | def test_sanity_check_pls_canonical():
  function test_sanity_check_pls_canonical_random (line 236) | def test_sanity_check_pls_canonical_random():
  function test_convergence_fail (line 340) | def test_convergence_fail():
  function test_attibutes_shapes (line 352) | def test_attibutes_shapes(Est):
  function test_univariate_equivalence (line 371) | def test_univariate_equivalence(Est):
  function test_copy (line 386) | def test_copy(Est):
  function _generate_test_scale_and_stability_datasets (line 424) | def _generate_test_scale_and_stability_datasets():
  function test_scale_and_stability (line 458) | def test_scale_and_stability(Est, X, Y):
  function test_n_components_bounds (line 473) | def test_n_components_bounds(Est, n_components):
  function test_n_components_bounds_pls_regression (line 487) | def test_n_components_bounds_pls_regression(n_components):
  function test_scores_deprecations (line 501) | def test_scores_deprecations(Est):
  function test_norm_y_weights_deprecation (line 517) | def test_norm_y_weights_deprecation(Est):
  function test_mean_and_std_deprecation (line 529) | def test_mean_and_std_deprecation(Estimator, attribute):
  function test_singular_value_helpers (line 540) | def test_singular_value_helpers(n_samples, n_features, seed):
  function test_one_component_equivalence (line 554) | def test_one_component_equivalence():
  function test_svd_flip_1d (line 566) | def test_svd_flip_1d():
  function test_loadings_converges (line 581) | def test_loadings_converges():
  function test_pls_constant_y (line 597) | def test_pls_constant_y():

FILE: sklearn/datasets/_base.py
  function get_data_home (line 34) | def get_data_home(data_home=None) -> str:
  function clear_data_home (line 62) | def clear_data_home(data_home=None):
  function _convert_data_dataframe (line 75) | def _convert_data_dataframe(
  function load_files (line 93) | def load_files(
  function load_csv_data (line 247) | def load_csv_data(
  function load_gzip_compressed_csv_data (line 314) | def load_gzip_compressed_csv_data(
  function load_descr (line 378) | def load_descr(descr_file_name, *, descr_module=DESCR_MODULE):
  function load_wine (line 403) | def load_wine(*, return_X_y=False, as_frame=False):
  function load_iris (line 520) | def load_iris(*, return_X_y=False, as_frame=False):
  function load_breast_cancer (line 639) | def load_breast_cancer(*, return_X_y=False, as_frame=False):
  function load_digits (line 783) | def load_digits(*, n_class=10, return_X_y=False, as_frame=False):
  function load_diabetes (line 911) | def load_diabetes(*, return_X_y=False, as_frame=False):
  function load_linnerud (line 1010) | def load_linnerud(*, return_X_y=False, as_frame=False):
  function load_boston (line 1152) | def load_boston(*, return_X_y=False):
  function load_sample_images (line 1307) | def load_sample_images():
  function load_sample_image (line 1356) | def load_sample_image(image_name):
  function _pkl_filepath (line 1397) | def _pkl_filepath(*args, **kwargs):
  function _sha256 (line 1414) | def _sha256(path):
  function _fetch_remote (line 1427) | def _fetch_remote(remote, dirname=None):

FILE: sklearn/datasets/_california_housing.py
  function fetch_california_housing (line 53) | def fetch_california_housing(

FILE: sklearn/datasets/_covtype.py
  function fetch_covtype (line 64) | def fetch_covtype(

FILE: sklearn/datasets/_kddcup99.py
  function fetch_kddcup99 (line 49) | def fetch_kddcup99(
  function _fetch_brute_kddcup99 (line 227) | def _fetch_brute_kddcup99(data_home=None, download_if_missing=True, perc...
  function _mkdirp (line 375) | def _mkdirp(d):

FILE: sklearn/datasets/_lfw.py
  function _check_fetch_lfw (line 76) | def _check_fetch_lfw(data_home=None, funneled=True, download_if_missing=...
  function _load_imgs (line 119) | def _load_imgs(file_paths, slice_, color, resize):
  function _fetch_lfw_people (line 182) | def _fetch_lfw_people(
  function fetch_lfw_people (line 225) | def fetch_lfw_people(
  function _fetch_lfw_pairs (line 353) | def _fetch_lfw_pairs(
  function fetch_lfw_pairs (line 405) | def fetch_lfw_pairs(

FILE: sklearn/datasets/_olivetti_faces.py
  function fetch_olivetti_faces (line 39) | def fetch_olivetti_faces(

FILE: sklearn/datasets/_openml.py
  function _get_local_path (line 44) | def _get_local_path(openml_path: str, data_home: str) -> str:
  function _retry_with_clean_cache (line 48) | def _retry_with_clean_cache(openml_path: str, data_home: Optional[str]) ...
  function _open_openml_url (line 75) | def _open_openml_url(openml_path: str, data_home: Optional[str]):
  class OpenMLError (line 134) | class OpenMLError(ValueError):
  function _get_json_content_from_openml_api (line 140) | def _get_json_content_from_openml_api(
  function _split_sparse_columns (line 183) | def _split_sparse_columns(
  function _sparse_data_to_array (line 219) | def _sparse_data_to_array(
  function _convert_arff_data (line 237) | def _convert_arff_data(
  function _feature_to_dtype (line 298) | def _feature_to_dtype(feature: Dict[str, str]):
  function _convert_arff_data_dataframe (line 316) | def _convert_arff_data_dataframe(
  function _get_data_info_by_name (line 375) | def _get_data_info_by_name(
  function _get_data_description_by_id (line 442) | def _get_data_description_by_id(
  function _get_data_features (line 454) | def _get_data_features(data_id: int, data_home: Optional[str]) -> Openml...
  function _get_data_qualities (line 465) | def _get_data_qualities(data_id: int, data_home: Optional[str]) -> Openm...
  function _get_num_samples (line 478) | def _get_num_samples(data_qualities: OpenmlQualitiesType) -> int:
  function _load_arff_response (line 499) | def _load_arff_response(
  function _download_data_to_bunch (line 544) | def _download_data_to_bunch(
  function _verify_target_data_type (line 672) | def _verify_target_data_type(features_dict, target_columns):
  function _valid_data_column_names (line 699) | def _valid_data_column_names(features_list, target_columns):
  function fetch_openml (line 715) | def fetch_openml(

FILE: sklearn/datasets/_rcv1.py
  function fetch_rcv1 (line 79) | def fetch_rcv1(
  function _inverse_permutation (line 282) | def _inverse_permutation(p):
  function _find_permutation (line 291) | def _find_permutation(a, b):

FILE: sklearn/datasets/_samples_generator.py
  function _generate_hypercube (line 23) | def _generate_hypercube(samples, dimensions, rng):
  function make_classification (line 39) | def make_classification(
  function make_multilabel_classification (line 290) | def make_multilabel_classification(
  function make_hastie_10_2 (line 458) | def make_hastie_10_2(n_samples=12000, *, random_state=None):
  function make_regression (line 506) | def make_regression(
  function make_circles (line 640) | def make_circles(
  function make_moons (line 723) | def make_moons(n_samples=100, *, shuffle=True, noise=None, random_state=...
  function make_blobs (line 792) | def make_blobs(
  function make_friedman1 (line 964) | def make_friedman1(n_samples=100, n_features=10, *, noise=0.0, random_st...
  function make_friedman2 (line 1031) | def make_friedman2(n_samples=100, *, noise=0.0, random_state=None):
  function make_friedman3 (line 1096) | def make_friedman3(n_samples=100, *, noise=0.0, random_state=None):
  function make_low_rank_matrix (line 1161) | def make_low_rank_matrix(
  function make_sparse_coded_signal (line 1237) | def make_sparse_coded_signal(
  function make_sparse_uncorrelated (line 1300) | def make_sparse_uncorrelated(n_samples=100, n_features=10, *, random_sta...
  function make_spd_matrix (line 1351) | def make_spd_matrix(n_dim, *, random_state=None):
  function make_sparse_spd_matrix (line 1384) | def make_sparse_spd_matrix(
  function make_swiss_roll (line 1464) | def make_swiss_roll(n_samples=100, *, noise=0.0, random_state=None, hole...
  function make_s_curve (line 1529) | def make_s_curve(n_samples=100, *, noise=0.0, random_state=None):
  function make_gaussian_quantiles (line 1571) | def make_gaussian_quantiles(
  function _shuffle (line 1667) | def _shuffle(data, random_state=None):
  function make_biclusters (line 1676) | def make_biclusters(
  function make_checkerboard (line 1773) | def make_checkerboard(

FILE: sklearn/datasets/_species_distributions.py
  function _load_coverage (line 77) | def _load_coverage(F, header_length=6, dtype=np.int16):
  function _load_csv (line 93) | def _load_csv(F):
  function construct_grids (line 113) | def construct_grids(batch):
  function fetch_species_distributions (line 140) | def fetch_species_distributions(*, data_home=None, download_if_missing=T...

FILE: sklearn/datasets/_svmlight_format_io.py
  function _load_svmlight_file (line 33) | def _load_svmlight_file(*args, **kwargs):
  function load_svmlight_file (line 42) | def load_svmlight_file(
  function _gen_open (line 177) | def _gen_open(f):
  function _open_and_load (line 196) | def _open_and_load(f, dtype, multilabel, zero_based, query_id, offset=0,...
  function load_svmlight_files (line 219) | def load_svmlight_files(
  function _dump_svmlight (line 366) | def _dump_svmlight(X, y, f, multilabel, one_based, comment, query_id):
  function dump_svmlight_file (line 427) | def dump_svmlight_file(

FILE: sklearn/datasets/_twenty_newsgroups.py
  function _download_20newsgroups (line 65) | def _download_20newsgroups(target_dir, cache_path):
  function strip_newsgroup_header (line 93) | def strip_newsgroup_header(text):
  function strip_newsgroup_quoting (line 112) | def strip_newsgroup_quoting(text):
  function strip_newsgroup_footer (line 127) | def strip_newsgroup_footer(text):
  function fetch_20newsgroups (line 152) | def fetch_20newsgroups(
  function fetch_20newsgroups_vectorized (line 334) | def fetch_20newsgroups_vectorized(

FILE: sklearn/datasets/setup.py
  function configuration (line 6) | def configuration(parent_package="", top_path=None):

FILE: sklearn/datasets/tests/conftest.py
  function hide_available_pandas (line 8) | def hide_available_pandas(monkeypatch):

FILE: sklearn/datasets/tests/test_20news.py
  function test_20news (line 19) | def test_20news(fetch_20newsgroups_fxt):
  function test_20news_length_consistency (line 51) | def test_20news_length_consistency(fetch_20newsgroups_fxt):
  function test_20news_vectorized (line 63) | def test_20news_vectorized(fetch_20newsgroups_vectorized_fxt):
  function test_20news_normalization (line 93) | def test_20news_normalization(fetch_20newsgroups_vectorized_fxt):
  function test_20news_as_frame (line 103) | def test_20news_as_frame(fetch_20newsgroups_vectorized_fxt):
  function test_as_frame_no_pandas (line 128) | def test_as_frame_no_pandas(fetch_20newsgroups_vectorized_fxt, hide_avai...
  function test_outdated_pickle (line 132) | def test_outdated_pickle(fetch_20newsgroups_vectorized_fxt):

FILE: sklearn/datasets/tests/test_base.py
  function _remove_dir (line 38) | def _remove_dir(path):
  function data_home (line 44) | def data_home(tmpdir_factory):
  function load_files_root (line 51) | def load_files_root(tmpdir_factory):
  function test_category_dir_1 (line 58) | def test_category_dir_1(load_files_root):
  function test_category_dir_2 (line 68) | def test_category_dir_2(load_files_root):
  function test_data_home (line 74) | def test_data_home(data_home):
  function test_default_empty_load_files (line 89) | def test_default_empty_load_files(load_files_root):
  function test_default_load_files (line 96) | def test_default_load_files(test_category_dir_1, test_category_dir_2, lo...
  function test_load_files_w_categories_desc_and_encoding (line 106) | def test_load_files_w_categories_desc_and_encoding(
  function test_load_files_wo_load_content (line 121) | def test_load_files_wo_load_content(
  function test_load_csv_data (line 139) | def test_load_csv_data(
  function test_load_csv_data_with_descr (line 149) | def test_load_csv_data_with_descr():
  function test_load_gzip_compressed_csv_data (line 175) | def test_load_gzip_compressed_csv_data(filename, kwargs, expected_shape):
  function test_load_gzip_compressed_csv_data_with_descr (line 180) | def test_load_gzip_compressed_csv_data_with_descr():
  function test_load_sample_images (line 194) | def test_load_sample_images():
  function test_load_sample_image (line 210) | def test_load_sample_image():
  function test_load_missing_sample_image_error (line 219) | def test_load_missing_sample_image_error():
  function test_loader (line 248) | def test_loader(loader_func, data_shape, target_shape, n_target, has_des...
  function test_toy_dataset_frame_dtype (line 281) | def test_toy_dataset_frame_dtype(loader_func, data_dtype, target_dtype):
  function test_loads_dumps_bunch (line 291) | def test_loads_dumps_bunch():
  function test_bunch_pickle_generated_with_0_16_and_read_with_0_17 (line 298) | def test_bunch_pickle_generated_with_0_16_and_read_with_0_17():
  function test_bunch_dir (line 319) | def test_bunch_dir():
  function test_load_boston_warning (line 326) | def test_load_boston_warning():
  function test_load_boston_alternative (line 334) | def test_load_boston_alternative():

FILE: sklearn/datasets/tests/test_california_housing.py
  function test_fetch (line 10) | def test_fetch(fetch_california_housing_fxt):
  function test_fetch_asframe (line 21) | def test_fetch_asframe(fetch_california_housing_fxt):
  function test_pandas_dependency_message (line 31) | def test_pandas_dependency_message(fetch_california_housing_fxt, hide_av...

FILE: sklearn/datasets/tests/test_common.py
  function is_pillow_installed (line 11) | def is_pillow_installed():
  function check_pandas_dependency_message (line 40) | def check_pandas_dependency_message(fetch_func):
  function check_return_X_y (line 54) | def check_return_X_y(bunch, dataset_func):
  function check_as_frame (line 61) | def check_as_frame(
  function _skip_network_tests (line 89) | def _skip_network_tests():
  function _generate_func_supporting_param (line 93) | def _generate_func_supporting_param(param, dataset_type=("load", "fetch")):
  function test_common_check_return_X_y (line 119) | def test_common_check_return_X_y(name, dataset_func):
  function test_common_check_as_frame (line 127) | def test_common_check_as_frame(name, dataset_func):
  function test_common_check_pandas_dependency (line 135) | def test_common_check_pandas_dependency(name, dataset_func):

FILE: sklearn/datasets/tests/test_covtype.py
  function test_fetch (line 9) | def test_fetch(fetch_covtype_fxt):
  function test_fetch_asframe (line 32) | def test_fetch_asframe(fetch_covtype_fxt):
  function test_pandas_dependency_message (line 49) | def test_pandas_dependency_message(fetch_covtype_fxt, hide_available_pan...

FILE: sklearn/datasets/tests/test_kddcup99.py
  function test_fetch_kddcup99_percent10 (line 28) | def test_fetch_kddcup99_percent10(
  function test_fetch_kddcup99_return_X_y (line 39) | def test_fetch_kddcup99_return_X_y(fetch_kddcup99_fxt):
  function test_fetch_kddcup99_as_frame (line 45) | def test_fetch_kddcup99_as_frame(fetch_kddcup99_fxt):
  function test_fetch_kddcup99_shuffle (line 50) | def test_fetch_kddcup99_shuffle(fetch_kddcup99_fxt):
  function test_pandas_dependency_message (line 67) | def test_pandas_dependency_message(fetch_kddcup99_fxt, hide_available_pa...
  function test_corrupted_file_error_message (line 71) | def test_corrupted_file_error_message(fetch_kddcup99_fxt, tmp_path):

FILE: sklearn/datasets/tests/test_lfw.py
  function setup_module (line 42) | def setup_module():
  function teardown_module (line 108) | def teardown_module():
  function test_load_empty_lfw_people (line 116) | def test_load_empty_lfw_people():
  function test_load_fake_lfw_people (line 121) | def test_load_fake_lfw_people():
  function test_load_fake_lfw_people_too_restrictive (line 179) | def test_load_fake_lfw_people_too_restrictive():
  function test_load_empty_lfw_pairs (line 188) | def test_load_empty_lfw_pairs():
  function test_load_fake_lfw_pairs (line 193) | def test_load_fake_lfw_pairs():

FILE: sklearn/datasets/tests/test_olivetti_faces.py
  function test_olivetti_faces (line 13) | def test_olivetti_faces(fetch_olivetti_faces_fxt):

FILE: sklearn/datasets/tests/test_openml.py
  function _test_features_list (line 42) | def _test_features_list(data_id):
  function _fetch_dataset_from_openml (line 91) | def _fetch_dataset_from_openml(
  class _MockHTTPResponse (line 186) | class _MockHTTPResponse:
    method __init__ (line 187) | def __init__(self, data, is_gzip):
    method read (line 191) | def read(self, amt=-1):
    method close (line 194) | def close(self):
    method info (line 197) | def info(self):
    method __iter__ (line 202) | def __iter__(self):
    method __enter__ (line 205) | def __enter__(self):
    method __exit__ (line 208) | def __exit__(self, exc_type, exc_val, exc_tb):
  function _monkey_patch_webbased_functions (line 212) | def _monkey_patch_webbased_functions(context, data_id, gzip_response):
  function test_feature_to_dtype (line 342) | def test_feature_to_dtype(feature, expected_dtype):
  function test_feature_to_dtype_error (line 349) | def test_feature_to_dtype_error(feature):
  function test_fetch_openml_iris_pandas (line 358) | def test_fetch_openml_iris_pandas(monkeypatch):
  function test_fetch_openml_iris_pandas_equal_to_no_frame (line 403) | def test_fetch_openml_iris_pandas_equal_to_no_frame(monkeypatch):
  function test_fetch_openml_iris_multitarget_pandas (line 425) | def test_fetch_openml_iris_multitarget_pandas(monkeypatch):
  function test_fetch_openml_anneal_pandas (line 470) | def test_fetch_openml_anneal_pandas(monkeypatch):
  function test_fetch_openml_cpu_pandas (line 512) | def test_fetch_openml_cpu_pandas(monkeypatch):
  function test_fetch_openml_australian_pandas_error_sparse (line 581) | def test_fetch_openml_australian_pandas_error_sparse(monkeypatch):
  function test_fetch_openml_as_frame_auto (line 594) | def test_fetch_openml_as_frame_auto(monkeypatch):
  function test_convert_arff_data_dataframe_warning_low_memory_pandas (line 611) | def test_convert_arff_data_dataframe_warning_low_memory_pandas(monkeypat...
  function test_fetch_openml_adultcensus_pandas_return_X_y (line 626) | def test_fetch_openml_adultcensus_pandas_return_X_y(monkeypatch):
  function test_fetch_openml_adultcensus_pandas (line 657) | def test_fetch_openml_adultcensus_pandas(monkeypatch):
  function test_fetch_openml_miceprotein_pandas (line 697) | def test_fetch_openml_miceprotein_pandas(monkeypatch):
  function test_fetch_openml_emotions_pandas (line 741) | def test_fetch_openml_emotions_pandas(monkeypatch):
  function test_fetch_openml_titanic_pandas (line 790) | def test_fetch_openml_titanic_pandas(monkeypatch):
  function test_fetch_openml_iris (line 872) | def test_fetch_openml_iris(monkeypatch, gzip_response):
  function test_decode_iris (line 888) | def test_decode_iris(monkeypatch):
  function test_fetch_openml_iris_multitarget (line 895) | def test_fetch_openml_iris_multitarget(monkeypatch, gzip_response):
  function test_fetch_openml_anneal (line 922) | def test_fetch_openml_anneal(monkeypatch, gzip_response):
  function test_decode_anneal (line 948) | def test_decode_anneal(monkeypatch):
  function test_fetch_openml_anneal_multitarget (line 955) | def test_fetch_openml_anneal_multitarget(monkeypatch, gzip_response):
  function test_fetch_openml_cpu (line 982) | def test_fetch_openml_cpu(monkeypatch, gzip_response):
  function test_decode_cpu (line 1007) | def test_decode_cpu(monkeypatch):
  function test_fetch_openml_australian (line 1014) | def test_fetch_openml_australian(monkeypatch, gzip_response):
  function test_fetch_openml_adultcensus (line 1048) | def test_fetch_openml_adultcensus(monkeypatch, gzip_response):
  function test_fetch_openml_miceprotein (line 1075) | def test_fetch_openml_miceprotein(monkeypatch, gzip_response):
  function test_fetch_openml_emotions (line 1105) | def test_fetch_openml_emotions(monkeypatch, gzip_response):
  function test_decode_emotions (line 1138) | def test_decode_emotions(monkeypatch):
  function test_open_openml_url_cache (line 1145) | def test_open_openml_url_cache(monkeypatch, gzip_response, tmpdir):
  function test_open_openml_url_unlinks_local_path (line 1163) | def test_open_openml_url_unlinks_local_path(
  function test_retry_with_clean_cache (line 1185) | def test_retry_with_clean_cache(tmpdir):
  function test_retry_with_clean_cache_http_error (line 1208) | def test_retry_with_clean_cache_http_error(tmpdir):
  function test_fetch_openml_cache (line 1225) | def test_fetch_openml_cache(monkeypatch, gzip_response, tmpdir):
  function test_fetch_openml_notarget (line 1259) | def test_fetch_openml_notarget(monkeypatch, gzip_response):
  function test_fetch_openml_inactive (line 1274) | def test_fetch_openml_inactive(monkeypatch, gzip_response):
  function test_fetch_nonexiting (line 1291) | def test_fetch_nonexiting(monkeypatch, gzip_response):
  function test_raises_illegal_multitarget (line 1302) | def test_raises_illegal_multitarget(monkeypatch, gzip_response):
  function test_warn_ignore_attribute (line 1313) | def test_warn_ignore_attribute(monkeypatch, gzip_response):
  function test_string_attribute_without_dataframe (line 1353) | def test_string_attribute_without_dataframe(monkeypatch, gzip_response):
  function test_dataset_with_openml_error (line 1366) | def test_dataset_with_openml_error(monkeypatch, gzip_response):
  function test_dataset_with_openml_warning (line 1375) | def test_dataset_with_openml_warning(monkeypatch, gzip_response):
  function test_illegal_column (line 1384) | def test_illegal_column(monkeypatch, gzip_response):
  function test_fetch_openml_raises_missing_values_target (line 1396) | def test_fetch_openml_raises_missing_values_target(monkeypatch, gzip_res...
  function test_fetch_openml_raises_illegal_argument (line 1404) | def test_fetch_openml_raises_illegal_argument():
  function test_fetch_openml_with_ignored_feature (line 1422) | def test_fetch_openml_with_ignored_feature(monkeypatch, gzip_response):
  function test_fetch_openml_verify_checksum (line 1442) | def test_fetch_openml_verify_checksum(monkeypatch, as_frame, cache, tmpd...
  function test_convert_arff_data_type (line 1484) | def test_convert_arff_data_type():
  function test_missing_values_pandas (line 1503) | def test_missing_values_pandas(monkeypatch):

FILE: sklearn/datasets/tests/test_rcv1.py
  function test_fetch_rcv1 (line 13) | def test_fetch_rcv1(fetch_rcv1_fxt):

FILE: sklearn/datasets/tests/test_samples_generator.py
  function test_make_classification (line 35) | def test_make_classification():
  function test_make_classification_informative_features (line 83) | def test_make_classification_informative_features():
  function test_make_classification_weights_type (line 208) | def test_make_classification_weights_type(weights, err_type, err_msg):
  function test_make_classification_weights_array_or_list_ok (line 214) | def test_make_classification_weights_array_or_list_ok(kwargs):
  function test_make_multilabel_classification_return_sequences (line 221) | def test_make_multilabel_classification_return_sequences():
  function test_make_multilabel_classification_return_indicator (line 238) | def test_make_multilabel_classification_return_indicator():
  function test_make_multilabel_classification_return_indicator_sparse (line 269) | def test_make_multilabel_classification_return_indicator_sparse():
  function test_make_multilabel_classification_valid_arguments (line 291) | def test_make_multilabel_classification_valid_arguments(params, err_msg):
  function test_make_hastie_10_2 (line 296) | def test_make_hastie_10_2():
  function test_make_regression (line 303) | def test_make_regression():
  function test_make_regression_multitarget (line 328) | def test_make_regression_multitarget():
  function test_make_blobs (line 348) | def test_make_blobs():
  function test_make_blobs_n_samples_list (line 366) | def test_make_blobs_n_samples_list():
  function test_make_blobs_n_samples_list_with_centers (line 376) | def test_make_blobs_n_samples_list_with_centers():
  function test_make_blobs_n_samples_centers_none (line 395) | def test_make_blobs_n_samples_centers_none(n_samples):
  function test_make_blobs_return_centers (line 405) | def test_make_blobs_return_centers():
  function test_make_blobs_error (line 415) | def test_make_blobs_error():
  function test_make_friedman1 (line 438) | def test_make_friedman1():
  function test_make_friedman2 (line 453) | def test_make_friedman2():
  function test_make_friedman3 (line 464) | def test_make_friedman3():
  function test_make_low_rank_matrix (line 475) | def test_make_low_rank_matrix():
  function test_make_sparse_coded_signal (line 492) | def test_make_sparse_coded_signal():
  function test_make_sparse_uncorrelated (line 505) | def test_make_sparse_uncorrelated():
  function test_make_spd_matrix (line 512) | def test_make_spd_matrix():
  function test_make_swiss_roll (line 527) | def test_make_swiss_roll(hole):
  function test_make_s_curve (line 536) | def test_make_s_curve():
  function test_make_biclusters (line 545) | def test_make_biclusters():
  function test_make_checkerboard (line 565) | def test_make_checkerboard():
  function test_make_moons (line 592) | def test_make_moons():
  function test_make_moons_unbalanced (line 602) | def test_make_moons_unbalanced():
  function test_make_circles (line 623) | def test_make_circles():
  function test_make_circles_unbalanced (line 656) | def test_make_circles_unbalanced():

FILE: sklearn/datasets/tests/test_svmlight_format.py
  function _load_svmlight_local_test_file (line 30) | def _load_svmlight_local_test_file(filename, **kwargs):
  function test_load_svmlight_file (line 38) | def test_load_svmlight_file():
  function test_load_svmlight_file_fd (line 74) | def test_load_svmlight_file_fd():
  function test_load_svmlight_file_multilabel (line 92) | def test_load_svmlight_file_multilabel():
  function test_load_svmlight_files (line 97) | def test_load_svmlight_files():
  function test_load_svmlight_file_n_features (line 116) | def test_load_svmlight_file_n_features():
  function test_load_compressed (line 134) | def test_load_compressed():
  function test_load_invalid_file (line 162) | def test_load_invalid_file():
  function test_load_invalid_order_file (line 167) | def test_load_invalid_order_file():
  function test_load_zero_based (line 172) | def test_load_zero_based():
  function test_load_zero_based_auto (line 178) | def test_load_zero_based_auto():
  function test_load_with_qid (line 193) | def test_load_with_qid():
  function test_load_large_qid (line 213) | def test_load_large_qid():
  function test_load_invalid_file2 (line 228) | def test_load_invalid_file2():
  function test_not_a_filename (line 236) | def test_not_a_filename():
  function test_invalid_filename (line 243) | def test_invalid_filename():
  function test_dump (line 248) | def test_dump():
  function test_dump_multilabel (line 317) | def test_dump_multilabel():
  function test_dump_concise (line 331) | def test_dump_concise():
  function test_dump_comment (line 362) | def test_dump_comment():
  function test_dump_invalid (line 395) | def test_dump_invalid():
  function test_dump_query_id (line 408) | def test_dump_query_id():
  function test_load_with_long_qid (line 423) | def test_load_with_long_qid():
  function test_load_zeros (line 459) | def test_load_zeros():
  function test_load_with_offsets (line 475) | def test_load_with_offsets(sparsity, n_samples, n_features):
  function test_load_offset_exhaustive_splits (line 511) | def test_load_offset_exhaustive_splits():
  function test_load_with_offsets_error (line 553) | def test_load_with_offsets_error():

FILE: sklearn/decomposition/_base.py
  class _BasePCA (line 19) | class _BasePCA(
    method get_covariance (line 28) | def get_covariance(self):
    method get_precision (line 49) | def get_precision(self):
    method fit (line 82) | def fit(self, X, y=None):
    method transform (line 99) | def transform(self, X):
    method inverse_transform (line 127) | def inverse_transform(self, X):
    method _n_features_out (line 161) | def _n_features_out(self):

FILE: sklearn/decomposition/_dict_learning.py
  function _check_positive_coding (line 26) | def _check_positive_coding(method, positive):
  function _sparse_encode (line 33) | def _sparse_encode(
  function sparse_encode (line 226) | def sparse_encode(
  function _update_dict (line 410) | def _update_dict(
  function dict_learning (line 490) | def dict_learning(
  function dict_learning_online (line 720) | def dict_learning_online(
  class _BaseSparseCoding (line 1017) | class _BaseSparseCoding(_ClassNamePrefixFeaturesOutMixin, TransformerMix...
    method __init__ (line 1020) | def __init__(
    method _transform (line 1038) | def _transform(self, X, dictionary):
    method transform (line 1080) | def transform(self, X):
  class SparseCoder (line 1101) | class SparseCoder(_BaseSparseCoding, BaseEstimator):
    method __init__ (line 1230) | def __init__(
    method fit (line 1253) | def fit(self, X, y=None):
    method components_ (line 1280) | def components_(self):
    method transform (line 1283) | def transform(self, X, y=None):
    method _more_tags (line 1305) | def _more_tags(self):
    method n_components_ (line 1309) | def n_components_(self):
    method n_features_in_ (line 1314) | def n_features_in_(self):
    method _n_features_out (line 1319) | def _n_features_out(self):
  class DictionaryLearning (line 1324) | class DictionaryLearning(_BaseSparseCoding, BaseEstimator):
    method __init__ (line 1508) | def __init__(
    method fit (line 1550) | def fit(self, X, y=None):
    method _n_features_out (line 1596) | def _n_features_out(self):
  class MiniBatchDictionaryLearning (line 1601) | class MiniBatchDictionaryLearning(_BaseSparseCoding, BaseEstimator):
    method __init__ (line 1789) | def __init__(
    method fit (line 1832) | def fit(self, X, y=None):
    method partial_fit (line 1879) | def partial_fit(self, X, y=None, iter_offset=None):
    method _n_features_out (line 1941) | def _n_features_out(self):

FILE: sklearn/decomposition/_factor_analysis.py
  class FactorAnalysis (line 35) | class FactorAnalysis(_ClassNamePrefixFeaturesOutMixin, TransformerMixin,...
    method __init__ (line 162) | def __init__(
    method fit (line 191) | def fit(self, X, y=None):
    method transform (line 303) | def transform(self, X):
    method get_covariance (line 333) | def get_covariance(self):
    method get_precision (line 349) | def get_precision(self):
    method score_samples (line 377) | def score_samples(self, X):
    method score (line 399) | def score(self, X, y=None):
    method _rotate (line 417) | def _rotate(self, components, n_components=None, tol=1e-6):
    method _n_features_out (line 430) | def _n_features_out(self):
  function _ortho_rotation (line 435) | def _ortho_rotation(components, method="varimax", tol=1e-6, max_iter=100):

FILE: sklearn/decomposition/_fastica.py
  function _gs_decorrelation (line 27) | def _gs_decorrelation(w, W, j):
  function _sym_decorrelation (line 52) | def _sym_decorrelation(W):
  function _ica_def (line 62) | def _ica_def(X, tol, g, fun_args, max_iter, w_init):
  function _ica_par (line 97) | def _ica_par(X, tol, g, fun_args, max_iter, w_init):
  function _logcosh (line 127) | def _logcosh(x, fun_args=None):
  function _exp (line 139) | def _exp(x, fun_args):
  function _cube (line 146) | def _cube(x, fun_args):
  function fastica (line 150) | def fastica(
  class FastICA (line 318) | class FastICA(_ClassNamePrefixFeaturesOutMixin, TransformerMixin, BaseEs...
    method __init__ (line 439) | def __init__(
    method _fit (line 463) | def _fit(self, X, compute_sources=False):
    method fit_transform (line 632) | def fit_transform(self, X, y=None):
    method fit (line 652) | def fit(self, X, y=None):
    method transform (line 672) | def transform(self, X, copy=True):
    method inverse_transform (line 700) | def inverse_transform(self, X, copy=True):
    method _n_features_out (line 726) | def _n_features_out(self):

FILE: sklearn/decomposition/_incremental_pca.py
  class IncrementalPCA (line 15) | class IncrementalPCA(_BasePCA):
    method __init__ (line 181) | def __init__(self, n_components=None, *, whiten=False, copy=True, batc...
    method fit (line 187) | def fit(self, X, y=None):
    method partial_fit (line 236) | def partial_fit(self, X, y=None, check_input=True):
    method transform (line 353) | def transform(self, X):

FILE: sklearn/decomposition/_kernel_pca.py
  class KernelPCA (line 24) | class KernelPCA(_ClassNamePrefixFeaturesOutMixin, TransformerMixin, Base...
    method __init__ (line 240) | def __init__(
    method _pairwise (line 284) | def _pairwise(self):
    method lambdas_ (line 294) | def lambdas_(self):
    method alphas_ (line 303) | def alphas_(self):
    method _get_kernel (line 306) | def _get_kernel(self, X, Y=None):
    method _fit_transform (line 315) | def _fit_transform(self, K):
    method _fit_inverse_transform (line 401) | def _fit_inverse_transform(self, X_transformed, X):
    method fit (line 413) | def fit(self, X, y=None):
    method fit_transform (line 446) | def fit_transform(self, X, y=None, **params):
    method transform (line 477) | def transform(self, X):
    method inverse_transform (line 507) | def inverse_transform(self, X):
    method _more_tags (line 558) | def _more_tags(self):
    method _n_features_out (line 565) | def _n_features_out(self):

FILE: sklearn/decomposition/_lda.py
  function _update_doc_distribution (line 34) | def _update_doc_distribution(
  class LatentDirichletAllocation (line 141) | class LatentDirichletAllocation(
    method __init__ (line 323) | def __init__(
    method _check_params (line 360) | def _check_params(self):
    method _init_latent_vars (line 380) | def _init_latent_vars(self, n_features):
    method _e_step (line 409) | def _e_step(self, X, cal_sstats, random_init, parallel=None):
    method _em_step (line 475) | def _em_step(self, X, total_samples, batch_update, parallel=None):
    method _more_tags (line 529) | def _more_tags(self):
    method _check_non_neg_array (line 532) | def _check_non_neg_array(self, X, reset_n_features, whom):
    method partial_fit (line 546) | def partial_fit(self, X, y=None):
    method fit (line 593) | def fit(self, X, y=None):
    method _unnormalized_transform (line 676) | def _unnormalized_transform(self, X):
    method transform (line 693) | def transform(self, X):
    method _approx_bound (line 717) | def _approx_bound(self, X, doc_topic_distr, sub_sampling):
    method score (line 796) | def score(self, X, y=None):
    method _perplexity_precomp_distr (line 821) | def _perplexity_precomp_distr(self, X, doc_topic_distr=None, sub_sampl...
    method perplexity (line 865) | def perplexity(self, X, sub_sampling=False):
    method _n_features_out (line 894) | def _n_features_out(self):

FILE: sklearn/decomposition/_nmf.py
  function norm (line 30) | def norm(x):
  function trace_dot (line 43) | def trace_dot(X, Y):
  function _check_init (line 56) | def _check_init(A, shape, whom):
  function _beta_divergence (line 68) | def _beta_divergence(X, W, H, beta, square_root=False):
  function _special_sparse_dot (line 174) | def _special_sparse_dot(W, H, X):
  function _compute_regularization (line 195) | def _compute_regularization(alpha, alpha_W, alpha_H, l1_ratio, regulariz...
  function _beta_loss_to_float (line 218) | def _beta_loss_to_float(beta_loss):
  function _initialize_nmf (line 232) | def _initialize_nmf(X, n_components, init=None, eps=1e-6, random_state=N...
  function _update_coordinate_descent (line 383) | def _update_coordinate_descent(X, W, Ht, l1_reg, l2_reg, shuffle, random...
  function _fit_coordinate_descent (line 413) | def _fit_coordinate_descent(
  function _multiplicative_update_w (line 533) | def _multiplicative_update_w(
  function _multiplicative_update_h (line 639) | def _multiplicative_update_h(X, W, H, beta_loss, l1_reg_H, l2_reg_H, gam...
  function _fit_multiplicative_update (line 721) | def _fit_multiplicative_update(
  function non_negative_factorization (line 870) | def non_negative_factorization(
  class NMF (line 1112) | class NMF(_ClassNamePrefixFeaturesOutMixin, TransformerMixin, BaseEstima...
    method __init__ (line 1334) | def __init__(
    method _more_tags (line 1367) | def _more_tags(self):
    method _check_params (line 1370) | def _check_params(self, X):
    method _check_w_h (line 1462) | def _check_w_h(self, X, W, H, update_H):
    method _scale_regularization (line 1493) | def _scale_regularization(self, X):
    method fit_transform (line 1512) | def fit_transform(self, X, y=None, W=None, H=None):
    method _fit_transform (line 1554) | def _fit_transform(self, X, y=None, W=None, H=None, update_H=True):
    method fit (line 1650) | def fit(self, X, y=None, **params):
    method transform (line 1674) | def transform(self, X):
    method inverse_transform (line 1698) | def inverse_transform(self, W):
    method _n_features_out (line 1717) | def _n_features_out(self):

FILE: sklearn/decomposition/_pca.py
  function _assess_dimension (line 30) | def _assess_dimension(spectrum, rank, n_samples):
  function _infer_dimension (line 104) | def _infer_dimension(spectrum, n_samples):
  class PCA (line 116) | class PCA(_BasePCA):
    method __init__ (line 354) | def __init__(
    method fit (line 375) | def fit(self, X, y=None):
    method fit_transform (line 402) | def fit_transform(self, X, y=None):
    method _fit (line 436) | def _fit(self, X):
    method _fit_full (line 482) | def _fit_full(self, X, n_components):
    method _fit_truncated (line 548) | def _fit_truncated(self, X, n_components, svd_solver):
    method score_samples (line 624) | def score_samples(self, X):
    method score (line 651) | def score(self, X, y=None):
    method _more_tags (line 673) | def _more_tags(self):

FILE: sklearn/decomposition/_sparse_pca.py
  class SparsePCA (line 14) | class SparsePCA(_ClassNamePrefixFeaturesOutMixin, TransformerMixin, Base...
    method __init__ (line 128) | def __init__(
    method fit (line 155) | def fit(self, X, y=None):
    method transform (line 207) | def transform(self, X):
    method _n_features_out (line 240) | def _n_features_out(self):
  class MiniBatchSparsePCA (line 245) | class MiniBatchSparsePCA(SparsePCA):
    method __init__ (line 357) | def __init__(
    method fit (line 386) | def fit(self, X, y=None):

FILE: sklearn/decomposition/_truncated_svd.py
  class TruncatedSVD (line 24) | class TruncatedSVD(_ClassNamePrefixFeaturesOutMixin, TransformerMixin, B...
    method __init__ (line 142) | def __init__(
    method fit (line 157) | def fit(self, X, y=None):
    method fit_transform (line 176) | def fit_transform(self, X, y=None):
    method transform (line 239) | def transform(self, X):
    method inverse_transform (line 256) | def inverse_transform(self, X):
    method _more_tags (line 274) | def _more_tags(self):
    method _n_features_out (line 278) | def _n_features_out(self):

FILE: sklearn/decomposition/setup.py
  function configuration (line 6) | def configuration(parent_package="", top_path=None):

FILE: sklearn/decomposition/tests/test_dict_learning.py
  function test_sparse_encode_shapes_omp (line 37) | def test_sparse_encode_shapes_omp():
  function test_dict_learning_shapes (line 48) | def test_dict_learning_shapes():
  function test_dict_learning_overcomplete (line 59) | def test_dict_learning_overcomplete():
  function test_max_iter (line 65) | def test_max_iter():
  function test_dict_learning_lars_positive_parameter (line 122) | def test_dict_learning_lars_positive_parameter():
  function test_dict_learning_positivity (line 140) | def test_dict_learning_positivity(transform_algorithm, positive_code, po...
  function test_dict_learning_lars_dict_positivity (line 163) | def test_dict_learning_lars_dict_positivity(positive_dict):
  function test_dict_learning_lars_code_positivity (line 179) | def test_dict_learning_lars_code_positivity():
  function test_dict_learning_reconstruction (line 195) | def test_dict_learning_reconstruction():
  function test_dict_learning_reconstruction_parallel (line 211) | def test_dict_learning_reconstruction_parallel():
  function test_dict_learning_lassocd_readonly_data (line 229) | def test_dict_learning_lassocd_readonly_data():
  function test_dict_learning_nonzero_coefs (line 246) | def test_dict_learning_nonzero_coefs():
  function test_dict_learning_unknown_fit_algorithm (line 262) | def test_dict_learning_unknown_fit_algorithm():
  function test_dict_learning_split (line 269) | def test_dict_learning_split():
  function test_dict_learning_online_shapes (line 283) | def test_dict_learning_online_shapes():
  function test_dict_learning_online_lars_positive_parameter (line 294) | def test_dict_learning_online_lars_positive_parameter():
  function test_minibatch_dictionary_learning_positivity (line 311) | def test_minibatch_dictionary_learning_positivity(
  function test_minibatch_dictionary_learning_lars (line 336) | def test_minibatch_dictionary_learning_lars(positive_dict):
  function test_dict_learning_online_positivity (line 355) | def test_dict_learning_online_positivity(positive_code, positive_dict):
  function test_dict_learning_online_verbosity (line 378) | def test_dict_learning_online_verbosity():
  function test_dict_learning_online_estimator_shapes (line 407) | def test_dict_learning_online_estimator_shapes():
  function test_dict_learning_online_overcomplete (line 414) | def test_dict_learning_online_overcomplete():
  function test_dict_learning_online_initialization (line 420) | def test_dict_learning_online_initialization():
  function test_dict_learning_online_readonly_initialization (line 430) | def test_dict_learning_online_readonly_initialization():
  function test_dict_learning_online_partial_fit (line 440) | def test_dict_learning_online_partial_fit():
  function test_dict_learning_iter_offset (line 465) | def test_dict_learning_iter_offset():
  function test_sparse_encode_shapes (line 482) | def test_sparse_encode_shapes():
  function test_sparse_encode_positivity (line 494) | def test_sparse_encode_positivity(algo, positive):
  function test_sparse_encode_unavailable_positivity (line 507) | def test_sparse_encode_unavailable_positivity(algo):
  function test_sparse_encode_input (line 518) | def test_sparse_encode_input():
  function test_sparse_encode_error (line 530) | def test_sparse_encode_error():
  function test_sparse_encode_error_default_sparsity (line 540) | def test_sparse_encode_error_default_sparsity():
  function test_unknown_method (line 548) | def test_unknown_method():
  function test_sparse_coder_estimator (line 556) | def test_sparse_coder_estimator():
  function test_sparse_coder_estimator_clone (line 568) | def test_sparse_coder_estimator_clone():
  function test_sparse_coder_parallel_mmap (line 586) | def test_sparse_coder_parallel_mmap():
  function test_sparse_coder_common_transformer (line 605) | def test_sparse_coder_common_transformer():
  function test_sparse_coder_deprecation (line 622) | def test_sparse_coder_deprecation():
  function test_sparse_coder_n_features_in (line 633) | def test_sparse_coder_n_features_in():
  function test_update_dict (line 639) | def test_update_dict():
  function test_warning_default_transform_alpha (line 663) | def test_warning_default_transform_alpha(Estimator):
  function test_get_feature_names_out (line 674) | def test_get_feature_names_out(estimator):

FILE: sklearn/decomposition/tests/test_factor_analysis.py
  function test_factor_analysis (line 20) | def test_factor_analysis():

FILE: sklearn/decomposition/tests/test_fastica.py
  function center_and_norm (line 19) | def center_and_norm(x, axis=-1):
  function test_gs (line 35) | def test_gs():
  function test_fastica_simple (line 55) | def test_fastica_simple(add_noise, seed):
  function test_fastica_nowhiten (line 142) | def test_fastica_nowhiten():
  function test_fastica_convergence_fail (line 153) | def test_fastica_convergence_fail():
  function test_non_square_fastica (line 184) | def test_non_square_fastica(add_noise):
  function test_fit_transform (line 229) | def test_fit_transform():
  function test_inverse_transform (line 267) | def test_inverse_transform(whiten, n_components, expected_mixing_shape):
  function test_fastica_errors (line 288) | def test_fastica_errors():
  function test_fastica_whiten_unit_variance (line 309) | def test_fastica_whiten_unit_variance():
  function test_fastica_whiten_default_value_deprecation (line 324) | def test_fastica_whiten_default_value_deprecation(ica):
  function test_fastica_whiten_backwards_compatibility (line 336) | def test_fastica_whiten_backwards_compatibility():
  function test_fastica_output_shape (line 375) | def test_fastica_output_shape(whiten, return_X_mean, return_n_iter):

FILE: sklearn/decomposition/tests/test_incremental_pca.py
  function test_incremental_pca (line 18) | def test_incremental_pca():
  function test_incremental_pca_sparse (line 48) | def test_incremental_pca_sparse(matrix_class):
  function test_incremental_pca_check_projection (line 86) | def test_incremental_pca_check_projection():
  function test_incremental_pca_inverse (line 107) | def test_incremental_pca_inverse():
  function test_incremental_pca_validation (line 123) | def test_incremental_pca_validation():
  function test_n_components_none (line 152) | def test_n_components_none():
  function test_incremental_pca_set_params (line 170) | def test_incremental_pca_set_params():
  function test_incremental_pca_num_features_change (line 193) | def test_incremental_pca_num_features_change():
  function test_incremental_pca_batch_signs (line 205) | def test_incremental_pca_batch_signs():
  function test_incremental_pca_batch_values (line 221) | def test_incremental_pca_batch_values():
  function test_incremental_pca_batch_rank (line 237) | def test_incremental_pca_batch_rank():
  function test_incremental_pca_partial_fit (line 253) | def test_incremental_pca_partial_fit():
  function test_incremental_pca_against_pca_iris (line 273) | def test_incremental_pca_against_pca_iris():
  function test_incremental_pca_against_pca_random_data (line 283) | def test_incremental_pca_against_pca_random_data():
  function test_explained_variances (line 296) | def test_explained_variances():
  function test_singular_values (line 315) | def test_singular_values():
  function test_whitening (line 372) | def test_whitening():
  function test_incremental_pca_partial_fit_float_division (line 393) | def test_incremental_pca_partial_fit_float_division():
  function test_incremental_pca_fit_overflow_error (line 418) | def test_incremental_pca_fit_overflow_error():
  function test_incremental_pca_feature_names_out (line 433) | def test_incremental_pca_feature_names_out():

FILE: sklearn/decomposition/tests/test_kernel_pca.py
  function test_kernel_pca (line 23) | def test_kernel_pca():
  function test_kernel_pca_invalid_solver (line 69) | def test_kernel_pca_invalid_solver():
  function test_kernel_pca_invalid_parameters (line 75) | def test_kernel_pca_invalid_parameters():
  function test_kernel_pca_consistent_transform (line 89) | def test_kernel_pca_consistent_transform():
  function test_kernel_pca_deterministic_output (line 108) | def test_kernel_pca_deterministic_output():
  function test_kernel_pca_sparse (line 125) | def test_kernel_pca_sparse():
  function test_kernel_pca_linear_kernel (line 164) | def test_kernel_pca_linear_kernel(solver, n_features):
  function test_kernel_pca_n_components (line 188) | def test_kernel_pca_n_components():
  function test_remove_zero_eig (line 206) | def test_remove_zero_eig():
  function test_leave_zero_eig (line 228) | def test_leave_zero_eig():
  function test_kernel_pca_precomputed (line 255) | def test_kernel_pca_precomputed():
  function test_kernel_pca_precomputed_non_symmetric (line 294) | def test_kernel_pca_precomputed_non_symmetric(solver):
  function test_kernel_pca_invalid_kernel (line 320) | def test_kernel_pca_invalid_kernel():
  function test_gridsearch_pipeline (line 332) | def test_gridsearch_pipeline():
  function test_gridsearch_pipeline_precomputed (line 347) | def test_gridsearch_pipeline_precomputed():
  function test_nested_circles (line 363) | def test_nested_circles():
  function test_kernel_conditioning (line 391) | def test_kernel_conditioning():
  function test_precomputed_kernel_not_psd (line 408) | def test_precomputed_kernel_not_psd(solver):
  function test_kernel_pca_solvers_equivalence (line 460) | def test_kernel_pca_solvers_equivalence(n_components):
  function test_kernel_pca_inverse_transform_reconstruction (line 496) | def test_kernel_pca_inverse_transform_reconstruction():
  function test_kernel_pca_raise_not_fitted_error (line 513) | def test_kernel_pca_raise_not_fitted_error():
  function test_32_64_decomposition_shape (line 521) | def test_32_64_decomposition_shape():
  function test_kernel_pcc_pairwise_is_deprecated (line 539) | def test_kernel_pcc_pairwise_is_deprecated():
  function test_kernel_pca_lambdas_deprecated (line 551) | def test_kernel_pca_lambdas_deprecated():
  function test_kernel_pca_alphas_deprecated (line 560) | def test_kernel_pca_alphas_deprecated():
  function test_kernel_pca_feature_names_out (line 568) | def test_kernel_pca_feature_names_out():

FILE: sklearn/decomposition/tests/test_nmf.py
  function test_convergence_warning (line 24) | def test_convergence_warning(solver):
  function test_initialize_nn_output (line 33) | def test_initialize_nn_output():
  function test_parameter_checking (line 42) | def test_parameter_checking():
  function test_initialize_close (line 85) | def test_initialize_close():
  function test_initialize_variants (line 97) | def test_initialize_variants():
  function test_nmf_fit_nn_output (line 117) | def test_nmf_fit_nn_output(solver, init, alpha_W, alpha_H):
  function test_nmf_fit_close (line 133) | def test_nmf_fit_close(solver):
  function test_nmf_transform (line 148) | def test_nmf_transform(solver):
  function test_nmf_transform_custom_init (line 164) | def test_nmf_transform_custom_init():
  function test_nmf_inverse_transform (line 179) | def test_nmf_inverse_transform(solver):
  function test_n_components_greater_n_features (line 195) | def test_n_components_greater_n_features():
  function test_nmf_sparse_input (line 205) | def test_nmf_sparse_input(solver, alpha_W, alpha_H):
  function test_nmf_sparse_transform (line 234) | def test_nmf_sparse_transform():
  function test_non_negative_factorization_consistency (line 254) | def test_non_negative_factorization_consistency(init, solver, alpha_W, a...
  function test_non_negative_factorization_checking (line 297) | def test_non_negative_factorization_checking():
  function _beta_divergence_dense (line 328) | def _beta_divergence_dense(X, W, H, beta):
  function test_beta_divergence (line 358) | def test_beta_divergence():
  function test_special_sparse_dot (line 381) | def test_special_sparse_dot():
  function test_nmf_multiplicative_update_sparse (line 409) | def test_nmf_multiplicative_update_sparse():
  function test_nmf_negative_beta_loss (line 487) | def test_nmf_negative_beta_loss():
  function test_nmf_regularization (line 524) | def test_nmf_regularization(solver):
  function test_nmf_decreasing (line 595) | def test_nmf_decreasing(solver):
  function test_nmf_underflow (line 647) | def test_nmf_underflow():
  function test_nmf_dtype_match (line 674) | def test_nmf_dtype_match(dtype_in, dtype_out, solver, alpha_W, alpha_H):
  function test_nmf_float32_float64_consistency (line 686) | def test_nmf_float32_float64_consistency(solver):
  function test_nmf_custom_init_dtype_error (line 699) | def test_nmf_custom_init_dtype_error():
  function test_feature_names_out (line 714) | def test_feature_names_out():

FILE: sklearn/decomposition/tests/test_online_lda.py
  function _build_sparse_mtx (line 26) | def _build_sparse_mtx():
  function test_lda_default_prior_params (line 37) | def test_lda_default_prior_params():
  function test_lda_fit_batch (line 54) | def test_lda_fit_batch():
  function test_lda_fit_online (line 73) | def test_lda_fit_online():
  function test_lda_partial_fit (line 93) | def test_lda_partial_fit():
  function test_lda_dense_input (line 113) | def test_lda_dense_input():
  function test_lda_transform (line 129) | def test_lda_transform():
  function test_lda_fit_transform (line 142) | def test_lda_fit_transform(method):
  function test_invalid_params (line 155) | def test_invalid_params():
  function test_lda_negative_input (line 171) | def test_lda_negative_input():
  function test_lda_no_component_error (line 180) | def test_lda_no_component_error():
  function test_lda_multi_jobs (line 196) | def test_lda_multi_jobs(method):
  function test_lda_partial_fit_multi_jobs (line 216) | def test_lda_partial_fit_multi_jobs():
  function test_lda_preplexity_mismatch (line 236) | def test_lda_preplexity_mismatch():
  function test_lda_perplexity (line 260) | def test_lda_perplexity(method):
  function test_lda_score (line 291) | def test_lda_score(method):
  function test_perplexity_input_format (line 317) | def test_perplexity_input_format():
  function test_lda_score_perplexity (line 334) | def test_lda_score_perplexity():
  function test_lda_fit_perplexity (line 348) | def test_lda_fit_perplexity():
  function test_lda_empty_docs (line 370) | def test_lda_empty_docs():
  function test_dirichlet_expectation (line 380) | def test_dirichlet_expectation():
  function check_verbosity (line 396) | def check_verbosity(verbose, evaluate_every, expected_lines, expected_pe...
  function test_verbosity (line 429) | def test_verbosity(verbose, evaluate_every, expected_lines, expected_per...
  function test_lda_feature_names_out (line 433) | def test_lda_feature_names_out():

FILE: sklearn/decomposition/tests/test_pca.py
  function test_pca (line 21) | def test_pca(svd_solver, n_components):
  function test_no_empty_slice_warning (line 41) | def test_no_empty_slice_warning():
  function test_whitening (line 54) | def test_whitening(solver, copy):
  function test_pca_explained_variance_equivalence_solver (line 108) | def test_pca_explained_variance_equivalence_solver(svd_solver):
  function test_pca_explained_variance_empirical (line 138) | def test_pca_explained_variance_empirical(X, svd_solver):
  function test_pca_singular_values_consistency (line 149) | def test_pca_singular_values_consistency(svd_solver):
  function test_pca_singular_values (line 164) | def test_pca_singular_values(svd_solver):
  function test_pca_check_projection (line 194) | def test_pca_check_projection(svd_solver):
  function test_pca_check_projection_list (line 209) | def test_pca_check_projection_list(svd_solver):
  function test_pca_inverse (line 221) | def test_pca_inverse(svd_solver, whiten):
  function test_pca_validation (line 267) | def test_pca_validation(svd_solver, data, n_components, err_msg):
  function test_n_components_none (line 303) | def test_n_components_none(data, solver, n_components_):
  function test_n_components_mle (line 310) | def test_n_components_mle(svd_solver):
  function test_n_components_mle_error (line 321) | def test_n_components_mle_error(svd_solver):
  function test_pca_dim (line 335) | def test_pca_dim():
  function test_infer_dim_1 (line 346) | def test_infer_dim_1():
  function test_infer_dim_2 (line 363) | def test_infer_dim_2():
  function test_infer_dim_3 (line 377) | def test_infer_dim_3():
  function test_infer_dim_by_explained_variance (line 398) | def test_infer_dim_by_explained_variance(X, n_components, n_components_v...
  function test_pca_score (line 406) | def test_pca_score(svd_solver):
  function test_pca_score3 (line 427) | def test_pca_score3():
  function test_pca_sanity_noise_variance (line 443) | def test_pca_sanity_noise_variance(svd_solver):
  function test_pca_score_consistency_solvers (line 455) | def test_pca_score_consistency_solvers(svd_solver):
  function test_pca_zero_noise_variance_edge_cases (line 467) | def test_pca_zero_noise_variance_edge_cases(svd_solver):
  function test_pca_svd_solver_auto (line 494) | def test_pca_svd_solver_auto(data, n_components, expected_solver):
  function test_pca_sparse_input (line 505) | def test_pca_sparse_input(svd_solver):
  function test_pca_bad_solver (line 515) | def test_pca_bad_solver():
  function test_pca_deterministic_output (line 523) | def test_pca_deterministic_output(svd_solver):
  function test_pca_dtype_preservation (line 535) | def test_pca_dtype_preservation(svd_solver):
  function check_pca_float_dtype_preservation (line 540) | def check_pca_float_dtype_preservation(svd_solver):
  function check_pca_int_dtype_upcast_to_double (line 559) | def check_pca_int_dtype_upcast_to_double(svd_solver):
  function test_pca_n_components_mostly_explained_variance_ratio (line 576) | def test_pca_n_components_mostly_explained_variance_ratio():
  function test_assess_dimension_bad_rank (line 588) | def test_assess_dimension_bad_rank():
  function test_small_eigenvalues_mle (line 597) | def test_small_eigenvalues_mle():
  function test_mle_redundant_data (line 610) | def test_mle_redundant_data():
  function test_fit_mle_too_few_samples (line 625) | def test_fit_mle_too_few_samples():
  function test_mle_simple_case (line 638) | def test_mle_simple_case():
  function test_assess_dimesion_rank_one (line 649) | def test_assess_dimesion_rank_one():
  function test_pca_randomized_svd_n_oversamples (line 662) | def test_pca_randomized_svd_n_oversamples():
  function test_pca_params_validation (line 703) | def test_pca_params_validation(params, err_type, err_msg):
  function test_feature_names_out (line 711) | def test_feature_names_out():

FILE: sklearn/decomposition/tests/test_sparse_pca.py
  function generate_toy_data (line 18) | def generate_toy_data(n_components, n_samples, image_size, random_state=...
  function test_correct_shapes (line 44) | def test_correct_shapes():
  function test_fit_transform (line 58) | def test_fit_transform():
  function test_fit_transform_parallel (line 72) | def test_fit_transform_parallel():
  function test_transform_nan (line 88) | def test_transform_nan():
  function test_fit_transform_tall (line 98) | def test_fit_transform_tall():
  function test_initialization (line 108) | def test_initialization():
  function test_mini_batch_correct_shapes (line 119) | def test_mini_batch_correct_shapes():
  function test_mini_batch_fit_transform (line 135) | def test_mini_batch_fit_transform():
  function test_scaling_fit_transform (line 166) | def test_scaling_fit_transform():
  function test_pca_vs_spca (line 176) | def test_pca_vs_spca():
  function test_spca_n_components_ (line 196) | def test_spca_n_components_(SPCA, n_components):
  function test_spca_feature_names_out (line 210) | def test_spca_feature_names_out(SPCA):

FILE: sklearn/decomposition/tests/test_truncated_svd.py
  function X_sparse (line 16) | def X_sparse():
  function test_solvers (line 26) | def test_solvers(X_sparse, solver, kind):
  function test_attributes (line 43) | def test_attributes(n_components, X_sparse):
  function test_too_many_components (line 51) | def test_too_many_components(algorithm, X_sparse):
  function test_sparse_formats (line 60) | def test_sparse_formats(fmt, X_sparse):
  function test_inverse_transform (line 71) | def test_inverse_transform(algo, X_sparse):
  function test_integers (line 80) | def test_integers(X_sparse):
  function test_explained_variance (line 91) | def test_explained_variance(X_sparse, kind, n_components, solver):
  function test_explained_variance_components_10_20 (line 114) | def test_explained_variance_components_10_20(X_sparse, kind, solver):
  function test_singular_values_consistency (line 133) | def test_singular_values_consistency(solver):
  function test_singular_values_expected (line 156) | def test_singular_values_expected(solver):
  function test_truncated_svd_eq_pca (line 176) | def test_truncated_svd_eq_pca(X_sparse):
  function test_fit_transform (line 200) | def test_fit_transform(X_sparse, algorithm, tol, kind):

FILE: sklearn/discriminant_analysis.py
  function _cov (line 30) | def _cov(X, shrinkage=None, covariance_estimator=None):
  function _class_means (line 96) | def _class_means(X, y):
  function _class_cov (line 120) | def _class_cov(X, y, priors, shrinkage=None, covariance_estimator=None):
  class LinearDiscriminantAnalysis (line 167) | class LinearDiscriminantAnalysis(
    method __init__ (line 312) | def __init__(
    method _solve_lsqr (line 330) | def _solve_lsqr(self, X, y, shrinkage, covariance_estimator):
    method _solve_eigen (line 386) | def _solve_eigen(self, X, y, shrinkage, covariance_estimator):
    method _solve_svd (line 452) | def _solve_svd(self, X, y):
    method fit (line 522) | def fit(self, X, y):
    method transform (line 619) | def transform(self, X):
    method predict_proba (line 646) | def predict_proba(self, X):
    method predict_log_proba (line 668) | def predict_log_proba(self, X):
    method decision_function (line 685) | def decision_function(self, X):
  class QuadraticDiscriminantAnalysis (line 709) | class QuadraticDiscriminantAnalysis(ClassifierMixin, BaseEstimator):
    method __init__ (line 810) | def __init__(
    method fit (line 818) | def fit(self, X, y):
    method _decision_function (line 893) | def _decision_function(self, X):
    method decision_function (line 909) | def decision_function(self, X):
    method predict (line 935) | def predict(self, X):
    method predict_proba (line 955) | def predict_proba(self, X):
    method predict_log_proba (line 975) | def predict_log_proba(self, X):

FILE: sklearn/dummy.py
  class DummyClassifier (line 23) | class DummyClassifier(MultiOutputMixin, ClassifierMixin, BaseEstimator):
    method __init__ (line 109) | def __init__(self, *, strategy="prior", random_state=None, constant=No...
    method fit (line 114) | def fit(self, X, y, sample_weight=None):
    method predict (line 214) | def predict(self, X):
    method predict_proba (line 301) | def predict_proba(self, X):
    method predict_log_proba (line 364) | def predict_log_proba(self, X):
    method _more_tags (line 386) | def _more_tags(self):
    method score (line 396) | def score(self, X, y, sample_weight=None):
    method n_features_in_ (line 431) | def n_features_in_(self):
  class DummyRegressor (line 436) | class DummyRegressor(MultiOutputMixin, RegressorMixin, BaseEstimator):
    method __init__ (line 502) | def __init__(self, *, strategy="mean", constant=None, quantile=None):
    method fit (line 507) | def fit(self, X, y, sample_weight=None):
    method predict (line 598) | def predict(self, X, return_std=False):
    method _more_tags (line 636) | def _more_tags(self):
    method score (line 639) | def score(self, X, y, sample_weight=None):
    method n_features_in_ (line 678) | def n_features_in_(self):

FILE: sklearn/ensemble/_bagging.py
  function _generate_indices (line 33) | def _generate_indices(random_state, bootstrap, n_population, n_samples):
  function _generate_bagging_indices (line 46) | def _generate_bagging_indices(
  function _parallel_build_estimators (line 70) | def _parallel_build_estimators(
  function _parallel_predict_proba (line 134) | def _parallel_predict_proba(estimators, estimators_features, X, n_classes):
  function _parallel_predict_log_proba (line 161) | def _parallel_predict_log_proba(estimators, estimators_features, X, n_cl...
  function _parallel_decision_function (line 186) | def _parallel_decision_function(estimators, estimators_features, X):
  function _parallel_predict_regression (line 194) | def _parallel_predict_regression(estimators, estimators_features, X):
  class BaseBagging (line 202) | class BaseBagging(BaseEnsemble, metaclass=ABCMeta):
    method __init__ (line 210) | def __init__(
    method fit (line 237) | def fit(self, X, y, sample_weight=None):
    method _parallel_args (line 271) | def _parallel_args(self):
    method _fit (line 274) | def _fit(self, X, y, max_samples=None, max_depth=None, sample_weight=N...
    method _set_oob_score (line 424) | def _set_oob_score(self, X, y):
    method _validate_y (line 427) | def _validate_y(self, y):
    method _get_estimators_indices (line 433) | def _get_estimators_indices(self):
    method estimators_samples_ (line 451) | def estimators_samples_(self):
    method n_features_ (line 472) | def n_features_(self):
  class BaggingClassifier (line 476) | class BaggingClassifier(ClassifierMixin, BaseBagging):
    method __init__ (line 645) | def __init__(
    method _validate_estimator (line 675) | def _validate_estimator(self):
    method _set_oob_score (line 679) | def _set_oob_score(self, X, y):
    method _validate_y (line 718) | def _validate_y(self, y):
    method predict (line 726) | def predict(self, X):
    method predict_proba (line 747) | def predict_proba(self, X):
    method predict_log_proba (line 801) | def predict_log_proba(self, X):
    method decision_function (line 860) | def decision_function(self, X):
  class BaggingRegressor (line 908) | class BaggingRegressor(RegressorMixin, BaseBagging):
    method __init__ (line 1068) | def __init__(
    method predict (line 1097) | def predict(self, X):
    method _validate_estimator (line 1143) | def _validate_estimator(self):
    method _set_oob_score (line 1147) | def _set_oob_score(self, X, y):

FILE: sklearn/ensemble/_base.py
  function _fit_single_estimator (line 24) | def _fit_single_estimator(
  function _set_random_states (line 46) | def _set_random_states(estimator, random_state=None):
  class BaseEnsemble (line 84) | class BaseEnsemble(MetaEstimatorMixin, BaseEstimator, metaclass=ABCMeta):
    method __init__ (line 115) | def __init__(self, base_estimator, *, n_estimators=10, estimator_param...
    method _validate_estimator (line 125) | def _validate_estimator(self, default=None):
    method _make_estimator (line 152) | def _make_estimator(self, append=True, random_state=None):
    method __len__ (line 178) | def __len__(self):
    method __getitem__ (line 182) | def __getitem__(self, index):
    method __iter__ (line 186) | def __iter__(self):
  function _partition_estimators (line 191) | def _partition_estimators(n_estimators, n_jobs):
  class _BaseHeterogeneousEnsemble (line 204) | class _BaseHeterogeneousEnsemble(
    method named_estimators (line 228) | def named_estimators(self):
    method __init__ (line 238) | def __init__(self, estimators):
    method _validate_estimators (line 241) | def _validate_estimators(self):
    method set_params (line 270) | def set_params(self, **params):
    method get_params (line 295) | def get_params(self, deep=True):

FILE: sklearn/ensemble/_forest.py
  function _get_n_samples_bootstrap (line 85) | def _get_n_samples_bootstrap(n_samples, max_samples):
  function _generate_sample_indices (line 124) | def _generate_sample_indices(random_state, n_samples, n_samples_bootstrap):
  function _generate_unsampled_indices (line 134) | def _generate_unsampled_indices(random_state, n_samples, n_samples_boots...
  function _parallel_build_trees (line 148) | def _parallel_build_trees(
  class BaseForest (line 192) | class BaseForest(MultiOutputMixin, BaseEnsemble, metaclass=ABCMeta):
    method __init__ (line 201) | def __init__(
    method apply (line 231) | def apply(self, X):
    method decision_path (line 257) | def decision_path(self, X):
    method fit (line 297) | def fit(self, X, y, sample_weight=None):
    method _set_oob_score_and_attributes (line 488) | def _set_oob_score_and_attributes(self, X, y):
    method _compute_oob_predictions (line 499) | def _compute_oob_predictions(self, X, y):
    method _validate_y_class_weight (line 561) | def _validate_y_class_weight(self, y):
    method _validate_X_predict (line 565) | def _validate_X_predict(self, X):
    method feature_importances_ (line 575) | def feature_importances_(self):
    method n_features_ (line 618) | def n_features_(self):
  function _accumulate_prediction (line 623) | def _accumulate_prediction(predict, X, out, lock):
  class ForestClassifier (line 639) | class ForestClassifier(ClassifierMixin, BaseForest, metaclass=ABCMeta):
    method __init__ (line 648) | def __init__(
    method _get_oob_predictions (line 678) | def _get_oob_predictions(tree, X):
    method _set_oob_score_and_attributes (line 705) | def _set_oob_score_and_attributes(self, X, y):
    method _validate_y_class_weight (line 723) | def _validate_y_class_weight(self, y):
    method predict (line 777) | def predict(self, X):
    method predict_proba (line 816) | def predict_proba(self, X):
    method predict_log_proba (line 868) | def predict_log_proba(self, X):
    method _more_tags (line 900) | def _more_tags(self):
  class ForestRegressor (line 904) | class ForestRegressor(RegressorMixin, BaseForest, metaclass=ABCMeta):
    method __init__ (line 913) | def __init__(
    method predict (line 940) | def predict(self, X):
    method _get_oob_predictions (line 988) | def _get_oob_predictions(tree, X):
    method _set_oob_score_and_attributes (line 1012) | def _set_oob_score_and_attributes(self, X, y):
    method _compute_partial_dependence_recursion (line 1028) | def _compute_partial_dependence_recursion(self, grid, target_features):
    method _more_tags (line 1061) | def _more_tags(self):
  class RandomForestClassifier (line 1065) | class RandomForestClassifier(ForestClassifier):
    method __init__ (line 1341) | def __init__(
  class RandomForestRegressor (line 1399) | class RandomForestRegressor(ForestRegressor):
    method __init__ (line 1662) | def __init__(
  class ExtraTreesClassifier (line 1718) | class ExtraTreesClassifier(ForestClassifier):
    method __init__ (line 1987) | def __init__(
  class ExtraTreesRegressor (line 2045) | class ExtraTreesRegressor(ForestRegressor):
    method __init__ (line 2291) | def __init__(
  class RandomTreesEmbedding (line 2347) | class RandomTreesEmbedding(BaseForest):
    method __init__ (line 2527) | def __init__(
    method _set_oob_score_and_attributes (line 2574) | def _set_oob_score_and_attributes(self, X, y):
    method fit (line 2577) | def fit(self, X, y=None, sample_weight=None):
    method fit_transform (line 2606) | def fit_transform(self, X, y=None, sample_weight=None):
    method transform (line 2638) | def transform(self, X):

FILE: sklearn/ensemble/_gb.py
  class VerboseReporter (line 59) | class VerboseReporter:
    method __init__ (line 70) | def __init__(self, verbose):
    method init (line 73) | def init(self, est, begin_at_stage=0):
    method update (line 103) | def update(self, j, est):
  class BaseGradientBoosting (line 138) | class BaseGradientBoosting(BaseEnsemble, metaclass=ABCMeta):
    method __init__ (line 142) | def __init__(
    method _validate_y (line 191) | def _validate_y(self, y, sample_weight=None):
    method _fit_stage (line 194) | def _fit_stage(
    method _check_params (line 266) | def _check_params(self):
    method _init_state (line 367) | def _init_state(self):
    method _clear_state (line 380) | def _clear_state(self):
    method _resize_state (line 393) | def _resize_state(self):
    method _is_initialized (line 418) | def _is_initialized(self):
    method _check_initialized (line 421) | def _check_initialized(self):
    method _warn_mae_for_criterion (line 426) | def _warn_mae_for_criterion(self):
    method fit (line 429) | def fit(self, X, y, sample_weight=None, monitor=None):
    method _fit_stages (line 609) | def _fit_stages(
    method _make_estimator (line 715) | def _make_estimator(self, append=True):
    method _raw_predict_init (line 719) | def _raw_predict_init(self, X):
    method _raw_predict (line 733) | def _raw_predict(self, X):
    method _staged_raw_predict (line 739) | def _staged_raw_predict(self, X):
    method feature_importances_ (line 769) | def feature_importances_(self):
    method _compute_partial_dependence_recursion (line 809) | def _compute_partial_dependence_recursion(self, grid, target_features):
    method apply (line 850) | def apply(self, X):
    method n_features_ (line 892) | def n_features_(self):
  class GradientBoostingClassifier (line 896) | class GradientBoostingClassifier(ClassifierMixin, BaseGradientBoosting):
    method __init__ (line 1215) | def __init__(
    method _validate_y (line 1263) | def _validate_y(self, y, sample_weight):
    method _warn_mae_for_criterion (line 1278) | def _warn_mae_for_criterion(self):
    method decision_function (line 1289) | def decision_function(self, X):
    method staged_decision_function (line 1316) | def staged_decision_function(self, X):
    method predict (line 1340) | def predict(self, X):
    method staged_predict (line 1359) | def staged_predict(self, X):
    method predict_proba (line 1381) | def predict_proba(self, X):
    method predict_log_proba (line 1412) | def predict_log_proba(self, X):
    method staged_predict_proba (line 1436) | def staged_predict_proba(self, X):
  class GradientBoostingRegressor (line 1465) | class GradientBoostingRegressor(RegressorMixin, BaseGradientBoosting):
    method __init__ (line 1793) | def __init__(
    method _validate_y (line 1843) | def _validate_y(self, y, sample_weight=None):
    method _warn_mae_for_criterion (line 1848) | def _warn_mae_for_criterion(self):
    method predict (line 1858) | def predict(self, X):
    method staged_predict (line 1879) | def staged_predict(self, X):
    method apply (line 1900) | def apply(self, X):
    method n_classes_ (line 1930) | def n_classes_(self):

FILE: sklearn/ensemble/_gb_losses.py
  class LossFunction (line 17) | class LossFunction(metaclass=ABCMeta):
    method __init__ (line 35) | def __init__(self, n_classes):
    method init_estimator (line 38) | def init_estimator(self):
    method __call__ (line 43) | def __call__(self, y, raw_predictions, sample_weight=None):
    method negative_gradient (line 59) | def negative_gradient(self, y, raw_predictions, **kargs):
    method update_terminal_regions (line 72) | def update_terminal_regions(
    method _update_terminal_region (line 138) | def _update_terminal_region(
    method get_init_raw_predictions (line 152) | def get_init_raw_predictions(self, X, estimator):
  class RegressionLossFunction (line 173) | class RegressionLossFunction(LossFunction, metaclass=ABCMeta):
    method __init__ (line 176) | def __init__(self):
    method check_init_estimator (line 179) | def check_init_estimator(self, estimator):
    method get_init_raw_predictions (line 193) | def get_init_raw_predictions(self, X, estimator):
  class LeastSquaresError (line 198) | class LeastSquaresError(RegressionLossFunction):
    method init_estimator (line 208) | def init_estimator(self):
    method __call__ (line 211) | def __call__(self, y, raw_predictions, sample_weight=None):
    method negative_gradient (line 234) | def negative_gradient(self, y, raw_predictions, **kargs):
    method update_terminal_regions (line 248) | def update_terminal_regions(
    method _update_terminal_region (line 290) | def _update_terminal_region(
  class LeastAbsoluteError (line 304) | class LeastAbsoluteError(RegressionLossFunction):
    method init_estimator (line 313) | def init_estimator(self):
    method __call__ (line 316) | def __call__(self, y, raw_predictions, sample_weight=None):
    method negative_gradient (line 339) | def negative_gradient(self, y, raw_predictions, **kargs):
    method _update_terminal_region (line 356) | def _update_terminal_region(
  class HuberLossFunction (line 378) | class HuberLossFunction(RegressionLossFunction):
    method __init__ (line 394) | def __init__(self, alpha=0.9):
    method init_estimator (line 399) | def init_estimator(self):
    method __call__ (line 402) | def __call__(self, y, raw_predictions, sample_weight=None):
    method negative_gradient (line 443) | def negative_gradient(self, y, raw_predictions, sample_weight=None, **...
    method _update_terminal_region (line 471) | def _update_terminal_region(
  class QuantileLossFunction (line 495) | class QuantileLossFunction(RegressionLossFunction):
    method __init__ (line 507) | def __init__(self, alpha=0.9):
    method init_estimator (line 512) | def init_estimator(self):
    method __call__ (line 515) | def __call__(self, y, raw_predictions, sample_weight=None):
    method negative_gradient (line 546) | def negative_gradient(self, y, raw_predictions, **kargs):
    method _update_terminal_region (line 563) | def _update_terminal_region(
  class ClassificationLossFunction (line 584) | class ClassificationLossFunction(LossFunction, metaclass=ABCMeta):
    method _raw_prediction_to_proba (line 587) | def _raw_prediction_to_proba(self, raw_predictions):
    method _raw_prediction_to_decision (line 603) | def _raw_prediction_to_decision(self, raw_predictions):
    method check_init_estimator (line 618) | def check_init_estimator(self, estimator):
  class BinomialDeviance (line 633) | class BinomialDeviance(ClassificationLossFunction):
    method __init__ (line 645) | def __init__(self, n_classes):
    method init_estimator (line 655) | def init_estimator(self):
    method __call__ (line 660) | def __call__(self, y, raw_predictions, sample_weight=None):
    method negative_gradient (line 691) | def negative_gradient(self, y, raw_predictions, **kargs):
    method _update_terminal_region (line 705) | def _update_terminal_region(
    method _raw_prediction_to_proba (line 738) | def _raw_prediction_to_proba(self, raw_predictions):
    method _raw_prediction_to_decision (line 744) | def _raw_prediction_to_decision(self, raw_predictions):
    method get_init_raw_predictions (line 748) | def get_init_raw_predictions(self, X, estimator):
  class MultinomialDeviance (line 758) | class MultinomialDeviance(ClassificationLossFunction):
    method __init__ (line 772) | def __init__(self, n_classes):
    method init_estimator (line 779) | def init_estimator(self):
    method __call__ (line 782) | def __call__(self, y, raw_predictions, sample_weight=None):
    method negative_gradient (line 807) | def negative_gradient(self, y, raw_predictions, k=0, **kwargs):
    method _update_terminal_region (line 826) | def _update_terminal_region(
    method _raw_prediction_to_proba (line 854) | def _raw_prediction_to_proba(self, raw_predictions):
    method _raw_prediction_to_decision (line 861) | def _raw_prediction_to_decision(self, raw_predictions):
    method get_init_raw_predictions (line 865) | def get_init_raw_predictions(self, X, estimator):
  class ExponentialLoss (line 873) | class ExponentialLoss(ClassificationLossFunction):
    method __init__ (line 888) | def __init__(self, n_classes):
    method init_estimator (line 898) | def init_estimator(self):
    method __call__ (line 901) | def __call__(self, y, raw_predictions, sample_weight=None):
    method negative_gradient (line 926) | def negative_gradient(self, y, raw_predictions, **kargs):
    method _update_terminal_region (line 941) | def _update_terminal_region(
    method _raw_prediction_to_proba (line 968) | def _raw_prediction_to_proba(self, raw_predictions):
    method _raw_prediction_to_decision (line 974) | def _raw_prediction_to_decision(self, raw_predictions):
    method get_init_raw_predictions (line 977) | def get_init_raw_predictions(self, X, estimator):

FILE: sklearn/ensemble/_hist_gradient_boosting/binning.py
  function _find_binning_thresholds (line 21) | def _find_binning_thresholds(col_data, max_bins):
  class _BinMapper (line 71) | class _BinMapper(TransformerMixin, BaseEstimator):
    method __init__ (line 153) | def __init__(
    method fit (line 169) | def fit(self, X, y=None):
    method transform (line 248) | def transform(self, X):
    method make_known_categories_bitsets (line 283) | def make_known_categories_bitsets(self):

FILE: sklearn/ensemble/_hist_gradient_boosting/gradient_boosting.py
  class BaseHistGradientBoosting (line 31) | class BaseHistGradientBoosting(BaseEstimator, ABC):
    method __init__ (line 35) | def __init__(
    method _validate_parameters (line 76) | def _validate_parameters(self):
    method _check_categories (line 121) | def _check_categories(self, X):
    method fit (line 206) | def fit(self, X, y, sample_weight=None):
    method _is_fitted (line 627) | def _is_fitted(self):
    method _clear_state (line 630) | def _clear_state(self):
    method _get_small_trainset (line 636) | def _get_small_trainset(self, X_binned_train, y_train, sample_weight_t...
    method _check_early_stopping_scorer (line 665) | def _check_early_stopping_scorer(
    method _check_early_stopping_loss (line 710) | def _check_early_stopping_loss(
    method _should_stop (line 736) | def _should_stop(self, scores):
    method _bin_data (line 754) | def _bin_data(self, X, is_training_data):
    method _print_iteration_stats (line 783) | def _print_iteration_stats(self, iteration_start_time):
    method _raw_predict (line 826) | def _raw_predict(self, X, n_threads=None):
    method _predict_iterations (line 869) | def _predict_iterations(self, X, predictors, raw_predictions, is_binne...
    method _staged_raw_predict (line 894) | def _staged_raw_predict(self, X):
    method _compute_partial_dependence_recursion (line 940) | def _compute_partial_dependence_recursion(self, grid, target_features):
    method _more_tags (line 982) | def _more_tags(self):
    method _get_loss (line 986) | def _get_loss(self, sample_weight, n_threads):
    method _encode_y (line 990) | def _encode_y(self, y=None):
    method n_iter_ (line 994) | def n_iter_(self):
  class HistGradientBoostingRegressor (line 1000) | class HistGradientBoostingRegressor(RegressorMixin, BaseHistGradientBoos...
    method __init__ (line 1205) | def __init__(
    method predict (line 1248) | def predict(self, X):
    method staged_predict (line 1266) | def staged_predict(self, X):
    method _encode_y (line 1287) | def _encode_y(self, y):
    method _get_loss (line 1299) | def _get_loss(self, sample_weight, n_threads):
  class HistGradientBoostingClassifier (line 1325) | class HistGradientBoostingClassifier(ClassifierMixin, BaseHistGradientBo...
    method __init__ (line 1513) | def __init__(
    method predict (line 1556) | def predict(self, X):
    method staged_predict (line 1573) | def staged_predict(self, X):
    method predict_proba (line 1595) | def predict_proba(self, X):
    method staged_predict_proba (line 1611) | def staged_predict_proba(self, X):
    method decision_function (line 1631) | def decision_function(self, X):
    method staged_decision_function (line 1652) | def staged_decision_function(self, X):
    method _encode_y (line 1676) | def _encode_y(self, y):
    method _get_loss (line 1691) | def _get_loss(self, sample_weight, n_threads):

FILE: sklearn/ensemble/_hist_gradient_boosting/grower.py
  class TreeNode (line 29) | class TreeNode:
    method __init__ (line 87) | def __init__(self, depth, sample_indices, sum_gradients, sum_hessians,...
    method set_children_bounds (line 97) | def set_children_bounds(self, lower, upper):
    method __lt__ (line 106) | def __lt__(self, other_node):
  class TreeGrower (line 123) | class TreeGrower:
    method __init__ (line 187) | def __init__(
    method _validate_parameters (line 309) | def _validate_parameters(
    method grow (line 357) | def grow(self):
    method _apply_shrinkage (line 364) | def _apply_shrinkage(self):
    method _intilialize_root (line 376) | def _intilialize_root(self, gradients, hessians, hessians_are_constant):
    method _compute_best_split_and_push (line 409) | def _compute_best_split_and_push(self, node):
    method split_next (line 433) | def split_next(self):
    method _finalize_leaf (line 583) | def _finalize_leaf(self, node):
    method _finalize_splittable_nodes (line 589) | def _finalize_splittable_nodes(self):
    method make_predictor (line 598) | def make_predictor(self, binning_thresholds):
  function _fill_predictor_arrays (line 634) | def _fill_predictor_arrays(

FILE: sklearn/ensemble/_hist_gradient_boosting/loss.py
  class BaseLoss (line 27) | class BaseLoss(ABC):
    method __init__ (line 30) | def __init__(self, hessians_are_constant, n_threads=None):
    method __call__ (line 34) | def __call__(self, y_true, raw_predictions, sample_weight):
    method pointwise_loss (line 41) | def pointwise_loss(self, y_true, raw_predictions):
    method init_gradients_and_hessians (line 54) | def init_gradients_and_hessians(self, n_samples, prediction_dim, sampl...
    method get_baseline_prediction (line 98) | def get_baseline_prediction(self, y_train, sample_weight, prediction_d...
    method update_gradients_and_hessians (line 120) | def update_gradients_and_hessians(
  class LeastSquares (line 150) | class LeastSquares(BaseLoss):
    method __init__ (line 162) | def __init__(self, sample_weight, n_threads=None):
    method pointwise_loss (line 170) | def pointwise_loss(self, y_true, raw_predictions):
    method get_baseline_prediction (line 177) | def get_baseline_prediction(self, y_train, sample_weight, prediction_d...
    method inverse_link_function (line 181) | def inverse_link_function(raw_predictions):
    method update_gradients_and_hessians (line 184) | def update_gradients_and_hessians(
  class LeastAbsoluteDeviation (line 207) | class LeastAbsoluteDeviation(BaseLoss):
    method __init__ (line 215) | def __init__(self, sample_weight, n_threads=None):
    method pointwise_loss (line 233) | def pointwise_loss(self, y_true, raw_predictions):
    method get_baseline_prediction (line 240) | def get_baseline_prediction(self, y_train, sample_weight, prediction_d...
    method inverse_link_function (line 247) | def inverse_link_function(raw_predictions):
    method update_gradients_and_hessians (line 250) | def update_gradients_and_hessians(
    method update_leaves_values (line 275) | def update_leaves_values(self, grower, y_true, raw_predictions, sample...
  class Poisson (line 297) | class Poisson(BaseLoss):
    method __init__ (line 309) | def __init__(self, sample_weight, n_threads=None):
    method pointwise_loss (line 314) | def pointwise_loss(self, y_true, raw_predictions):
    method get_baseline_prediction (line 327) | def get_baseline_prediction(self, y_train, sample_weight, prediction_d...
    method update_gradients_and_hessians (line 333) | def update_gradients_and_hessians(
  class BinaryCrossEntropy (line 351) | class BinaryCrossEntropy(BaseLoss):
    method __init__ (line 363) | def __init__(self, sample_weight, n_threads=None):
    method pointwise_loss (line 368) | def pointwise_loss(self, y_true, raw_predictions):
    method get_baseline_prediction (line 376) | def get_baseline_prediction(self, y_train, sample_weight, prediction_d...
    method update_gradients_and_hessians (line 390) | def update_gradients_and_hessians(
    method predict_proba (line 402) | def predict_proba(self, raw_predictions):
  class CategoricalCrossEntropy (line 412) | class CategoricalCrossEntropy(BaseLoss):
    method __init__ (line 420) | def __init__(self, sample_weight, n_threads=None):
    method pointwise_loss (line 423) | def pointwise_loss(self, y_true, raw_predictions):
    method get_baseline_prediction (line 434) | def get_baseline_prediction(self, y_train, sample_weight, prediction_d...
    method update_gradients_and_hessians (line 444) | def update_gradients_and_hessians(
    method predict_proba (line 451) | def predict_proba(self, raw_predictions):

FILE: sklearn/ensemble/_hist_gradient_boosting/predictor.py
  class TreePredictor (line 14) | class TreePredictor:
    method __init__ (line 32) | def __init__(self, nodes, binned_left_cat_bitsets, raw_left_cat_bitsets):
    method get_n_leaf_nodes (line 37) | def get_n_leaf_nodes(self):
    method get_max_depth (line 41) | def get_max_depth(self):
    method predict (line 45) | def predict(self, X, known_cat_bitsets, f_idx_map, n_threads):
    method predict_binned (line 80) | def predict_binned(self, X, missing_values_bin_idx, n_threads):
    method compute_partial_dependence (line 110) | def compute_partial_dependence(self, grid, target_features, out):

FILE: sklearn/ensemble/_hist_gradient_boosting/tests/test_binning.py
  function test_find_binning_thresholds_regular_data (line 25) | def test_find_binning_thresholds_regular_data():
  function test_find_binning_thresholds_small_regular_data (line 34) | def test_find_binning_thresholds_small_regular_data():
  function test_find_binning_thresholds_random_data (line 50) | def test_find_binning_thresholds_random_data():
  function test_find_binning_thresholds_low_n_bins (line 67) | def test_find_binning_thresholds_low_n_bins():
  function test_invalid_n_bins (line 77) | def test_invalid_n_bins(n_bins):
  function test_bin_mapper_n_features_transform (line 85) | def test_bin_mapper_n_features_transform():
  function test_map_to_bins (line 93) | def test_map_to_bins(max_bins):
  function test_bin_mapper_random_data (line 114) | def test_bin_mapper_random_data(max_bins):
  function test_bin_mapper_small_random_data (line 143) | def test_bin_mapper_small_random_data(n_samples, max_bins):
  function test_bin_mapper_identity_repeated_values (line 165) | def test_bin_mapper_identity_repeated_values(max_bins, n_distinct, multi...
  function test_bin_mapper_repeated_values_invariance (line 174) | def test_bin_mapper_repeated_values_invariance(n_distinct):
  function test_bin_mapper_identity_small (line 206) | def test_bin_mapper_identity_small(max_bins, scale, offset):
  function test_bin_mapper_idempotence (line 226) | def test_bin_mapper_idempotence(max_bins_small, max_bins_large):
  function test_n_bins_non_missing (line 238) | def test_n_bins_non_missing(n_bins, diff):
  function test_subsample (line 249) | def test_subsample():
  function test_missing_values_support (line 291) | def test_missing_values_support(n_bins, n_bins_non_missing, X_trans_expe...
  function test_infinite_values (line 323) | def test_infinite_values():
  function test_categorical_feature (line 338) | def test_categorical_feature(n_bins):
  function test_categorical_with_numerical_features (line 368) | def test_categorical_with_numerical_features(n_bins):
  function test_make_known_categories_bitsets (line 403) | def test_make_known_categories_bitsets():
  function test_categorical_parameters (line 452) | def test_categorical_parameters(is_categorical, known_categories, match):

FILE: sklearn/ensemble/_hist_gradient_boosting/tests/test_bitset.py
  function test_set_get_bitset (line 23) | def test_set_get_bitset(values_to_insert, expected_bitset):
  function test_raw_bitset_from_binned_bitset (line 47) | def test_raw_bitset_from_binned_bitset(

FILE: sklearn/ensemble/_hist_gradient_boosting/tests/test_compare_lightgbm.py
  function test_same_predictions_regression (line 22) | def test_same_predictions_regression(seed, min_samples_leaf, n_samples, ...
  function test_same_predictions_classification (line 99) | def test_same_predictions_classification(
  function test_same_predictions_multiclass_classification (line 171) | def test_same_predictions_multiclass_classification(

FILE: sklearn/ensemble/_hist_gradient_boosting/tests/test_gradient_boosting.py
  function _make_dumb_dataset (line 36) | def _make_dumb_dataset(n_samples):
  function test_init_parameters_validation (line 71) | def test_init_parameters_validation(GradientBoosting, X, y, params, err_...
  function test_invalid_classification_loss (line 77) | def test_invalid_classification_loss():
  function test_early_stopping_regression (line 100) | def test_early_stopping_regression(
  function test_early_stopping_classification (line 148) | def test_early_stopping_classification(
  function test_early_stopping_default (line 184) | def test_early_stopping_default(GradientBoosting, X, y):
  function test_should_stop (line 210) | def test_should_stop(scores, n_iter_no_change, tol, stopping):
  function test_absolute_error (line 216) | def test_absolute_error():
  function test_absolute_error_sample_weight (line 224) | def test_absolute_error_sample_weight():
  function test_poisson_y_positive (line 239) | def test_poisson_y_positive(y):
  function test_poisson (line 247) | def test_poisson():
  function test_binning_train_validation_are_separated (line 277) | def test_binning_train_validation_are_separated():
  function test_missing_values_trivial (line 305) | def test_missing_values_trivial():
  function test_missing_values_resilience (line 330) | def test_missing_values_resilience(
  function test_zero_division_hessians (line 379) | def test_zero_division_hessians(data):
  function test_small_trainset (line 392) | def test_small_trainset():
  function test_missing_values_minmax_imputation (line 423) | def test_missing_values_minmax_imputation():
  function test_infinite_values (line 525) | def test_infinite_values():
  function test_consistent_lengths (line 536) | def test_consistent_lengths():
  function test_infinite_values_missing_values (line 550) | def test_infinite_values_missing_values():
  function test_crossentropy_binary_problem (line 568) | def test_crossentropy_binary_problem():
  function test_string_target_early_stopping (line 581) | def test_string_target_early_stopping(scoring):
  function test_zero_sample_weights_regression (line 591) | def test_zero_sample_weights_regression():
  function test_zero_sample_weights_classification (line 604) | def test_zero_sample_weights_classification():
  function test_sample_weight_effect (line 631) | def test_sample_weight_effect(problem, duplication):
  function test_sum_hessians_are_sample_weight (line 685) | def test_sum_hessians_are_sample_weight(loss_name):
  function test_max_depth_max_leaf_nodes (line 731) | def test_max_depth_max_leaf_nodes():
  function test_early_stopping_on_test_set_with_warm_start (line 746) | def test_early_stopping_on_test_set_with_warm_start():
  function test_single_node_trees (line 768) | def test_single_node_trees(Est):
  function test_custom_loss (line 804) | def test_custom_loss(Est, loss, X, y):
  function test_staged_predict (line 821) | def test_staged_predict(HistGradientBoosting, X, y):
  function test_unknown_categories_nan (line 864) | def test_unknown_categories_nan(insert_missing, Est, bool_categorical_pa...
  function test_categorical_encoding_strategies (line 897) | def test_categorical_encoding_strategies():
  function test_categorical_spec_errors (line 988) | def test_categorical_spec_errors(
  function test_categorical_spec_no_categories (line 1008) | def test_categorical_spec_no_categories(Est, categorical_features, as_ar...
  function test_categorical_bad_encoding_errors (line 1022) | def test_categorical_bad_encoding_errors(Est):
  function test_uint8_predict (line 1048) | def test_uint8_predict(Est):
  function test_loss_deprecated (line 1071) | def test_loss_deprecated(old_loss, new_loss):

FILE: sklearn/ensemble/_hist_gradient_boosting/tests/test_grower.py
  function _make_training_data (line 20) | def _make_training_data(n_bins=256, constant_hessian=True):
  function _check_children_consistency (line 52) | def _check_children_consistency(parent, left, right):
  function test_grow_tree (line 84) | def test_grow_tree(n_bins, constant_hessian, stopping_param, shrinkage):
  function test_predictor_from_grower (line 159) | def test_predictor_from_grower():
  function test_min_samples_leaf (line 224) | def test_min_samples_leaf(n_samples, min_samples_leaf, n_bins, constant_...
  function test_min_samples_leaf_root (line 261) | def test_min_samples_leaf_root(n_samples, min_samples_leaf):
  function assert_is_stump (line 292) | def assert_is_stump(grower):
  function test_max_depth (line 300) | def test_max_depth(max_depth):
  function test_input_validation (line 325) | def test_input_validation():
  function test_init_parameters_validation (line 340) | def test_init_parameters_validation():
  function test_missing_value_predict_only (line 350) | def test_missing_value_predict_only():
  function test_split_on_nan_with_infinite_values (line 393) | def test_split_on_nan_with_infinite_values():
  function test_grow_tree_categories (line 443) | def test_grow_tree_categories():
  function test_ohe_equivalence (line 516) | def test_ohe_equivalence(min_samples_leaf, n_unique_categories, target):

FILE: sklearn/ensemble/_hist_gradient_boosting/tests/test_histogram.py
  function test_build_histogram (line 21) | def test_build_histogram(build_func):
  function test_histogram_sample_order_independence (line 53) | def test_histogram_sample_order_independence():
  function test_unrolled_equivalent_to_naive (line 111) | def test_unrolled_equivalent_to_naive(constant_hessian):
  function test_hist_subtraction (line 165) | def test_hist_subtraction(constant_hessian):

FILE: sklearn/ensemble/_hist_gradient_boosting/tests/test_loss.py
  function get_derivatives_helper (line 19) | def get_derivatives_helper(loss):
  function test_derivatives (line 75) | def test_derivatives(loss, x0, y_true):
  function test_numerical_gradients (line 125) | def test_numerical_gradients(loss, n_classes, prediction_dim, seed=0):
  function test_baseline_least_squares (line 171) | def test_baseline_least_squares():
  function test_baseline_absolute_error (line 186) | def test_baseline_absolute_error():
  function test_baseline_poisson (line 201) | def test_baseline_poisson():
  function test_baseline_binary_crossentropy (line 222) | def test_baseline_binary_crossentropy():
  function test_baseline_categorical_crossentropy (line 245) | def test_baseline_categorical_crossentropy():
  function test_sample_weight_multiplies_gradients (line 279) | def test_sample_weight_multiplies_gradients(loss, problem, sample_weight):
  function test_init_gradient_and_hessians_sample_weight (line 327) | def test_init_gradient_and_hessians_sample_weight():

FILE: sklearn/ensemble/_hist_gradient_boosting/tests/test_monotonic_contraints.py
  function is_increasing (line 20) | def is_increasing(a):
  function is_decreasing (line 24) | def is_decreasing(a):
  function assert_leaves_values_monotonic (line 28) | def assert_leaves_values_monotonic(predictor, monotonic_cst):
  function assert_children_values_monotonic (line 61) | def assert_children_values_monotonic(predictor, monotonic_cst):
  function assert_children_values_bounded (line 93) | def assert_children_values_bounded(grower, monotonic_cst):
  function test_nodes_values (line 144) | def test_nodes_values(monotonic_cst, seed):
  function test_predictions (line 201) | def test_predictions(seed):
  function test_input_error (line 255) | def test_input_error():
  function test_bounded_value_min_gain_to_split (line 280) | def test_bounded_value_min_gain_to_split():

FILE: sklearn/ensemble/_hist_gradient_boosting/tests/test_predictor.py
  function test_regression_dataset (line 29) | def test_regression_dataset(n_bins):
  function test_infinite_values_and_thresholds (line 77) | def test_infinite_values_and_thresholds(num_threshold, expected_predicti...
  function test_categorical_predictor (line 120) | def test_categorical_predictor(bins_go_left, expected_predictions):

FILE: sklearn/ensemble/_hist_gradient_boosting/tests/test_splitting.py
  function test_histogram_split (line 21) | def test_histogram_split(n_bins):
  function test_gradient_and_hessian_sanity (line 97) | def test_gradient_and_hessian_sanity(constant_hessian):
  function test_split_indices (line 240) | def test_split_indices():
  function test_min_gain_to_split (line 326) | def test_min_gain_to_split():
  function test_splitting_missing_values (line 483) | def test_splitting_missing_values(
  function test_splitting_categorical_cat_smooth (line 598) | def test_splitting_categorical_cat_smooth(
  function _assert_categories_equals_bitset (line 659) | def _assert_categories_equals_bitset(categories, bitset):
  function test_splitting_categorical_sanity (line 778) | def test_splitting_categorical_sanity(

FILE: sklearn/ensemble/_hist_gradient_boosting/tests/test_warm_start.py
  function _assert_predictor_equal (line 19) | def _assert_predictor_equal(gb_1, gb_2, X):
  function test_max_iter_with_warm_start_validation (line 37) | def test_max_iter_with_warm_start_validation(GradientBoosting, X, y):
  function test_warm_start_yields_identical_results (line 59) | def test_warm_start_yields_identical_results(GradientBoosting, X, y):
  function test_warm_start_max_depth (line 85) | def test_warm_start_max_depth(GradientBoosting, X, y):
  function test_warm_start_early_stopping (line 114) | def test_warm_start_early_stopping(GradientBoosting, X, y, scoring):
  function test_warm_start_equal_n_estimators (line 142) | def test_warm_start_equal_n_estimators(GradientBoosting, X, y):
  function test_warm_start_clear (line 162) | def test_warm_start_clear(GradientBoosting, X, y):
  function test_random_seeds_warm_start (line 189) | def test_random_seeds_warm_start(GradientBoosting, X, y, rng_type):

FILE: sklearn/ensemble/_iforest.py
  class IsolationForest (line 26) | class IsolationForest(OutlierMixin, BaseBagging):
    method __init__ (line 195) | def __init__(
    method _set_oob_score (line 226) | def _set_oob_score(self, X, y):
    method _parallel_args (line 229) | def _parallel_args(self):
    method fit (line 236) | def fit(self, X, y=None, sample_weight=None):
    method predict (line 322) | def predict(self, X):
    method decision_function (line 345) | def decision_function(self, X):
    method score_samples (line 377) | def score_samples(self, X):
    method _compute_chunked_score_samples (line 412) | def _compute_chunked_score_samples(self, X):
    method _compute_score_samples (line 445) | def _compute_score_samples(self, X, subsample_features):
    method _more_tags (line 483) | def _more_tags(self):
  function _average_path_length (line 493) | def _average_path_length(n_samples_leaf):

FILE: sklearn/ensemble/_stacking.py
  class _BaseStacking (line 38) | class _BaseStacking(TransformerMixin, _BaseHeterogeneousEnsemble, metacl...
    method __init__ (line 42) | def __init__(
    method _clone_final_estimator (line 61) | def _clone_final_estimator(self, default):
    method _concatenate_predictions (line 67) | def _concatenate_predictions(self, X, predictions):
    method _method_name (line 104) | def _method_name(name, estimator, method):
    method fit (line 123) | def fit(self, X, y, sample_weight=None):
    method n_features_in_ (line 224) | def n_features_in_(self):
    method _transform (line 234) | def _transform(self, X):
    method predict (line 245) | def predict(self, X, **predict_params):
    method _sk_visual_block_ (line 269) | def _sk_visual_block_(self, final_estimator):
  class StackingClassifier (line 281) | class StackingClassifier(ClassifierMixin, _BaseStacking):
    method __init__ (line 433) | def __init__(
    method _validate_final_estimator (line 454) | def _validate_final_estimator(self):
    method fit (line 463) | def fit(self, X, y, sample_weight=None):
    method predict (line 491) | def predict(self, X, **predict_params):
    method predict_proba (line 515) | def predict_proba(self, X):
    method decision_function (line 534) | def decision_function(self, X):
    method transform (line 552) | def transform(self, X):
    method _sk_visual_block_ (line 569) | def _sk_visual_block_(self):
  class StackingRegressor (line 579) | class StackingRegressor(RegressorMixin, _BaseStacking):
    method __init__ (line 707) | def __init__(
    method _validate_final_estimator (line 727) | def _validate_final_estimator(self):
    method fit (line 736) | def fit(self, X, y, sample_weight=None):
    method transform (line 761) | def transform(self, X):
    method _sk_visual_block_ (line 777) | def _sk_visual_block_(self):

FILE: sklearn/ensemble/_voting.py
  class _BaseVoting (line 39) | class _BaseVoting(TransformerMixin, _BaseHeterogeneousEnsemble):
    method _log_message (line 46) | def _log_message(self, name, idx, total):
    method _weights_not_none (line 52) | def _weights_not_none(self):
    method _predict (line 58) | def _predict(self, X):
    method fit (line 63) | def fit(self, X, y, sample_weight=None):
    method fit_transform (line 100) | def fit_transform(self, X, y=None, **fit_params):
    method n_features_in_ (line 125) | def n_features_in_(self):
    method _sk_visual_block_ (line 140) | def _sk_visual_block_(self):
    method _more_tags (line 144) | def _more_tags(self):
  class VotingClassifier (line 148) | class VotingClassifier(ClassifierMixin, _BaseVoting):
    method __init__ (line 268) | def __init__(
    method fit (line 285) | def fit(self, X, y, sample_weight=None):
    method predict (line 326) | def predict(self, X):
    method _collect_probas (line 355) | def _collect_probas(self, X):
    method _check_voting (line 359) | def _check_voting(self):
    method predict_proba (line 367) | def predict_proba(self, X):
    method transform (line 386) | def transform(self, X):
  class VotingRegressor (line 420) | class VotingRegressor(RegressorMixin, _BaseVoting):
    method __init__ (line 500) | def __init__(self, estimators, *, weights=None, n_jobs=None, verbose=F...
    method fit (line 506) | def fit(self, X, y, sample_weight=None):
    method predict (line 531) | def predict(self, X):
    method transform (line 550) | def transform(self, X):

FILE: sklearn/ensemble/_weight_boosting.py
  class BaseWeightBoosting (line 55) | class BaseWeightBoosting(BaseEnsemble, metaclass=ABCMeta):
    method __init__ (line 63) | def __init__(
    method _check_X (line 82) | def _check_X(self, X):
    method fit (line 93) | def fit(self, X, y, sample_weight=None):
    method _boost (line 183) | def _boost(self, iboost, X, y, sample_weight, random_state):
    method staged_score (line 222) | def staged_score(self, X, y, sample_weight=None):
    method feature_importances_ (line 254) | def feature_importances_(self):
  function _samme_proba (line 294) | def _samme_proba(estimator, n_classes, X):
  class AdaBoostClassifier (line 315) | class AdaBoostClassifier(ClassifierMixin, BaseWeightBoosting):
    method __init__ (line 443) | def __init__(
    method fit (line 462) | def fit(self, X, y, sample_weight=None):
    method _validate_estimator (line 509) | def _validate_estimator(self):
    method _boost (line 529) | def _boost(self, iboost, X, y, sample_weight, random_state):
    method _boost_real (line 574) | def _boost_real(self, iboost, X, y, sample_weight, random_state):
    method _boost_discrete (line 633) | def _boost_discrete(self, iboost, X, y, sample_weight, random_state):
    method predict (line 683) | def predict(self, X):
    method staged_predict (line 707) | def staged_predict(self, X):
    method decision_function (line 741) | def decision_function(self, X):
    method staged_decision_function (line 783) | def staged_decision_function(self, X):
    method _compute_proba_from_decision (line 836) | def _compute_proba_from_decision(decision, n_classes):
    method predict_proba (line 854) | def predict_proba(self, X):
    method staged_predict_proba (line 882) | def staged_predict_proba(self, X):
    method predict_log_proba (line 912) | def predict_log_proba(self, X):
  class AdaBoostRegressor (line 934) | class AdaBoostRegressor(RegressorMixin, BaseWeightBoosting):
    method __init__ (line 1040) | def __init__(
    method fit (line 1060) | def fit(self, X, y, sample_weight=None):
    method _validate_estimator (line 1088) | def _validate_estimator(self):
    method _boost (line 1092) | def _boost(self, iboost, X, y, sample_weight, random_state):
    method _get_median_predict (line 1190) | def _get_median_predict(self, X, limit):
    method predict (line 1207) | def predict(self, X):
    method staged_predict (line 1229) | def staged_predict(self, X):

FILE: sklearn/ensemble/setup.py
  function configuration (line 5) | def configuration(parent_package="", top_path=None):

FILE: sklearn/ensemble/tests/test_bagging.py
  function test_classification (line 52) | def test_classification():
  function test_sparse_classification (line 108) | def test_sparse_classification(sparse_format, params, method):
  function test_regression (line 149) | def test_regression():
  function test_sparse_regression (line 177) | def test_sparse_regression():
  class DummySizeEstimator (line 235) | class DummySizeEstimator(BaseEstimator):
    method fit (line 236) | def fit(self, X, y):
  function test_bootstrap_samples (line 241) | def test_bootstrap_samples():
  function test_bootstrap_features (line 283) | def test_bootstrap_features():
  function test_probability (line 311) | def test_probability():
  function test_oob_score_classification (line 346) | def test_oob_score_classification():
  function test_oob_score_regression (line 383) | def test_oob_score_regression():
  function test_single_estimator (line 419) | def test_single_estimator():
  function test_error (line 439) | def test_error():
  function test_parallel_classification (line 472) | def test_parallel_classification():
  function test_parallel_regression (line 518) | def test_parallel_regression():
  function test_gridsearch (line 544) | def test_gridsearch():
  function test_base_estimator (line 556) | def test_base_estimator():
  function test_bagging_with_pipeline (line 600) | def test_bagging_with_pipeline():
  class DummyZeroEstimator (line 608) | class DummyZeroEstimator(BaseEstimator):
    method fit (line 609) | def fit(self, X, y):
    method predict (line 613) | def predict(self, X):
  function test_bagging_sample_weight_unsupported_but_passed (line 617) | def test_bagging_sample_weight_unsupported_but_passed():
  function test_warm_start (line 630) | def test_warm_start(random_state=42):
  function test_warm_start_smaller_n_estimators (line 656) | def test_warm_start_smaller_n_estimators():
  function test_warm_start_equal_n_estimators (line 666) | def test_warm_start_equal_n_estimators():
  function test_warm_start_equivalence (line 684) | def test_warm_start_equivalence():
  function test_warm_start_with_oob_score_fails (line 703) | def test_warm_start_with_oob_score_fails():
  function test_oob_score_removed_on_warm_start (line 711) | def test_oob_score_removed_on_warm_start():
  function test_oob_score_consistency (line 724) | def test_oob_score_consistency():
  function test_estimators_samples (line 738) | def test_estimators_samples():
  function test_estimators_samples_deterministic (line 778) | def test_estimators_samples_deterministic():
  function test_max_samples_consistency (line 807) | def test_max_samples_consistency():
  function test_set_oob_score_label_encoding (line 822) | def test_set_oob_score_label_encoding():
  function replace (line 848) | def replace(X):
  function test_bagging_regressor_with_missing_inputs (line 854) | def test_bagging_regressor_with_missing_inputs():
  function test_bagging_classifier_with_missing_inputs (line 895) | def test_bagging_classifier_with_missing_inputs():
  function test_bagging_small_max_features (line 927) | def test_bagging_small_max_features():
  function test_bagging_get_estimators_indices (line 937) | def test_bagging_get_estimators_indices():
  function test_n_features_deprecation (line 960) | def test_n_features_deprecation(Estimator):

FILE: sklearn/ensemble/tests/test_base.py
  function test_base (line 21) | def test_base():
  function test_base_zero_n_estimators (line 52) | def test_base_zero_n_estimators():
  function test_base_not_int_n_estimators (line 62) | def test_base_not_int_n_estimators():
  function test_set_random_states (line 74) | def test_set_random_states():

FILE: sklearn/ensemble/tests/test_common.py
  function test_ensemble_heterogeneous_estimators_behavior (line 76) | def test_ensemble_heterogeneous_estimators_behavior(X, y, estimator):
  function test_ensemble_heterogeneous_estimators_type (line 139) | def test_ensemble_heterogeneous_estimators_type(Ensemble):
  function test_ensemble_heterogeneous_estimators_name_validation (line 166) | def test_ensemble_heterogeneous_estimators_name_validation(X, y, Ensemble):
  function test_ensemble_heterogeneous_estimators_all_dropped (line 228) | def test_ensemble_heterogeneous_estimators_all_dropped(X, y, estimator):
  function test_heterogeneous_ensemble_support_missing_values (line 247) | def test_heterogeneous_ensemble_support_missing_values(Ensemble, Estimat...

FILE: sklearn/ensemble/tests/test_forest.py
  function check_classification_toy (line 119) | def check_classification_toy(name):
  function test_classification_toy (line 139) | def test_classification_toy(name):
  function check_iris_criterion (line 143) | def check_iris_criterion(name, criterion):
  function test_iris (line 162) | def test_iris(name, criterion):
  function check_regression_criterion (line 166) | def check_regression_criterion(name, criterion):
  function test_regression (line 195) | def test_regression(name, criterion):
  function test_poisson_vs_mse (line 199) | def test_poisson_vs_mse():
  function test_balance_property_random_forest (line 251) | def test_balance_property_random_forest(criterion):
  function check_regressor_attributes (line 270) | def check_regressor_attributes(name):
  function test_regressor_attributes (line 282) | def test_regressor_attributes(name):
  function check_probability (line 286) | def check_probability(name):
  function test_probability (line 303) | def test_probability(name):
  function check_importances (line 307) | def check_importances(name, criterion, dtype, tolerance):
  function test_importances (line 353) | def test_importances(dtype, name, criterion):
  function test_importances_asymptotic (line 360) | def test_importances_asymptotic():
  function test_unfitted_feature_importances (line 470) | def test_unfitted_feature_importances(name):
  function test_forest_classifier_oob (line 505) | def test_forest_classifier_oob(ForestClassifier, X, y, X_type, lower_bou...
  function test_forest_regressor_oob (line 560) | def test_forest_regressor_oob(ForestRegressor, X, y, X_type, lower_bound...
  function test_forest_oob_warning (line 598) | def test_forest_oob_warning(ForestEstimator):
  function test_forest_oob_error (line 629) | def test_forest_oob_error(ForestEstimator, X, y, params, err_msg):
  function test_random_trees_embedding_raise_error_oob (line 636) | def test_random_trees_embedding_raise_error_oob(oob_score):
  function check_gridsearch (line 643) | def check_gridsearch(name):
  function test_gridsearch (line 650) | def test_gridsearch(name):
  function check_parallel (line 655) | def check_parallel(name, X, y):
  function test_parallel (line 671) | def test_parallel(name):
  function check_pickle (line 682) | def check_pickle(name, X, y):
  function test_pickle (line 698) | def test_pickle(name):
  function check_multioutput (line 709) | def check_multioutput(name):
  function test_multioutput (line 761) | def test_multioutput(name):
  function test_multioutput_string (line 766) | def test_multioutput_string(name):
  function check_classes_shape (line 821) | def check_classes_shape(name):
  function test_classes_shape (line 840) | def test_classes_shape(name):
  function test_random_trees_dense_type (line 844) | def test_random_trees_dense_type():
  function test_random_trees_dense_equal (line 857) | def test_random_trees_dense_equal():
  function test_random_hasher (line 878) | def test_random_hasher():
  function test_random_hasher_sparse_data (line 901) | def test_random_hasher_sparse_data():
  function test_parallel_train (line 909) | def test_parallel_train():
  function test_distribution (line 928) | def test_distribution():
  function check_max_leaf_nodes_max_depth (line 982) | def check_max_leaf_nodes_max_depth(name):
  function test_max_leaf_nodes_max_depth (line 997) | def test_max_leaf_nodes_max_depth(name):
  function check_min_samples_split (line 1001) | def check_min_samples_split(name):
  function test_min_samples_split (line 1029) | def test_min_samples_split(name):
  function check_min_samples_leaf (line 1033) | def check_min_samples_leaf(name):
  function test_min_samples_leaf (line 1063) | def test_min_samples_leaf(name):
  function check_min_weight_fraction_leaf (line 1067) | def check_min_weight_fraction_leaf(name):
  function test_min_weight_fraction_leaf (line 1099) | def test_min_weight_fraction_leaf(name):
  function check_sparse_input (line 1103) | def check_sparse_input(name, X, X_sparse, y):
  function test_sparse_input (line 1134) | def test_sparse_input(name, sparse_matrix):
  function check_memory_layout (line 1140) | def check_memory_layout(name, dtype):
  function test_memory_layout (line 1189) | def test_memory_layout(name, dtype):
  function check_1d_input (line 1194) | def check_1d_input(name, X, X_2d, y):
  function test_1d_input (line 1208) | def test_1d_input(name):
  function check_class_weights (line 1217) | def check_class_weights(name):
  function test_class_weights (line 1265) | def test_class_weights(name):
  function check_class_weight_balanced_and_bootstrap_multi_output (line 1269) | def check_class_weight_balanced_and_bootstrap_multi_output(name):
  function test_class_weight_balanced_and_bootstrap_multi_output (line 1285) | def test_class_weight_balanced_and_bootstrap_multi_output(name):
  function check_class_weight_errors (line 1289) | def check_class_weight_errors(name):
  function test_class_weight_errors (line 1323) | def test_class_weight_errors(name):
  function check_warm_start (line 1327) | def check_warm_start(name, random_state=42):
  function test_warm_start (line 1358) | def test_warm_start(name):
  function check_warm_start_clear (line 1362) | def check_warm_start_clear(name):
  function test_warm_start_clear (line 1380) | def test_warm_start_clear(name):
  function check_warm_start_smaller_n_estimators (line 1384) | def check_warm_start_smaller_n_estimators(name):
  function test_warm_start_smaller_n_estimators (line 1396) | def test_warm_start_smaller_n_estimators(name):
  function check_warm_start_equal_n_estimators (line 1400) | def check_warm_start_equal_n_estimators(name):
  function test_warm_start_equal_n_estimators (line 1426) | def test_warm_start_equal_n_estimators(name):
  function check_warm_start_oob (line 1430) | def check_warm_start_oob(name):
  function test_warm_start_oob (line 1481) | def test_warm_start_oob(name):
  function test_dtype_convert (line 1485) | def test_dtype_convert(n_classes=15):
  function check_decision_path (line 1496) | def check_decision_path(name):
  function test_decision_path (line 1521) | def test_decision_path(name):
  function test_min_impurity_decrease (line 1525) | def test_min_impurity_decrease():
  function test_poisson_y_positive_check (line 1543) | def test_poisson_y_positive_check():
  class MyBackend (line 1565) | class MyBackend(DEFAULT_JOBLIB_BACKEND):  # type: ignore
    method __init__ (line 1566) | def __init__(self, *args, **kwargs):
    method start_call (line 1570) | def start_call(self):
  function test_backend_respected (line 1583) | def test_backend_respected():
  function test_forest_feature_importances_sum (line 1598) | def test_forest_feature_importances_sum():
  function test_forest_degenerate_feature_importances (line 1608) | def test_forest_degenerate_feature_importances():
  function test_max_samples_exceptions (line 1661) | def test_max_samples_exceptions(name, max_samples, exc_type, exc_msg):
  function test_max_samples_boundary_regressors (line 1669) | def test_max_samples_boundary_regressors(name):
  function test_max_samples_boundary_classifiers (line 1687) | def test_max_samples_boundary_classifiers(name):
  function test_forest_y_sparse (line 1701) | def test_forest_y_sparse():
  function test_little_tree_with_small_max_samples (line 1711) | def test_little_tree_with_small_max_samples(ForestClass):
  function test_n_features_deprecation (line 1752) | def test_n_features_deprecation(Estimator):
  function test_criterion_deprecated (line 1771) | def test_criterion_deprecated(old_criterion, new_criterion):
  function test_mse_criterion_object_segfault_smoke_test (line 1785) | def test_mse_criterion_object_segfault_smoke_test(Forest):

FILE: sklearn/ensemble/tests/test_gradient_boosting.py
  function test_classification_toy (line 63) | def test_classification_toy(loss):
  function test_gbdt_parameter_checks (line 119) | def test_gbdt_parameter_checks(GradientBoosting, X, y, params, err_msg):
  function test_gbdt_loss_alpha_error (line 132) | def test_gbdt_loss_alpha_error(params, err_msg):
  function test_wrong_type_loss_function (line 150) | def test_wrong_type_loss_function(GradientBoosting, loss):
  function test_classification_synthetic (line 158) | def test_classification_synthetic(loss):
  function test_regression_dataset (line 194) | def test_regression_dataset(loss, subsample):
  function test_iris (line 231) | def test_iris(subsample, sample_weight):
  function test_regression_synthetic (line 246) | def test_regression_synthetic():
  function test_feature_importances (line 296) | def test_feature_importances(GradientBoosting, X, y):
  function test_probability_log (line 305) | def test_probability_log():
  function test_single_class_with_sample_weight (line 325) | def test_single_class_with_sample_weight():
  function test_check_inputs_predict_stages (line 336) | def test_check_inputs_predict_stages():
  function test_max_feature_regression (line 352) | def test_max_feature_regression():
  function test_feature_importance_regression (line 372) | def test_feature_importance_regression(fetch_california_housing_fxt):
  function test_max_feature_auto (line 404) | def test_max_feature_auto():
  function test_staged_predict (line 437) | def test_staged_predict():
  function test_staged_predict_proba (line 458) | def test_staged_predict_proba():
  function test_staged_functions_defensive (line 486) | def test_staged_functions_defensive(Estimator):
  function test_serialization (line 504) | def test_serialization():
  function test_degenerate_targets (line 524) | def test_degenerate_targets():
  function test_quantile_loss (line 538) | def test_quantile_loss():
  function test_symbol_labels (line 556) | def test_symbol_labels():
  function test_float_class_labels (line 567) | def test_float_class_labels():
  function test_shape_y (line 578) | def test_shape_y():
  function test_mem_layout (line 599) | def test_mem_layout():
  function test_oob_improvement (line 628) | def test_oob_improvement():
  function test_oob_improvement_raise (line 639) | def test_oob_improvement_raise():
  function test_oob_multilcass_iris (line 647) | def test_oob_multilcass_iris():
  function test_verbose_output (line 663) | def test_verbose_output():
  function test_more_verbose_output (line 695) | def test_more_verbose_output():
  function test_warm_start (line 724) | def test_warm_start(Cls):
  function test_warm_start_n_estimators (line 745) | def test_warm_start_n_estimators(Cls):
  function test_warm_start_max_depth (line 760) | def test_warm_start_max_depth(Cls):
  function test_warm_start_clear (line 775) | def test_warm_start_clear(Cls):
  function test_warm_start_zero_n_estimators (line 790) | def test_warm_start_zero_n_estimators(Cls):
  function test_warm_start_smaller_n_estimators (line 801) | def test_warm_start_smaller_n_estimators(Cls):
  function test_warm_start_equal_n_estimators (line 812) | def test_warm_start_equal_n_estimators(Cls):
  function test_warm_start_oob_switch (line 826) | def test_warm_start_oob_switch(Cls):
  function test_warm_start_oob (line 840) | def test_warm_start_oob(Cls):
  function test_warm_start_sparse (line 857) | def test_warm_start_sparse(Cls):
  function test_warm_start_fortran (line 893) | def test_warm_start_fortran(Cls):
  function early_stopping_monitor (line 912) | def early_stopping_monitor(i, est, locals):
  function test_monitor_early_stopping (line 921) | def test_monitor_early_stopping(Cls):
  function test_complete_classification (line 957) | def test_complete_classification():
  function test_complete_regression (line 974) | def test_complete_regression():
  function test_zero_estimator_reg (line 989) | def test_zero_estimator_reg():
  function test_zero_estimator_clf (line 1007) | def test_zero_estimator_clf():
  function test_max_leaf_nodes_max_depth (line 1037) | def test_max_leaf_nodes_max_depth(GBEstimator):
  function test_min_impurity_decrease (line 1053) | def test_min_impurity_decrease(GBEstimator):
  function test_warm_start_wo_nestimators_change (line 1064) | def test_warm_start_wo_nestimators_change():
  function test_probability_exponential (line 1074) | def test_probability_exponential():
  function test_non_uniform_weights_toy_edge_case_reg (line 1098) | def test_non_uniform_weights_toy_edge_case_reg():
  function test_non_uniform_weights_toy_edge_case_clf (line 1109) | def test_non_uniform_weights_toy_edge_case_clf():
  function test_sparse_input (line 1125) | def test_sparse_input(EstimatorClass, sparse_matrix):
  function test_gradient_boosting_early_stopping (line 1165) | def test_gradient_boosting_early_stopping():
  function test_gradient_boosting_validation_fraction (line 1211) | def test_gradient_boosting_validation_fraction():
  function test_early_stopping_stratified (line 1254) | def test_early_stopping_stratified():
  function _make_multiclass (line 1266) | def _make_multiclass():
  function test_gradient_boosting_with_init (line 1279) | def test_gradient_boosting_with_init(gb, dataset_maker, init_estimator):
  function test_gradient_boosting_with_init_pipeline (line 1299) | def test_gradient_boosting_with_init_pipeline():
  function test_gradient_boosting_init_wrong_methods (line 1331) | def test_gradient_boosting_init_wrong_methods(estimator, missing_method):
  function test_early_stopping_n_classes (line 1343) | def test_early_stopping_n_classes():
  function test_gbr_degenerate_feature_importances (line 1365) | def test_gbr_degenerate_feature_importances():
  function test_gbr_deprecated_attr (line 1374) | def test_gbr_deprecated_attr():
  function test_attr_error_raised_if_not_fitted (line 1387) | def test_attr_error_raised_if_not_fitted():
  function test_criterion_mae_deprecation (line 1405) | def test_criterion_mae_deprecation(estimator):
  function test_n_features_deprecation (line 1420) | def test_n_features_deprecation(Estimator):
  function test_criterion_mse_deprecated (line 1433) | def test_criterion_mse_deprecated(Estimator):
  function test_loss_deprecated (line 1455) | def test_loss_deprecated(old_loss, new_loss):

FILE: sklearn/ensemble/tests/test_gradient_boosting_loss_functions.py
  function test_binomial_deviance (line 23) | def test_binomial_deviance():
  function test_sample_weight_smoke (line 62) | def test_sample_weight_smoke():
  function test_sample_weight_init_estimators (line 74) | def test_sample_weight_init_estimators():
  function test_quantile_loss_function (line 111) | def test_quantile_loss_function():
  function test_sample_weight_deviance (line 123) | def test_sample_weight_deviance():
  function test_multinomial_deviance (line 157) | def test_multinomial_deviance(n_classes, n_samples):
  function test_mdl_computation_weighted (line 179) | def test_mdl_computation_weighted():
  function test_mdl_exception (line 190) | def test_mdl_exception(n):
  function test_init_raw_predictions_shapes (line 197) | def test_init_raw_predictions_shapes():
  function test_init_raw_predictions_values (line 233) | def test_init_raw_predictions_values():
  function test_lad_equals_quantiles (line 299) | def test_lad_equals_quantiles(seed, alpha):

FILE: sklearn/ensemble/tests/test_iforest.py
  function test_iforest (line 46) | def test_iforest():
  function test_iforest_sparse (line 60) | def test_iforest_sparse():
  function test_iforest_error (line 88) | def test_iforest_error():
  function test_recalculate_max_depth (line 127) | def test_recalculate_max_depth():
  function test_max_samples_attribute (line 135) | def test_max_samples_attribute():
  function test_iforest_parallel_regression (line 150) | def test_iforest_parallel_regression():
  function test_iforest_performance (line 172) | def test_iforest_performance():
  function test_iforest_works (line 197) | def test_iforest_works(contamination):
  function test_max_samples_consistency (line 211) | def test_max_samples_consistency():
  function test_iforest_subsampled_features (line 218) | def test_iforest_subsampled_features():
  function test_iforest_average_path_length (line 229) | def test_iforest_average_path_length():
  function test_score_samples (line 249) | def test_score_samples():
  function test_iforest_warm_start (line 266) | def test_iforest_warm_start():
  function test_iforest_chunks_works1 (line 294) | def test_iforest_chunks_works1(mocked_get_chunk, contamination, n_predic...
  function test_iforest_chunks_works2 (line 305) | def test_iforest_chunks_works2(mocked_get_chunk, contamination, n_predic...
  function test_iforest_with_uniform_data (line 310) | def test_iforest_with_uniform_data():
  function test_n_features_deprecation (line 345) | def test_n_features_deprecation():

FILE: sklearn/ensemble/tests/test_stacking.py
  function test_stacking_classifier_iris (line 57) | def test_stacking_classifier_iris(cv, final_estimator, passthrough):
  function test_stacking_classifier_drop_column_binary_classification (line 96) | def test_stacking_classifier_drop_column_binary_classification():
  function test_stacking_classifier_drop_estimator (line 123) | def test_stacking_classifier_drop_estimator():
  function test_stacking_regressor_drop_estimator (line 143) | def test_stacking_regressor_drop_estimator():
  function test_stacking_regressor_diabetes (line 172) | def test_stacking_regressor_diabetes(cv, final_estimator, predict_params...
  function test_stacking_regressor_sparse_passthrough (line 209) | def test_stacking_regressor_sparse_passthrough(fmt):
  function test_stacking_classifier_sparse_passthrough (line 227) | def test_stacking_classifier_sparse_passthrough(fmt):
  function test_stacking_classifier_drop_binary_prob (line 244) | def test_stacking_classifier_drop_binary_prob():
  class NoWeightRegressor (line 258) | class NoWeightRegressor(RegressorMixin, BaseEstimator):
    method fit (line 259) | def fit(self, X, y):
    method predict (line 263) | def predict(self, X):
  class NoWeightClassifier (line 267) | class NoWeightClassifier(ClassifierMixin, BaseEstimator):
    method fit (line 268) | def fit(self, X, y):
  function test_stacking_classifier_error (line 315) | def test_stacking_classifier_error(y, params, type_err, msg_err):
  function test_stacking_regressor_error (line 348) | def test_stacking_regressor_error(y, params, type_err, msg_err):
  function test_stacking_randomness (line 380) | def test_stacking_randomness(estimator, X, y):
  function test_stacking_classifier_stratify_default (line 400) | def test_stacking_classifier_stratify_default():
  function test_stacking_with_sample_weight (line 442) | def test_stacking_with_sample_weight(stacker, X, y):
  function test_stacking_classifier_sample_weight_fit_param (line 471) | def test_stacking_classifier_sample_weight_fit_param():
  function test_stacking_cv_influence (line 508) | def test_stacking_cv_influence(stacker, X, y):
  function test_stacking_without_n_features_in (line 540) | def test_stacking_without_n_features_in(make_dataset, Stacking, Estimator):

FILE: sklearn/ensemble/tests/test_voting.py
  function test_voting_classifier_estimator_init (line 54) | def test_voting_classifier_estimator_init(params, err_msg):
  function test_predictproba_hardvoting (line 60) | def test_predictproba_hardvoting():
  function test_notfitted (line 74) | def test_notfitted():
  function test_majority_label_iris (line 96) | def test_majority_label_iris():
  function test_tie_situation (line 108) | def test_tie_situation():
  function test_weights_iris (line 118) | def test_weights_iris():
  function test_weights_regressor (line 132) | def test_weights_regressor():
  function test_predict_on_toy_problem (line 168) | def test_predict_on_toy_problem():
  function test_predict_proba_on_toy_problem (line 199) | def test_predict_proba_on_toy_problem():
  function test_multilabel (line 248) | def test_multilabel():
  function test_gridsearch (line 263) | def test_gridsearch():
  function test_parallel_fit (line 282) | def test_parallel_fit():
  function test_sample_weight (line 301) | def test_sample_weight():
  function test_sample_weight_kwargs (line 343) | def test_sample_weight_kwargs():
  function test_voting_classifier_set_params (line 359) | def test_voting_classifier_set_params():
  function test_set_estimator_drop (line 379) | def test_set_estimator_drop():
  function test_estimator_weights_format (line 461) | def test_estimator_weights_format():
  function test_transform (line 476) | def test_transform():
  function test_none_estimator_with_weights (line 532) | def test_none_estimator_with_weights(X, y, voter):
  function test_n_features_in (line 564) | def test_n_features_in(est):
  function test_voting_verbose (line 593) | def test_voting_verbose(estimator, capsys):

FILE: sklearn/ensemble/tests/test_weight_boosting.py
  function test_samme_proba (line 54) | def test_samme_proba():
  function test_oneclass_adaboost_proba (line 83) | def test_oneclass_adaboost_proba():
  function test_classification_toy (line 93) | def test_classification_toy(algorithm):
  function test_regression_toy (line 103) | def test_regression_toy():
  function test_iris (line 110) | def test_iris():
  function test_diabetes (line 145) | def test_diabetes(loss):
  function test_staged_predict (line 159) | def test_staged_predict(algorithm):
  function test_gridsearch (line 204) | def test_gridsearch():
  function test_pickle (line 223) | def test_pickle():
  function test_importances (line 251) | def test_importances():
  function test_error (line 273) | def test_error():
  function test_base_estimator (line 280) | def test_base_estimator():
  function test_sample_weights_infinite (line 308) | def test_sample_weights_infinite():
  function test_sparse_classification (line 315) | def test_sparse_classification():
  function test_sparse_regression (line 408) | def test_sparse_regression():
  function test_sample_weight_adaboost_regressor (line 456) | def test_sample_weight_adaboost_regressor():
  function test_multidimensional_X (line 475) | def test_multidimensional_X():
  function test_adaboostclassifier_without_sample_weight (line 497) | def test_adaboostclassifier_without_sample_weight(algorithm):
  function test_adaboostregressor_sample_weight (line 508) | def test_adaboostregressor_sample_weight():
  function test_adaboost_classifier_params_validation (line 566) | def test_adaboost_classifier_params_validation(params, err_type, err_msg):
  function test_adaboost_consistent_predict (line 573) | def test_adaboost_consistent_predict(algorithm):
  function test_adaboost_negative_weight_error (line 595) | def test_adaboost_negative_weight_error(model, X, y):

FILE: sklearn/exceptions.py
  class NotFittedError (line 23) | class NotFittedError(ValueError, AttributeError):
  class ChangedBehaviorWarning (line 46) | class ChangedBehaviorWarning(UserWarning):
  class ConvergenceWarning (line 54) | class ConvergenceWarning(UserWarning):
  class DataConversionWarning (line 62) | class DataConversionWarning(UserWarning):
  class DataDimensionalityWarning (line 80) | class DataDimensionalityWarning(UserWarning):
  class EfficiencyWarning (line 94) | class EfficiencyWarning(UserWarning):
  class FitFailedWarning (line 105) | class FitFailedWarning(RuntimeWarning):
  class NonBLASDotWarning (line 118) | class NonBLASDotWarning(EfficiencyWarning):
  class SkipTestWarning (line 129) | class SkipTestWarning(UserWarning):
  class UndefinedMetricWarning (line 138) | class UndefinedMetricWarning(UserWarning):
  class PositiveSpectrumWarning (line 146) | class PositiveSpectrumWarning(UserWarning):

FILE: sklearn/experimental/tests/test_enable_hist_gradient_boosting.py
  function test_import_raises_warning (line 8) | def test_import_raises_warning():

FILE: sklearn/experimental/tests/test_enable_iterative_imputer.py
  function test_imports_strategies (line 8) | def test_imports_strategies():

FILE: sklearn/experimental/tests/test_enable_successive_halving.py
  function test_imports_strategies (line 8) | def test_imports_strategies():

FILE: sklearn/externals/_arff.py
  class ArffContainerType (line 179) | class ArffContainerType(TypedDict):
  function _build_re_values (line 189) | def _build_re_values():
  function _escape_sub_callback (line 260) | def _escape_sub_callback(match):
  function _unquote (line 273) | def _unquote(v):
  function _parse_values (line 283) | def _parse_values(s):
  class ArffException (line 323) | class ArffException(Exception):
    method __init__ (line 326) | def __init__(self):
    method __str__ (line 329) | def __str__(self):
  class BadRelationFormat (line 332) | class BadRelationFormat(ArffException):
  class BadAttributeFormat (line 336) | class BadAttributeFormat(ArffException):
  class BadDataFormat (line 340) | class BadDataFormat(ArffException):
    method __init__ (line 342) | def __init__(self, value):
  class BadAttributeType (line 349) | class BadAttributeType(ArffException):
  class BadAttributeName (line 354) | class BadAttributeName(ArffException):
    method __init__ (line 358) | def __init__(self, value, value2):
  class BadNominalValue (line 366) | class BadNominalValue(ArffException):
    method __init__ (line 370) | def __init__(self, value):
  class BadNominalFormatting (line 377) | class BadNominalFormatting(ArffException):
    method __init__ (line 379) | def __init__(self, value):
  class BadNumericalValue (line 386) | class BadNumericalValue(ArffException):
  class BadStringValue (line 391) | class BadStringValue(ArffException):
  class BadLayout (line 395) | class BadLayout(ArffException):
    method __init__ (line 399) | def __init__(self, msg=''):
  class BadObject (line 405) | class BadObject(ArffException):
    method __init__ (line 408) | def __init__(self, msg='Invalid object.'):
    method __str__ (line 411) | def __str__(self):
  function _unescape_sub_callback (line 417) | def _unescape_sub_callback(match):
  function encode_string (line 421) | def encode_string(s):
  class EncodedNominalConversor (line 427) | class EncodedNominalConversor:
    method __init__ (line 428) | def __init__(self, values):
    method __call__ (line 432) | def __call__(self, value):
  class NominalConversor (line 439) | class NominalConversor:
    method __init__ (line 440) | def __init__(self, values):
    method __call__ (line 444) | def __call__(self, value):
  class DenseGeneratorData (line 456) | class DenseGeneratorData:
    method decode_rows (line 460) | def decode_rows(self, stream, conversors):
    method _decode_values (line 477) | def _decode_values(values, conversors):
    method encode_data (line 487) | def encode_data(self, data, attributes):
  class _DataListMixin (line 518) | class _DataListMixin:
    method decode_rows (line 520) | def decode_rows(self, stream, conversors):
  class Data (line 524) | class Data(_DataListMixin, DenseGeneratorData):
  class COOData (line 528) | class COOData:
    method decode_rows (line 529) | def decode_rows(self, stream, conversors):
    method encode_data (line 555) | def encode_data(self, data, attributes):
  class LODGeneratorData (line 591) | class LODGeneratorData:
    method decode_rows (line 592) | def decode_rows(self, stream, conversors):
    method encode_data (line 609) | def encode_data(self, data, attributes):
  class LODData (line 633) | class LODData(_DataListMixin, LODGeneratorData):
  function _get_data_object_for_decoding (line 637) | def _get_data_object_for_decoding(matrix_type):
  function _get_data_object_for_encoding (line 651) | def _get_data_object_for_encoding(matrix):
  class ArffDecoder (line 666) | class ArffDecoder:
    method __init__ (line 669) | def __init__(self):
    method _decode_comment (line 674) | def _decode_comment(self, s):
    method _decode_relation (line 690) | def _decode_relation(self, s):
    method _decode_attribute (line 713) | def _decode_attribute(self, s):
    method _decode (line 771) | def _decode(self, s, encode_nominal=False, matrix_type=DENSE):
    method decode (line 878) | def decode(self, s, encode_nominal=False, return_type=DENSE):
  class ArffEncoder (line 901) | class ArffEncoder:
    method _encode_comment (line 904) | def _encode_comment(self, s=''):
    method _encode_relation (line 921) | def _encode_relation(self, name):
    method _encode_attribute (line 937) | def _encode_attribute(self, name, type_):
    method encode (line 971) | def encode(self, obj):
    method iter_encode (line 981) | def iter_encode(self, obj):
  function load (line 1045) | def load(fp, encode_nominal=False, return_type=DENSE):
  function loads (line 1063) | def loads(s, encode_nominal=False, return_type=DENSE):
  function dump (line 1081) | def dump(obj, fp):
  function dumps (line 1099) | def dumps(obj):

FILE: sklearn/externals/_lobpcg.py
  function _report_nonhermitian (line 32) | def _report_nonhermitian(M, name):
  function _as2d (line 49) | def _as2d(ar):
  function _makeOperator (line 62) | def _makeOperator(operatorInput, expectedShape):
  function _applyConstraints (line 77) | def _applyConstraints(blockVectorV, factYBY, blockVectorBY, blockVectorY):
  function _b_orthonormalize (line 84) | def _b_orthonormalize(B, blockVectorV, blockVectorBV=None, retInvR=False):
  function _get_indx (line 119) | def _get_indx(_lambda, num, largest):
  function lobpcg (line 130) | def lobpcg(A, X,

FILE: sklearn/externals/_packaging/_structures.py
  class InfinityType (line 29) | class InfinityType:
    method __repr__ (line 30) | def __repr__(self) -> str:
    method __hash__ (line 33) | def __hash__(self) -> int:
    method __lt__ (line 36) | def __lt__(self, other: object) -> bool:
    method __le__ (line 39) | def __le__(self, other: object) -> bool:
    method __eq__ (line 42) | def __eq__(self, other: object) -> bool:
    method __ne__ (line 45) | def __ne__(self, other: object) -> bool:
    method __gt__ (line 48) | def __gt__(self, other: object) -> bool:
    method __ge__ (line 51) | def __ge__(self, other: object) -> bool:
    method __neg__ (line 54) | def __neg__(self: object) -> "NegativeInfinityType":
  class NegativeInfinityType (line 61) | class NegativeInfinityType:
    method __repr__ (line 62) | def __repr__(self) -> str:
    method __hash__ (line 65) | def __hash__(self) -> int:
    method __lt__ (line 68) | def __lt__(self, other: object) -> bool:
    method __le__ (line 71) | def __le__(self, other: object) -> bool:
    method __eq__ (line 74) | def __eq__(self, other: object) -> bool:
    method __ne__ (line 77) | def __ne__(self, other: object) -> bool:
    method __gt__ (line 80) | def __gt__(self, other: object) -> bool:
    method __ge__ (line 83) | def __ge__(self, other: object) -> bool:
    method __neg__ (line 86) | def __neg__(self: object) -> InfinityType:

FILE: sklearn/externals/_packaging/version.py
  function parse (line 65) | def parse(version: str) -> Union["LegacyVersion", "Version"]:
  class InvalidVersion (line 77) | class InvalidVersion(ValueError):
  class _BaseVersion (line 83) | class _BaseVersion:
    method __hash__ (line 86) | def __hash__(self) -> int:
    method __lt__ (line 92) | def __lt__(self, other: "_BaseVersion") -> bool:
    method __le__ (line 98) | def __le__(self, other: "_BaseVersion") -> bool:
    method __eq__ (line 104) | def __eq__(self, other: object) -> bool:
    method __ge__ (line 110) | def __ge__(self, other: "_BaseVersion") -> bool:
    method __gt__ (line 116) | def __gt__(self, other: "_BaseVersion") -> bool:
    method __ne__ (line 122) | def __ne__(self, other: object) -> bool:
  class LegacyVersion (line 129) | class LegacyVersion(_BaseVersion):
    method __init__ (line 130) | def __init__(self, version: str) -> None:
    method __str__ (line 140) | def __str__(self) -> str:
    method __repr__ (line 143) | def __repr__(self) -> str:
    method public (line 147) | def public(self) -> str:
    method base_version (line 151) | def base_version(self) -> str:
    method epoch (line 155) | def epoch(self) -> int:
    method release (line 159) | def release(self) -> None:
    method pre (line 163) | def pre(self) -> None:
    method post (line 167) | def post(self) -> None:
    method dev (line 171) | def dev(self) -> None:
    method local (line 175) | def local(self) -> None:
    method is_prerelease (line 179) | def is_prerelease(self) -> bool:
    method is_postrelease (line 183) | def is_postrelease(self) -> bool:
    method is_devrelease (line 187) | def is_devrelease(self) -> bool:
  function _parse_version_parts (line 202) | def _parse_version_parts(s: str) -> Iterator[str]:
  function _legacy_cmpkey (line 219) | def _legacy_cmpkey(version: str) -> LegacyCmpKey:
  class Version (line 280) | class Version(_BaseVersion):
    method __init__ (line 284) | def __init__(self, version: str) -> None:
    method __repr__ (line 313) | def __repr__(self) -> str:
    method __str__ (line 316) | def __str__(self) -> str:
    method epoch (line 345) | def epoch(self) -> int:
    method release (line 350) | def release(self) -> Tuple[int, ...]:
    method pre (line 355) | def pre(self) -> Optional[Tuple[str, int]]:
    method post (line 360) | def post(self) -> Optional[int]:
    method dev (line 364) | def dev(self) -> Optional[int]:
    method local (line 368) | def local(self) -> Optional[str]:
    method public (line 375) | def public(self) -> str:
    method base_version (line 379) | def base_version(self) -> str:
    method is_prerelease (line 392) | def is_prerelease(self) -> bool:
    method is_postrelease (line 396) | def is_postrelease(self) -> bool:
    method is_devrelease (line 400) | def is_devrelease(self) -> bool:
    method major (line 404) | def major(self) -> int:
    method minor (line 408) | def minor(self) -> int:
    method micro (line 412) | def micro(self) -> int:
  function _parse_letter_version (line 416) | def _parse_letter_version(
  function _parse_local_version (line 455) | def _parse_local_version(local: str) -> Optional[LocalType]:
  function _cmpkey (line 467) | def _cmpkey(

FILE: sklearn/externals/_pilutil.py
  function bytescale (line 74) | def bytescale(data, cmin=None, cmax=None, high=255, low=0):
  function imread (line 149) | def imread(name, flatten=False, mode=None):
  function imsave (line 208) | def imsave(name, arr, format=None):
  function fromimage (line 263) | def fromimage(im, flatten=False, mode=None):
  function toimage (line 323) | def toimage(arr, high=255, low=0, cmin=None, cmax=None, pal=None,
  function imresize (line 449) | def imresize(arr, size, interp='bilinear', mode=None):

FILE: sklearn/externals/conftest.py
  function pytest_ignore_collect (line 5) | def pytest_ignore_collect(path, config):

FILE: sklearn/feature_extraction/_dict_vectorizer.py
  function _tosequence (line 18) | def _tosequence(X):
  class DictVectorizer (line 26) | class DictVectorizer(TransformerMixin, BaseEstimator):
    method __init__ (line 100) | def __init__(self, *, dtype=np.float64, separator="=", sparse=True, so...
    method _add_iterable_element (line 106) | def _add_iterable_element(
    method fit (line 137) | def fit(self, X, y=None):
    method _transform (line 191) | def _transform(self, X, fitting):
    method fit_transform (line 290) | def fit_transform(self, X, y=None):
    method inverse_transform (line 315) | def inverse_transform(self, X, dict_type=dict):
    method transform (line 356) | def transform(self, X):
    method get_feature_names (line 379) | def get_feature_names(self):
    method get_feature_names_out (line 392) | def get_feature_names_out(self, input_features=None):
    method restrict (line 411) | def restrict(self, support, indices=False):
    method _more_tags (line 459) | def _more_tags(self):

FILE: sklearn/feature_extraction/_hash.py
  function _hashing_transform (line 16) | def _hashing_transform(*args, **kwargs):
  function _iteritems (line 24) | def _iteritems(d):
  class FeatureHasher (line 29) | class FeatureHasher(TransformerMixin, BaseEstimator):
    method __init__ (line 95) | def __init__(
    method _validate_params (line 111) | def _validate_params(n_features, input_type):
    method fit (line 127) | def fit(self, X=None, y=None):
    method transform (line 150) | def transform(self, raw_X):
    method _more_tags (line 189) | def _more_tags(self):

FILE: sklearn/feature_extraction/image.py
  function _make_edges_3d (line 33) | def _make_edges_3d(n_x, n_y, n_z=1):
  function _compute_gradient_3d (line 53) | def _compute_gradient_3d(edges, img):
  function _mask_edges_weights (line 73) | def _mask_edges_weights(mask, edges, weights=None):
  function _to_graph (line 93) | def _to_graph(
  function img_to_graph (line 141) | def img_to_graph(img, *, mask=None, return_as=sparse.coo_matrix, dtype=N...
  function grid_to_graph (line 177) | def grid_to_graph(
  function _compute_n_patches (line 217) | def _compute_n_patches(i_h, i_w, p_h, p_w, max_patches=None):
  function _extract_patches (line 254) | def _extract_patches(arr, patch_shape=8, extraction_step=1):
  function extract_patches_2d (line 313) | def extract_patches_2d(image, patch_size, *, max_patches=None, random_st...
  function reconstruct_from_patches_2d (line 410) | def reconstruct_from_patches_2d(patches, image_size):
  class PatchExtractor (line 453) | class PatchExtractor(BaseEstimator):
    method __init__ (line 495) | def __init__(self, *, patch_size=None, max_patches=None, random_state=...
    method fit (line 500) | def fit(self, X, y=None):
    method transform (line 521) | def transform(self, X):
    method _more_tags (line 567) | def _more_tags(self):

FILE: sklearn/feature_extraction/setup.py
  function configuration (line 5) | def configuration(parent_package="", top_path=None):

FILE: sklearn/feature_extraction/tests/test_dict_vectorizer.py
  function test_dictvectorizer (line 21) | def test_dictvectorizer(sparse, dtype, sort, iterable):
  function test_feature_selection (line 45) | def test_feature_selection(get_names):
  function test_one_of_k (line 63) | def test_one_of_k(get_names):
  function test_iterable_value (line 84) | def test_iterable_value(get_names):
  function test_iterable_not_string_error (line 109) | def test_iterable_not_string_error():
  function test_mapping_error (line 121) | def test_mapping_error():
  function test_unseen_or_no_features (line 138) | def test_unseen_or_no_features():
  function test_deterministic_vocabulary (line 159) | def test_deterministic_vocabulary():
  function test_n_features_in (line 174) | def test_n_features_in():
  function test_feature_union_get_feature_names_deprecated (line 184) | def test_feature_union_get_feature_names_deprecated():
  function test_dictvectorizer_dense_sparse_equivalence (line 194) | def test_dictvectorizer_dense_sparse_equivalence():
  function test_dict_vectorizer_unsupported_value_type (line 234) | def test_dict_vectorizer_unsupported_value_type():
  function test_dict_vectorizer_get_feature_names_out (line 252) | def test_dict_vectorizer_get_feature_names_out():

FILE: sklearn/feature_extraction/tests/test_feature_hasher.py
  function test_feature_hasher_dicts (line 11) | def test_feature_hasher_dicts():
  function test_feature_hasher_strings (line 22) | def test_feature_hasher_strings():
  function test_hashing_transform_seed (line 48) | def test_hashing_transform_seed():
  function test_feature_hasher_pairs (line 72) | def test_feature_hasher_pairs():
  function test_feature_hasher_pairs_with_string_values (line 85) | def test_feature_hasher_pairs_with_string_values():
  function test_hash_empty_input (line 106) | def test_hash_empty_input():
  function test_hasher_invalid_input (line 116) | def test_hasher_invalid_input():
  function test_hasher_set_params (line 135) | def test_hasher_set_params():
  function test_hasher_zeros (line 143) | def test_hasher_zeros():
  function test_hasher_alternate_sign (line 150) | def test_hasher_alternate_sign():
  function test_hash_collisions (line 160) | def test_hash_collisions():

FILE: sklearn/feature_extraction/tests/test_image.py
  function test_img_to_graph (line 22) | def test_img_to_graph():
  function test_img_to_graph_sparse (line 35) | def test_img_to_graph_sparse():
  function test_grid_to_graph (line 50) | def test_grid_to_graph():
  function test_connect_regions (line 87) | def test_connect_regions():
  function test_connect_regions_with_grid (line 104) | def test_connect_regions_with_grid():
  function _downsampled_face (line 125) | def _downsampled_face():
  function _orange_face (line 141) | def _orange_face(face=None):
  function _make_images (line 150) | def _make_images(face=None):
  function test_extract_patches_all (line 165) | def test_extract_patches_all():
  function test_extract_patches_all_color (line 174) | def test_extract_patches_all_color():
  function test_extract_patches_all_rect (line 183) | def test_extract_patches_all_rect():
  function test_extract_patches_max_patches (line 194) | def test_extract_patches_max_patches():
  function test_extract_patch_same_size_image (line 212) | def test_extract_patch_same_size_image():
  function test_extract_patches_less_than_max_patches (line 220) | def test_extract_patches_less_than_max_patches():
  function test_reconstruct_patches_perfect (line 231) | def test_reconstruct_patches_perfect():
  function test_reconstruct_patches_perfect_color (line 240) | def test_reconstruct_patches_perfect_color():
  function test_patch_extractor_fit (line 249) | def test_patch_extractor_fit():
  function test_patch_extractor_max_patches (line 255) | def test_patch_extractor_max_patches():
  function test_patch_extractor_max_patches_default (line 279) | def test_patch_extractor_max_patches_default():
  function test_patch_extractor_all_patches (line 286) | def test_patch_extractor_all_patches():
  function test_patch_extractor_color (line 296) | def test_patch_extractor_color():
  function test_extract_patches_strided (line 306) | def test_extract_patches_strided():
  function test_extract_patches_square (line 354) | def test_extract_patches_square():
  function test_width_patch (line 364) | def test_width_patch():

FILE: sklearn/feature_extraction/tests/test_text.py
  function uppercase (line 62) | def uppercase(s):
  function strip_eacute (line 66) | def strip_eacute(s):
  function split_tokenize (line 70) | def split_tokenize(s):
  function lazy_analyze (line 74) | def lazy_analyze(s):
  function test_strip_accents (line 78) | def test_strip_accents():
  function test_to_ascii (line 114) | def test_to_ascii():
  function test_word_analyzer_unigrams (line 136) | def test_word_analyzer_unigrams(Vectorizer):
  function test_word_analyzer_unigrams_and_bigrams (line 197) | def test_word_analyzer_unigrams_and_bigrams():
  function test_unicode_decode_error (line 227) | def test_unicode_decode_error():
  function test_char_ngram_analyzer (line 246) | def test_char_ngram_analyzer():
  function test_char_wb_ngram_analyzer (line 272) | def test_char_wb_ngram_analyzer():
  function test_word_ngram_analyzer (line 292) | def test_word_ngram_analyzer():
  function test_countvectorizer_custom_vocabulary (line 315) | def test_countvectorizer_custom_vocabulary():
  function test_countvectorizer_custom_vocabulary_pipeline (line 336) | def test_countvectorizer_custom_vocabulary_pipeline():
  function test_countvectorizer_custom_vocabulary_repeated_indices (line 349) | def test_countvectorizer_custom_vocabulary_repeated_indices():
  function test_countvectorizer_custom_vocabulary_gap_index (line 357) | def test_countvectorizer_custom_vocabulary_gap_index():
  function test_countvectorizer_stop_words (line 364) | def test_countvectorizer_stop_words():
  function test_countvectorizer_empty_vocabulary (line 379) | def test_countvectorizer_empty_vocabulary():
  function test_fit_countvectorizer_twice (line 390) | def test_fit_countvectorizer_twice():
  function test_countvectorizer_custom_token_pattern (line 400) | def test_countvectorizer_custom_token_pattern(get_names):
  function test_countvectorizer_custom_token_pattern_with_several_group (line 419) | def test_countvectorizer_custom_token_pattern_with_several_group():
  function test_countvectorizer_uppercase_in_vocab (line 438) | def test_countvectorizer_uppercase_in_vocab():
  function test_tf_transformer_feature_names_out (line 459) | def test_tf_transformer_feature_names_out():
  function test_tf_idf_smoothing (line 469) | def test_tf_idf_smoothing():
  function test_tfidf_no_smoothing (line 485) | def test_tfidf_no_smoothing():
  function test_sublinear_tf (line 504) | def test_sublinear_tf():
  function test_vectorizer (line 515) | def test_vectorizer():
  function test_tfidf_vectorizer_setters (line 618) | def test_tfidf_vectorizer_setters():
  function test_hashing_vectorizer (line 631) | def test_hashing_vectorizer():
  function test_feature_names (line 672) | def test_feature_names(get_names):
  function test_vectorizer_max_features (line 748) | def test_vectorizer_max_features(Vectorizer):
  function test_count_vectorizer_max_features (line 770) | def test_count_vectorizer_max_features(get_names):
  function test_vectorizer_max_df (line 796) | def test_vectorizer_max_df():
  function test_vectorizer_min_df (line 819) | def test_vectorizer_min_df():
  function test_vectorizer_params_validation (line 860) | def test_vectorizer_params_validation(params, err_type, message):
  function test_count_binary_occurrences (line 870) | def test_count_binary_occurrences(get_names):
  function test_hashed_binary_occurrences (line 891) | def test_hashed_binary_occurrences():
  function test_vectorizer_inverse_transform (line 918) | def test_vectorizer_inverse_transform(Vectorizer):
  function test_count_vectorizer_pipeline_grid_selection (line 949) | def test_count_vectorizer_pipeline_grid_selection():
  function test_vectorizer_pipeline_grid_selection (line 985) | def test_vectorizer_pipeline_grid_selection():
  function test_vectorizer_pipeline_cross_validation (line 1024) | def test_vectorizer_pipeline_cross_validation():
  function test_vectorizer_unicode (line 1038) | def test_vectorizer_unicode():
  function test_tfidf_vectorizer_with_fixed_vocabulary (line 1062) | def test_tfidf_vectorizer_with_fixed_vocabulary():
  function test_pickling_vectorizer (line 1072) | def test_pickling_vectorizer():
  function test_pickling_built_processors (line 1110) | def test_pickling_built_processors(factory):
  function test_countvectorizer_vocab_sets_when_pickling (line 1126) | def test_countvectorizer_vocab_sets_when_pickling(get_names):
  function test_countvectorizer_vocab_dicts_when_pickling (line 1155) | def test_countvectorizer_vocab_dicts_when_pickling(get_names):
  function test_stop_words_removal (line 1182) | def test_stop_words_removal():
  function test_pickling_transformer (line 1204) | def test_pickling_transformer():
  function test_transformer_idf_setter (line 1213) | def test_transformer_idf_setter():
  function test_tfidf_vectorizer_setter (line 1221) | def test_tfidf_vectorizer_setter():
  function test_tfidfvectorizer_invalid_idf_attr (line 1232) | def test_tfidfvectorizer_invalid_idf_attr():
  function test_non_unique_vocab (line 1242) | def test_non_unique_vocab():
  function test_hashingvectorizer_nan_in_docs (line 1250) | def test_hashingvectorizer_nan_in_docs():
  function test_tfidfvectorizer_binary (line 1264) | def test_tfidfvectorizer_binary():
  function test_tfidfvectorizer_export_idf (line 1275) | def test_tfidfvectorizer_export_idf():
  function test_vectorizer_vocab_clone (line 1281) | def test_vectorizer_vocab_clone():
  function test_vectorizer_string_object_as_input (line 1292) | def test_vectorizer_string_object_as_input(Vectorizer):
  function test_tfidf_transformer_type (line 1308) | def test_tfidf_transformer_type(X_dtype):
  function test_tfidf_transformer_sparse (line 1314) | def test_tfidf_transformer_sparse():
  function test_tfidf_vectorizer_type (line 1334) | def test_tfidf_vectorizer_type(vectorizer_dtype, output_dtype, warning_e...
  function test_vectorizers_invalid_ngram_range (line 1357) | def test_vectorizers_invalid_ngram_range(vec):
  function _check_stop_words_consistency (line 1379) | def _check_stop_words_consistency(estimator):
  function test_vectorizer_stop_words_inconsistent (line 1387) | def test_vectorizer_stop_words_inconsistent():
  function test_countvectorizer_sort_features_64bit_sparse_indices (line 1415) | def test_countvectorizer_sort_features_64bit_sparse_indices():
  function test_stop_word_validation_custom_preprocessor (line 1443) | def test_stop_word_validation_custom_preprocessor(Estimator):
  function test_callable_analyzer_error (line 1478) | def test_callable_analyzer_error(Estimator, input_type, err_type, err_msg):
  function test_callable_analyzer_change_behavior (line 1498) | def test_callable_analyzer_change_behavior(Estimator, analyzer, input_ty...
  function test_callable_analyzer_reraise_error (line 1507) | def test_callable_analyzer_reraise_error(tmpdir, Estimator):
  function test_unused_parameters_warn (line 1597) | def test_unused_parameters_warn(
  function test_n_features_in (line 1637) | def test_n_features_in(Vectorizer, X):
  function test_tie_breaking_sample_order_invariance (line 1645) | def test_tie_breaking_sample_order_invariance():
  function test_get_feature_names_deprecated (line 1655) | def test_get_feature_names_deprecated():
  function test_nonnegative_hashing_vectorizer_result_indices (line 1663) | def test_nonnegative_hashing_vectorizer_result_indices():

FILE: sklearn/feature_extraction/text.py
  function _preprocess (line 51) | def _preprocess(doc, accent_function=None, lower=False):
  function _analyze (line 77) | def _analyze(
  function strip_accents_unicode (line 124) | def strip_accents_unicode(s):
  function strip_accents_ascii (line 151) | def strip_accents_ascii(s):
  function strip_tags (line 170) | def strip_tags(s):
  function _check_stop_list (line 184) | def _check_stop_list(stop):
  class _VectorizerMixin (line 195) | class _VectorizerMixin:
    method decode (line 200) | def decode(self, doc):
    method _word_ngrams (line 232) | def _word_ngrams(self, tokens, stop_words=None):
    method _char_ngrams (line 262) | def _char_ngrams(self, text_document):
    method _char_wb_ngrams (line 285) | def _char_wb_ngrams(self, text_document):
    method build_preprocessor (line 313) | def build_preprocessor(self):
    method build_tokenizer (line 340) | def build_tokenizer(self):
    method get_stop_words (line 360) | def get_stop_words(self):
    method _check_stop_words_consistency (line 370) | def _check_stop_words_consistency(self, stop_words, preprocess, tokeni...
    method build_analyzer (line 410) | def build_analyzer(self):
    method _validate_vocabulary (line 463) | def _validate_vocabulary(self):
    method _check_vocabulary (line 493) | def _check_vocabulary(self):
    method _validate_params (line 503) | def _validate_params(self):
    method _warn_for_unused_params (line 513) | def _warn_for_unused_params(self):
  class HashingVectorizer (line 557) | class HashingVectorizer(TransformerMixin, _VectorizerMixin, BaseEstimator):
    method __init__ (line 728) | def __init__(
    method partial_fit (line 765) | def partial_fit(self, X, y=None):
    method fit (line 786) | def fit(self, X, y=None):
    method transform (line 814) | def transform(self, X):
    method fit_transform (line 844) | def fit_transform(self, X, y=None):
    method _get_hasher (line 864) | def _get_hasher(self):
    method _more_tags (line 872) | def _more_tags(self):
  function _document_frequency (line 876) | def _document_frequency(X):
  class CountVectorizer (line 884) | class CountVectorizer(_VectorizerMixin, BaseEstimator):
    method __init__ (line 1090) | def __init__(
    method _sort_features (line 1129) | def _sort_features(self, X, vocabulary):
    method _limit_features (line 1143) | def _limit_features(self, X, vocabulary, high=None, low=None, limit=No...
    method _count_vocab (line 1184) | def _count_vocab(self, raw_documents, fixed_vocab):
    method _validate_params (line 1249) | def _validate_params(self):
    method fit (line 1266) | def fit(self, raw_documents, y=None):
    method fit_transform (line 1286) | def fit_transform(self, raw_documents, y=None):
    method transform (line 1356) | def transform(self, raw_documents):
    method inverse_transform (line 1384) | def inverse_transform(self, X):
    method get_feature_names (line 1421) | def get_feature_names(self):
    method get_feature_names_out (line 1433) | def get_feature_names_out(self, input_features=None):
    method _more_tags (line 1452) | def _more_tags(self):
  function _make_int_array (line 1456) | def _make_int_array():
  class TfidfTransformer (line 1461) | class TfidfTransformer(_OneToOneFeatureMixin, TransformerMixin, BaseEsti...
    method __init__ (line 1589) | def __init__(self, *, norm="l2", use_idf=True, smooth_idf=True, sublin...
    method fit (line 1595) | def fit(self, X, y=None):
    method transform (line 1643) | def transform(self, X, copy=True):
    method idf_ (line 1685) | def idf_(self):
    method idf_ (line 1697) | def idf_(self, value):
    method _more_tags (line 1704) | def _more_tags(self):
  class TfidfVectorizer (line 1708) | class TfidfVectorizer(CountVectorizer):
    method __init__ (line 1917) | def __init__(
    method norm (line 1971) | def norm(self):
    method norm (line 1976) | def norm(self, value):
    method use_idf (line 1980) | def use_idf(self):
    method use_idf (line 1985) | def use_idf(self, value):
    method smooth_idf (line 1989) | def smooth_idf(self):
    method smooth_idf (line 1994) | def smooth_idf(self, value):
    method sublinear_tf (line 1998) | def sublinear_tf(self):
    method sublinear_tf (line 2003) | def sublinear_tf(self, value):
    method idf_ (line 2007) | def idf_(self):
    method idf_ (line 2017) | def idf_(self, value):
    method _check_params (line 2027) | def _check_params(self):
    method fit (line 2035) | def fit(self, raw_documents, y=None):
    method fit_transform (line 2057) | def fit_transform(self, raw_documents, y=None):
    method transform (line 2083) | def transform(self, raw_documents):
    method _more_tags (line 2104) | def _more_tags(self):

FILE: sklearn/feature_selection/_base.py
  class SelectorMixin (line 24) | class SelectorMixin(TransformerMixin, metaclass=ABCMeta):
    method get_support (line 33) | def get_support(self, indices=False):
    method _get_support_mask (line 57) | def _get_support_mask(self):
    method transform (line 68) | def transform(self, X):
    method inverse_transform (line 102) | def inverse_transform(self, X):
    method get_feature_names_out (line 142) | def get_feature_names_out(self, input_features=None):
  function _get_feature_importances (line 165) | def _get_feature_importances(estimator, getter, transform_func=None, nor...

FILE: sklearn/feature_selection/_from_model.py
  function _calculate_threshold (line 17) | def _calculate_threshold(estimator, importances, threshold):
  class SelectFromModel (line 63) | class SelectFromModel(MetaEstimatorMixin, SelectorMixin, BaseEstimator):
    method __init__ (line 182) | def __init__(
    method _get_support_mask (line 199) | def _get_support_mask(self):
    method fit (line 229) | def fit(self, X, y=None, **fit_params):
    method threshold_ (line 273) | def threshold_(self):
    method partial_fit (line 284) | def partial_fit(self, X, y=None, **fit_params):
    method n_features_in_ (line 312) | def n_features_in_(self):
    method _more_tags (line 327) | def _more_tags(self):

FILE: sklearn/feature_selection/_mutual_info.py
  function _compute_mi_cc (line 17) | def _compute_mi_cc(x, y, n_neighbors):
  function _compute_mi_cd (line 80) | def _compute_mi_cd(c, d, n_neighbors):
  function _compute_mi (line 153) | def _compute_mi(x, y, x_discrete, y_discrete, n_neighbors=3):
  function _iterate_columns (line 169) | def _iterate_columns(X, columns=None):
  function _estimate_mi (line 199) | def _estimate_mi(
  function mutual_info_regression (line 308) | def mutual_info_regression(
  function mutual_info_classif (line 387) | def mutual_info_classif(

FILE: sklearn/feature_selection/_rfe.py
  function _rfe_single_fit (line 31) | def _rfe_single_fit(rfe, estimator, X, y, train, test, scorer):
  class RFE (line 46) | class RFE(SelectorMixin, MetaEstimatorMixin, BaseEstimator):
    method __init__ (line 173) | def __init__(
    method _estimator_type (line 189) | def _estimator_type(self):
    method classes_ (line 193) | def classes_(self):
    method fit (line 202) | def fit(self, X, y, **fit_params):
    method _fit (line 224) | def _fit(self, X, y, step_score=None, **fit_params):
    method predict (line 322) | def predict(self, X):
    method score (line 339) | def score(self, X, y, **fit_params):
    method _get_support_mask (line 365) | def _get_support_mask(self):
    method decision_function (line 370) | def decision_function(self, X):
    method predict_proba (line 392) | def predict_proba(self, X):
    method predict_log_proba (line 412) | def predict_log_proba(self, X):
    method _more_tags (line 429) | def _more_tags(self):
  class RFECV (line 437) | class RFECV(RFE):
    method __init__ (line 614) | def __init__(
    method fit (line 635) | def fit(self, X, y, groups=None):
    method grid_scores_ (line 759) | def grid_scores_(self):

FILE: sklearn/feature_selection/_sequential.py
  class SequentialFeatureSelector (line 15) | class SequentialFeatureSelector(SelectorMixin, MetaEstimatorMixin, BaseE...
    method __init__ (line 125) | def __init__(
    method fit (line 143) | def fit(self, X, y=None):
    method _get_best_new_feature (line 220) | def _get_best_new_feature(self, estimator, X, y, current_mask):
    method _get_support_mask (line 242) | def _get_support_mask(self):
    method _more_tags (line 246) | def _more_tags(self):

FILE: sklearn/feature_selection/_univariate_selection.py
  function _clean_nans (line 22) | def _clean_nans(scores):
  function f_oneway (line 41) | def f_oneway(*args):
  function f_classif (line 120) | def f_classif(X, y):
  function _chisquare (line 151) | def _chisquare(f_obs, f_exp):
  function chi2 (line 170) | def chi2(X, y):
  function r_regression (line 230) | def r_regression(X, y, *, center=True):
  function f_regression (line 294) | def f_regression(X, y, *, center=True):
  class _BaseFilter (line 367) | class _BaseFilter(SelectorMixin, BaseEstimator):
    method __init__ (line 377) | def __init__(self, score_func):
    method fit (line 380) | def fit(self, X, y):
    method _check_params (line 420) | def _check_params(self, X, y):
    method _more_tags (line 423) | def _more_tags(self):
  class SelectPercentile (line 430) | class SelectPercentile(_BaseFilter):
    method __init__ (line 498) | def __init__(self, score_func=f_classif, *, percentile=10):
    method _check_params (line 502) | def _check_params(self, X, y):
    method _get_support_mask (line 508) | def _get_support_mask(self):
  class SelectKBest (line 528) | class SelectKBest(_BaseFilter):
    method __init__ (line 598) | def __init__(self, score_func=f_classif, *, k=10):
    method _check_params (line 602) | def _check_params(self, X, y):
    method _get_support_mask (line 609) | def _get_support_mask(self):
  class SelectFpr (line 626) | class SelectFpr(_BaseFilter):
    method __init__ (line 691) | def __init__(self, score_func=f_classif, *, alpha=5e-2):
    method _get_support_mask (line 695) | def _get_support_mask(self):
  class SelectFdr (line 701) | class SelectFdr(_BaseFilter):
    method __init__ (line 770) | def __init__(self, score_func=f_classif, *, alpha=5e-2):
    method _get_support_mask (line 774) | def _get_support_mask(self):
  class SelectFwe (line 787) | class SelectFwe(_BaseFilter):
    method __init__ (line 847) | def __init__(self, score_func=f_classif, *, alpha=5e-2):
    method _get_support_mask (line 851) | def _get_support_mask(self):
  class GenericUnivariateSelect (line 863) | class GenericUnivariateSelect(_BaseFilter):
    method __init__ (line 935) | def __init__(self, score_func=f_classif, *, mode="percentile", param=1...
    method _make_selector (line 940) | def _make_selector(self):
    method _check_params (line 951) | def _check_params(self, X, y):
    method _get_support_mask (line 960) | def _get_support_mask(self):

FILE: sklearn/feature_selection/_variance_threshold.py
  class VarianceThreshold (line 11) | class VarianceThreshold(SelectorMixin, BaseEstimator):
    method __init__ (line 70) | def __init__(self, threshold=0.0):
    method fit (line 73) | def fit(self, X, y=None):
    method _get_support_mask (line 124) | def _get_support_mask(self):
    method _more_tags (line 129) | def _more_tags(self):

FILE: sklearn/feature_selection/tests/test_base.py
  class StepSelector (line 12) | class StepSelector(SelectorMixin, BaseEstimator):
    method __init__ (line 15) | def __init__(self, step=2):
    method fit (line 18) | def fit(self, X, y=None):
    method _get_support_mask (line 23) | def _get_support_mask(self):
  function test_transform_dense (line 42) | def test_transform_dense():
  function test_transform_sparse (line 62) | def test_transform_sparse():
  function test_inverse_transform_dense (line 79) | def test_inverse_transform_dense():
  function test_inverse_transform_sparse (line 97) | def test_inverse_transform_sparse():
  function test_get_support (line 112) | def test_get_support():

FILE: sklearn/feature_selection/tests/test_chi2.py
  function mkchi2 (line 25) | def mkchi2(k):
  function test_chi2 (line 30) | def test_chi2():
  function test_chi2_coo (line 53) | def test_chi2_coo():
  function test_chi2_negative (line 61) | def test_chi2_negative():
  function test_chi2_unused_feature (line 69) | def test_chi2_unused_feature():
  function test_chisquare (line 82) | def test_chisquare():

FILE: sklearn/feature_selection/tests/test_feature_select.py
  function test_f_oneway_vs_scipy_stats (line 40) | def test_f_oneway_vs_scipy_stats():
  function test_f_oneway_ints (line 51) | def test_f_oneway_ints():
  function test_f_classif (line 65) | def test_f_classif():
  function test_r_regression (line 94) | def test_r_regression(center):
  function test_f_regression (line 115) | def test_f_regression():
  function test_f_regression_input_dtype (line 142) | def test_f_regression_input_dtype():
  function test_f_regression_center (line 155) | def test_f_regression_center():
  function test_f_classif_multi_class (line 172) | def test_f_classif_multi_class():
  function test_select_percentile_classif (line 197) | def test_select_percentile_classif():
  function test_select_percentile_classif_sparse (line 229) | def test_select_percentile_classif_sparse():
  function test_select_kbest_classif (line 273) | def test_select_kbest_classif():
  function test_select_kbest_all (line 305) | def test_select_kbest_all():
  function test_select_kbest_zero (line 316) | def test_select_kbest_zero():
  function test_select_heuristics_classif (line 332) | def test_select_heuristics_classif():
  function assert_best_scores_kept (line 369) | def assert_best_scores_kept(score_filter):
  function test_select_percentile_regression (line 375) | def test_select_percentile_regression():
  function test_select_percentile_regression_full (line 405) | def test_select_percentile_regression_full():
  function test_invalid_percentile (line 426) | def test_invalid_percentile():
  function test_select_kbest_regression (line 441) | def test_select_kbest_regression():
  function test_select_heuristics_regression (line 469) | def test_select_heuristics_regression():
  function test_boundary_case_ch2 (line 498) | def test_boundary_case_ch2():
  function test_select_fdr_regression (line 534) | def test_select_fdr_regression(alpha, n_informative):
  function test_select_fwe_regression (line 583) | def test_select_fwe_regression():
  function test_selectkbest_tiebreaking (line 606) | def test_selectkbest_tiebreaking():
  function test_selectpercentile_tiebreaking (line 624) | def test_selectpercentile_tiebreaking():
  function test_tied_pvalues (line 641) | def test_tied_pvalues():
  function test_scorefunc_multilabel (line 659) | def test_scorefunc_multilabel():
  function test_tied_scores (line 674) | def test_tied_scores():
  function test_nans (line 685) | def test_nans():
  function test_score_func_error (line 700) | def test_score_func_error():
  function test_invalid_k (line 716) | def test_invalid_k():
  function test_f_classif_constant_feature (line 730) | def test_f_classif_constant_feature():
  function test_no_feature_selected (line 739) | def test_no_feature_selected():
  function test_mutual_info_classif (line 760) | def test_mutual_info_classif():
  function test_mutual_info_regression (line 804) | def test_mutual_info_regression():

FILE: sklearn/feature_selection/tests/test_from_model.py
  class NaNTag (line 20) | class NaNTag(BaseEstimator):
    method _more_tags (line 21) | def _more_tags(self):
  class NoNaNTag (line 25) | class NoNaNTag(BaseEstimator):
    method _more_tags (line 26) | def _more_tags(self):
  class NaNTagRandomForest (line 30) | class NaNTagRandomForest(RandomForestClassifier):
    method _more_tags (line 31) | def _more_tags(self):
  function test_invalid_input (line 40) | def test_invalid_input():
  function test_input_estimator_unchanged (line 51) | def test_input_estimator_unchanged():
  function test_max_features_error (line 68) | def test_max_features_error(max_features, err_type, err_msg):
  function test_max_features_dim (line 79) | def test_max_features_dim(max_features):
  class FixedImportanceEstimator (line 88) | class FixedImportanceEstimator(BaseEstimator):
    method __init__ (line 89) | def __init__(self, importances):
    method fit (line 92) | def fit(self, X, y=None):
  function test_max_features (line 96) | def test_max_features():
  function test_max_features_tiebreak (line 139) | def test_max_features_tiebreak():
  function test_threshold_and_max_features (line 165) | def test_threshold_and_max_features():
  function test_feature_importances (line 191) | def test_feature_importances():
  function test_sample_weight (line 216) | def test_sample_weight():
  function test_coef_default_threshold (line 244) | def test_coef_default_threshold():
  function test_2d_coef (line 264) | def test_2d_coef():
  function test_partial_fit (line 295) | def test_partial_fit():
  function test_calling_fit_reinitializes (line 315) | def test_calling_fit_reinitializes():
  function test_prefit (line 324) | def test_prefit():
  function test_threshold_string (line 349) | def test_threshold_string():
  function test_threshold_without_refitting (line 362) | def test_threshold_without_refitting():
  function test_fit_accepts_nan_inf (line 374) | def test_fit_accepts_nan_inf():
  function test_transform_accepts_nan_inf (line 387) | def test_transform_accepts_nan_inf():
  function test_allow_nan_tag_comes_from_estimator (line 401) | def test_allow_nan_tag_comes_from_estimator():
  function _pca_importances (line 411) | def _pca_importances(pca_estimator):
  function test_importance_getter (line 425) | def test_importance_getter(estimator, importance_getter):

FILE: sklearn/feature_selection/tests/test_mutual_info.py
  function test_compute_mi_dd (line 11) | def test_compute_mi_dd():
  function test_compute_mi_cc (line 24) | def test_compute_mi_cc():
  function test_compute_mi_cd (line 57) | def test_compute_mi_cd():
  function test_compute_mi_cd_unique_label (line 94) | def test_compute_mi_cd_unique_label():
  function test_mutual_info_classif_discrete (line 114) | def test_mutual_info_classif_discrete():
  function test_mutual_info_regression (line 124) | def test_mutual_info_regression():
  function test_mutual_info_classif_mixed (line 143) | def test_mutual_info_classif_mixed():
  function test_mutual_info_options (line 167) | def test_mutual_info_options():

FILE: sklearn/feature_selection/tests/test_rfe.py
  class MockClassifier (line 31) | class MockClassifier:
    method __init__ (line 36) | def __init__(self, foo_param=0):
    method fit (line 39) | def fit(self, X, y):
    method predict (line 44) | def predict(self, T):
    method score (line 51) | def score(self, X=None, y=None):
    method get_params (line 54) | def get_params(self, deep=True):
    method set_params (line 57) | def set_params(self, **params):
    method _more_tags (line 60) | def _more_tags(self):
  function test_rfe_features_importance (line 64) | def test_rfe_features_importance():
  function test_rfe (line 83) | def test_rfe():
  function test_RFE_fit_score_params (line 112) | def test_RFE_fit_score_params():
  function test_rfe_invalid_n_features_errors (line 138) | def test_rfe_invalid_n_features_errors(n_features_to_select):
  function test_rfe_percent_n_features (line 148) | def test_rfe_percent_n_features():
  function test_rfe_mockclassifier (line 166) | def test_rfe_mockclassifier():
  function test_rfecv (line 182) | def test_rfecv():
  function test_rfecv_mockclassifier (line 277) | def test_rfecv_mockclassifier():
  function test_rfecv_verbose_output (line 302) | def test_rfecv_verbose_output():
  function test_rfecv_cv_results_size (line 322) | def test_rfecv_cv_results_size():
  function test_rfe_estimator_tags (line 355) | def test_rfe_estimator_tags():
  function test_rfe_min_step (line 364) | def test_rfe_min_step():
  function test_number_of_subsets_of_features (line 386) | def test_number_of_subsets_of_features():
  function test_rfe_cv_n_jobs (line 464) | def test_rfe_cv_n_jobs():
  function test_rfe_cv_groups (line 497) | def test_rfe_cv_groups():
  function test_rfe_wrapped_estimator (line 519) | def test_rfe_wrapped_estimator(importance_getter, selector, expected_n_f...
  function test_rfe_importance_getter_validation (line 544) | def test_rfe_importance_getter_validation(importance_getter, err_type, S...
  function test_rfe_allow_nan_inf_in_x (line 557) | def test_rfe_allow_nan_inf_in_x(cv):
  function test_w_pipeline_2d_coef_ (line 575) | def test_w_pipeline_2d_coef_():
  function test_rfecv_std_and_mean (line 589) | def test_rfecv_std_and_mean():
  function test_multioutput (line 609) | def test_multioutput(ClsRFE):

FILE: sklearn/feature_selection/tests/test_sequential.py
  function test_bad_n_features_to_select (line 16) | def test_bad_n_features_to_select(n_features_to_select):
  function test_bad_direction (line 25) | def test_bad_direction():
  function test_n_features_to_select (line 34) | def test_n_features_to_select(direction, n_features_to_select):
  function test_n_features_to_select_float (line 62) | def test_n_features_to_select_float(direction, n_features_to_select, exp...
  function test_sanity (line 84) | def test_sanity(seed, direction, n_features_to_select, expected_selected...
  function test_sparse_support (line 104) | def test_sparse_support():
  function test_nan_support (line 114) | def test_nan_support():
  function test_pipeline_support (line 131) | def test_pipeline_support():
  function test_unsupervised_model_fit (line 152) | def test_unsupervised_model_fit(n_features_to_select):
  function test_no_y_validation_model_fit (line 166) | def test_no_y_validation_model_fit(y):

FILE: sklearn/feature_selection/tests/test_variance_threshold.py
  function test_zero_variance (line 15) | def test_zero_variance():
  function test_variance_threshold (line 28) | def test_variance_threshold():
  function test_variance_negative (line 36) | def test_variance_negative(X):
  function test_zero_variance_floating_point_error (line 51) | def test_zero_variance_floating_point_error():
  function test_variance_nan (line 63) | def test_variance_nan():

FILE: sklearn/gaussian_process/_gpc.py
  class _BinaryGaussianProcessClassifierLaplace (line 35) | class _BinaryGaussianProcessClassifierLaplace(BaseEstimator):
    method __init__ (line 148) | def __init__(
    method fit (line 167) | def fit(self, X, y):
    method predict (line 265) | def predict(self, X):
    method predict_proba (line 288) | def predict_proba(self, X):
    method log_marginal_likelihood (line 330) | def log_marginal_likelihood(
    method _posterior_mode (line 409) | def _posterior_mode(self, K, return_temporaries=False):
    method _constrained_optimization (line 467) | def _constrained_optimization(self, obj_func, initial_theta, bounds):
  class GaussianProcessClassifier (line 482) | class GaussianProcessClassifier(ClassifierMixin, BaseEstimator):
    method __init__ (line 637) | def __init__(
    method fit (line 660) | def fit(self, X, y):
    method predict (line 731) | def predict(self, X):
    method predict_proba (line 753) | def predict_proba(self, X):
    method kernel_ (line 784) | def kernel_(self):
    method log_marginal_likelihood (line 793) | def log_marginal_likelihood(

FILE: sklearn/gaussian_process/_gpr.py
  class GaussianProcessRegressor (line 24) | class GaussianProcessRegressor(MultiOutputMixin, RegressorMixin, BaseEst...
    method __init__ (line 176) | def __init__(
    method fit (line 195) | def fit(self, X, y):
    method predict (line 326) | def predict(self, X, return_std=False, return_cov=False):
    method sample_y (line 447) | def sample_y(self, X, n_samples=1, random_state=0):
    method log_marginal_likelihood (line 484) | def log_marginal_likelihood(
    method _constrained_optimization (line 601) | def _constrained_optimization(self, obj_func, initial_theta, bounds):
    method _more_tags (line 619) | def _more_tags(self):

FILE: sklearn/gaussian_process/kernels.py
  function _check_length_scale (line 39) | def _check_length_scale(X, length_scale):
  class Hyperparameter (line 51) | class Hyperparameter(
    method __new__ (line 121) | def __new__(cls, name, value_type, bounds, n_elements=1, fixed=None):
    method __eq__ (line 142) | def __eq__(self, other):
  class Kernel (line 152) | class Kernel(metaclass=ABCMeta):
    method get_params (line 158) | def get_params(self, deep=True):
    method set_params (line 198) | def set_params(self, **params):
    method clone_with_theta (line 238) | def clone_with_theta(self, theta):
    method n_dims (line 251) | def n_dims(self):
    method hyperparameters (line 256) | def hyperparameters(self):
    method theta (line 266) | def theta(self):
    method theta (line 290) | def theta(self, theta):
    method bounds (line 321) | def bounds(self):
    method __add__ (line 339) | def __add__(self, b):
    method __radd__ (line 344) | def __radd__(self, b):
    method __mul__ (line 349) | def __mul__(self, b):
    method __rmul__ (line 354) | def __rmul__(self, b):
    method __pow__ (line 359) | def __pow__(self, b):
    method __eq__ (line 362) | def __eq__(self, b):
    method __repr__ (line 372) | def __repr__(self):
    method __call__ (line 378) | def __call__(self, X, Y=None, eval_gradient=False):
    method diag (line 382) | def diag(self, X):
    method is_stationary (line 401) | def is_stationary(self):
    method requires_vector_input (line 405) | def requires_vector_input(self):
    method _check_bounds_params (line 411) | def _check_bounds_params(self):
  class NormalizedKernelMixin (line 442) | class NormalizedKernelMixin:
    method diag (line 448) | def diag(self, X):
  class StationaryKernelMixin (line 468) | class StationaryKernelMixin:
    method is_stationary (line 474) | def is_stationary(self):
  class GenericKernelMixin (line 479) | class GenericKernelMixin:
    method requires_vector_input (line 487) | def requires_vector_input(self):
  class CompoundKernel (line 492) | class CompoundKernel(Kernel):
    method __init__ (line 518) | def __init__(self, kernels):
    method get_params (line 521) | def get_params(self, deep=True):
    method theta (line 538) | def theta(self):
    method theta (line 554) | def theta(self, theta):
    method bounds (line 567) | def bounds(self):
    method __call__ (line 577) | def __call__(self, X, Y=None, eval_gradient=False):
    method __eq__ (line 620) | def __eq__(self, b):
    method is_stationary (line 627) | def is_stationary(self):
    method requires_vector_input (line 632) | def requires_vector_input(self):
    method diag (line 636) | def diag(self, X):
  class KernelOperator (line 656) | class KernelOperator(Kernel):
    method __init__ (line 662) | def __init__(self, k1, k2):
    method get_params (line 666) | def get_params(self, deep=True):
    method hyperparameters (line 690) | def hyperparameters(self):
    method theta (line 714) | def theta(self):
    method theta (line 730) | def theta(self, theta):
    method bounds (line 743) | def bounds(self):
    method __eq__ (line 757) | def __eq__(self, b):
    method is_stationary (line 764) | def is_stationary(self):
    method requires_vector_input (line 769) | def requires_vector_input(self):
  class Sum (line 774) | class Sum(KernelOperator):
    method __call__ (line 813) | def __call__(self, X, Y=None, eval_gradient=False):
    method diag (line 848) | def diag(self, X):
    method __repr__ (line 867) | def __repr__(self):
  class Product (line 871) | class Product(KernelOperator):
    method __call__ (line 911) | def __call__(self, X, Y=None, eval_gradient=False):
    method diag (line 948) | def diag(self, X):
    method __repr__ (line 967) | def __repr__(self):
  class Exponentiation (line 971) | class Exponentiation(Kernel):
    method __init__ (line 1012) | def __init__(self, kernel, exponent):
    method get_params (line 1016) | def get_params(self, deep=True):
    method hyperparameters (line 1037) | def hyperparameters(self):
    method theta (line 1052) | def theta(self):
    method theta (line 1068) | def theta(self, theta):
    method bounds (line 1079) | def bounds(self):
    method __eq__ (line 1089) | def __eq__(self, b):
    method __call__ (line 1094) | def __call__(self, X, Y=None, eval_gradient=False):
    method diag (line 1130) | def diag(self, X):
    method __repr__ (line 1149) | def __repr__(self):
    method is_stationary (line 1152) | def is_stationary(self):
    method requires_vector_input (line 1157) | def requires_vector_input(self):
  class ConstantKernel (line 1162) | class ConstantKernel(StationaryKernelMixin, GenericKernelMixin, Kernel):
    method __init__ (line 1211) | def __init__(self, constant_value=1.0, constant_value_bounds=(1e-5, 1e...
    method hyperparameter_constant_value (line 1216) | def hyperparameter_constant_value(self):
    method __call__ (line 1219) | def __call__(self, X, Y=None, eval_gradient=False):
    method diag (line 1273) | def diag(self, X):
    method __repr__ (line 1296) | def __repr__(self):
  class WhiteKernel (line 1300) | class WhiteKernel(StationaryKernelMixin, GenericKernelMixin, Kernel):
    method __init__ (line 1341) | def __init__(self, noise_level=1.0, noise_level_bounds=(1e-5, 1e5)):
    method hyperparameter_noise_level (line 1346) | def hyperparameter_noise_level(self):
    method __call__ (line 1349) | def __call__(self, X, Y=None, eval_gradient=False):
    method diag (line 1396) | def diag(self, X):
    method __repr__ (line 1417) | def __repr__(self):
  class RBF (line 1423) | class RBF(StationaryKernelMixin, NormalizedKernelMixin, Kernel):
    method __init__ (line 1486) | def __init__(self, length_scale=1.0, length_scale_bounds=(1e-5, 1e5)):
    method anisotropic (line 1491) | def anisotropic(self):
    method hyperparameter_length_scale (line 1495) | def hyperparameter_length_scale(self):
    method __call__ (line 1505) | def __call__(self, X, Y=None, eval_gradient=False):
    method __repr__ (line 1564) | def __repr__(self):
  class Matern (line 1576) | class Matern(RBF):
    method __init__ (line 1656) | def __init__(self, length_scale=1.0, length_scale_bounds=(1e-5, 1e5), ...
    method __call__ (line 1660) | def __call__(self, X, Y=None, eval_gradient=False):
    method __repr__ (line 1760) | def __repr__(self):
  class RationalQuadratic (line 1773) | class RationalQuadratic(StationaryKernelMixin, NormalizedKernelMixin, Ke...
    method __init__ (line 1836) | def __init__(
    method hyperparameter_length_scale (line 1849) | def hyperparameter_length_scale(self):
    method hyperparameter_alpha (line 1853) | def hyperparameter_alpha(self):
    method __call__ (line 1856) | def __call__(self, X, Y=None, eval_gradient=False):
    method __repr__ (line 1923) | def __repr__(self):
  class ExpSineSquared (line 1929) | class ExpSineSquared(StationaryKernelMixin, NormalizedKernelMixin, Kernel):
    method __init__ (line 1984) | def __init__(
    method hyperparameter_length_scale (line 1997) | def hyperparameter_length_scale(self):
    method hyperparameter_periodicity (line 2002) | def hyperparameter_periodicity(self):
    method __call__ (line 2005) | def __call__(self, X, Y=None, eval_gradient=False):
    method __repr__ (line 2068) | def __repr__(self):
  class DotProduct (line 2074) | class DotProduct(Kernel):
    method __init__ (line 2131) | def __init__(self, sigma_0=1.0, sigma_0_bounds=(1e-5, 1e5)):
    method hyperparameter_sigma_0 (line 2136) | def hyperparameter_sigma_0(self):
    method __call__ (line 2139) | def __call__(self, X, Y=None, eval_gradient=False):
    method diag (line 2185) | def diag(self, X):
    method is_stationary (line 2204) | def is_stationary(self):
    method __repr__ (line 2208) | def __repr__(self):
  function _approx_fprime (line 2213) | def _approx_fprime(xk, f, epsilon, args=()):
  class PairwiseKernel (line 2225) | class PairwiseKernel(Kernel):
    method __init__ (line 2282) | def __init__(
    method hyperparameter_gamma (line 2295) | def hyperparameter_gamma(self):
    method __call__ (line 2298) | def __call__(self, X, Y=None, eval_gradient=False):
    method diag (line 2358) | def diag(self, X):
    method is_stationary (line 2378) | def is_stationary(self):
    method __repr__ (line 2382) | def __repr__(self):

FILE: sklearn/gaussian_process/tests/_mini_sequence_kernel.py
  class MiniSeqKernel (line 8) | class MiniSeqKernel(GenericKernelMixin, StationaryKernelMixin, Kernel):
    method __init__ (line 14) | def __init__(self, baseline_similarity=0.5, baseline_similarity_bounds...
    method hyperparameter_baseline_similarity (line 19) | def hyperparameter_baseline_similarity(self):
    method _f (line 24) | def _f(self, s1, s2):
    method _g (line 29) | def _g(self, s1, s2):
    method __call__ (line 32) | def __call__(self, X, Y=None, eval_gradient=False):
    method diag (line 44) | def diag(self, X):
    method clone_with_theta (line 47) | def clone_with_theta(self, theta):

FILE: sklearn/gaussian_process/tests/test_gpc.py
  function f (line 21) | def f(x):
  function test_predict_consistent (line 46) | def test_predict_consistent(kernel):
  function test_predict_consistent_structured (line 52) | def test_predict_consistent_structured():
  function test_lml_improving (line 62) | def test_lml_improving(kernel):
  function test_lml_precomputed (line 71) | def test_lml_precomputed(kernel):
  function test_lml_without_cloning_kernel (line 80) | def test_lml_without_cloning_kernel(kernel):
  function test_converged_to_local_maximum (line 90) | def test_converged_to_local_maximum(kernel):
  function test_lml_gradient (line 104) | def test_lml_gradient(kernel):
  function test_random_starts (line 116) | def test_random_starts():
  function test_custom_optimizer (line 138) | def test_custom_optimizer(kernel):
  function test_multi_class (line 164) | def test_multi_class(kernel):
  function test_multi_class_n_jobs (line 177) | def test_multi_class_n_jobs(kernel):
  function test_warning_bounds (line 190) | def test_warning_bounds():

FILE: sklearn/gaussian_process/tests/test_gpr.py
  function f (line 30) | def f(x):
  function test_gpr_interpolation (line 53) | def test_gpr_interpolation(kernel):
  function test_gpr_interpolation_structured (line 65) | def test_gpr_interpolation_structured():
  function test_lml_improving (line 81) | def test_lml_improving(kernel):
  function test_lml_precomputed (line 93) | def test_lml_precomputed(kernel):
  function test_lml_without_cloning_kernel (line 102) | def test_lml_without_cloning_kernel(kernel):
  function test_converged_to_local_maximum (line 112) | def test_converged_to_local_maximum(kernel):
  function test_solution_inside_bounds (line 126) | def test_solution_inside_bounds(kernel):
  function test_lml_gradient (line 140) | def test_lml_gradient(kernel):
  function test_prior (line 153) | def test_prior(kernel):
  function test_sample_statistics (line 168) | def test_sample_statistics(kernel):
  function test_no_optimizer (line 185) | def test_no_optimizer():
  function test_predict_cov_vs_std (line 194) | def test_predict_cov_vs_std(kernel, target):
  function test_anisotropic_kernel (line 205) | def test_anisotropic_kernel():
  function test_random_starts (line 219) | def test_random_starts():
  function test_y_normalization (line 247) | def test_y_normalization(kernel):
  function test_large_variance_y (line 286) | def test_large_variance_y():
  function test_y_multioutput (line 341) | def test_y_multioutput():
  function test_custom_optimizer (line 383) | def test_custom_optimizer(kernel):
  function test_gpr_correct_error_message (line 408) | def test_gpr_correct_error_message():
  function test_duplicate_input (line 424) | def test_duplicate_input(kernel):
  function test_no_fit_default_predict (line 445) | def test_no_fit_default_predict():
  function test_warning_bounds (line 462) | def test_warning_bounds():
  function test_bound_check_fixed_hyperparameter (line 537) | def test_bound_check_fixed_hyperparameter():
  function test_constant_target (line 552) | def test_constant_target(kernel):
  function test_gpr_consistency_std_cov_non_invertible_kernel (line 572) | def test_gpr_consistency_std_cov_non_invertible_kernel():
  function test_gpr_fit_error (line 632) | def test_gpr_fit_error(params, TypeError, err_msg):
  function test_gpr_lml_error (line 639) | def test_gpr_lml_error():
  function test_gpr_predict_error (line 648) | def test_gpr_predict_error():
  function test_y_std_with_multitarget_normalized (line 657) | def test_y_std_with_multitarget_normalized():

FILE: sklearn/gaussian_process/tests/test_kernels.py
  function test_kernel_gradient (line 76) | def test_kernel_gradient(kernel):
  function test_kernel_theta (line 105) | def test_kernel_theta(kernel):
  function test_auto_vs_cross (line 163) | def test_auto_vs_cross(kernel):
  function test_kernel_diag (line 171) | def test_kernel_diag(kernel):
  function test_kernel_operator_commutative (line 178) | def test_kernel_operator_commutative():
  function test_kernel_anisotropic (line 187) | def test_kernel_anisotropic():
  function test_kernel_stationary (line 211) | def test_kernel_stationary(kernel):
  function test_kernel_input_type (line 218) | def test_kernel_input_type(kernel):
  function test_compound_kernel_input_type (line 228) | def test_compound_kernel_input_type():
  function check_hyperparameters_equal (line 236) | def check_hyperparameters_equal(kernel1, kernel2):
  function test_kernel_clone (line 246) | def test_kernel_clone(kernel):
  function test_kernel_clone_after_set_params (line 263) | def test_kernel_clone_after_set_params(kernel):
  function test_matern_kernel (line 291) | def test_matern_kernel():
  function test_kernel_versus_pairwise (line 321) | def test_kernel_versus_pairwise(kernel):
  function test_set_get_params (line 339) | def test_set_get_params(kernel):
  function test_repr_kernels (line 381) | def test_repr_kernels(kernel):
  function test_rational_quadratic_kernel (line 387) | def test_rational_quadratic_kernel():

FILE: sklearn/impute/_base.py
  function _check_inputs_dtype (line 24) | def _check_inputs_dtype(X, missing_values):
  function _most_frequent (line 36) | def _most_frequent(array, extra_value, n_repeat):
  class _BaseImputer (line 73) | class _BaseImputer(TransformerMixin, BaseEstimator):
    method __init__ (line 79) | def __init__(self, *, missing_values=np.nan, add_indicator=False):
    method _fit_indicator (line 83) | def _fit_indicator(self, X):
    method _transform_indicator (line 93) | def _transform_indicator(self, X):
    method _concatenate_indicator (line 106) | def _concatenate_indicator(self, X_imputed, X_indicator):
    method _concatenate_indicator_feature_names_out (line 121) | def _concatenate_indicator_feature_names_out(self, names, input_featur...
    method _more_tags (line 128) | def _more_tags(self):
  class SimpleImputer (line 132) | class SimpleImputer(_BaseImputer):
    method __init__ (line 242) | def __init__(
    method _validate_input (line 258) | def _validate_input(self, X, in_fit):
    method fit (line 319) | def fit(self, X, y=None):
    method _sparse_fit (line 390) | def _sparse_fit(self, X, strategy, missing_values, fill_value):
    method _dense_fit (line 427) | def _dense_fit(self, X, strategy, missing_values, fill_value):
    method transform (line 480) | def transform(self, X):
    method inverse_transform (line 563) | def inverse_transform(self, X):
    method _more_tags (line 625) | def _more_tags(self):
    method get_feature_names_out (line 632) | def get_feature_names_out(self, input_features=None):
  class MissingIndicator (line 657) | class MissingIndicator(TransformerMixin, BaseEstimator):
    method __init__ (line 740) | def __init__(
    method _get_missing_features_info (line 753) | def _get_missing_features_info(self, X):
    method _validate_input (line 807) | def _validate_input(self, X, in_fit):
    method _fit (line 841) | def _fit(self, X, y=None, precomputed=False):
    method fit (line 895) | def fit(self, X, y=None):
    method transform (line 916) | def transform(self, X):
    method fit_transform (line 957) | def fit_transform(self, X, y=None):
    method get_feature_names_out (line 982) | def get_feature_names_out(self, input_features=None):
    method _more_tags (line 1011) | def _more_tags(self):

FILE: sklearn/impute/_iterative.py
  class IterativeImputer (line 26) | class IterativeImputer(_BaseImputer):
    method __init__ (line 224) | def __init__(
    method _impute_one_feature (line 257) | def _impute_one_feature(
    method _get_neighbor_feat_idx (line 359) | def _get_neighbor_feat_idx(self, n_features, feat_idx, abs_corr_mat):
    method _get_ordered_idx (line 395) | def _get_ordered_idx(self, mask_missing_values):
    method _get_abs_corr_mat (line 442) | def _get_abs_corr_mat(self, X_filled, tolerance=1e-6):
    method _initial_imputation (line 480) | def _initial_imputation(self, X, in_fit=False):
    method _validate_limit (line 543) | def _validate_limit(limit, limit_type, n_features):
    method fit_transform (line 575) | def fit_transform(self, X, y=None):
    method transform (line 707) | def transform(self, X):
    method fit (line 759) | def fit(self, X, y=None):
    method get_feature_names_out (line 779) | def get_feature_names_out(self, input_features=None):

FILE: sklearn/impute/_knn.py
  class KNNImputer (line 19) | class KNNImputer(_BaseImputer):
    method __init__ (line 118) | def __init__(
    method _calc_impute (line 134) | def _calc_impute(self, dist_pot_donors, n_neighbors, fit_X_col, mask_f...
    method fit (line 181) | def fit(self, X, y=None):
    method transform (line 227) | def transform(self, X):
    method get_feature_names_out (line 344) | def get_feature_names_out(self, input_features=None):

FILE: sklearn/impute/tests/test_base.py
  function data (line 10) | def data():
  class NoFitIndicatorImputer (line 16) | class NoFitIndicatorImputer(_BaseImputer):
    method fit (line 17) | def fit(self, X, y=None):
    method transform (line 20) | def transform(self, X, y=None):
  class NoTransformIndicatorImputer (line 24) | class NoTransformIndicatorImputer(_BaseImputer):
    method fit (line 25) | def fit(self, X, y=None):
    method transform (line 30) | def transform(self, X, y=None):
  class NoPrecomputedMaskFit (line 34) | class NoPrecomputedMaskFit(_BaseImputer):
    method fit (line 35) | def fit(self, X, y=None):
    method transform (line 39) | def transform(self, X):
  class NoPrecomputedMaskTransform (line 43) | class NoPrecomputedMaskTransform(_BaseImputer):
    method fit (line 44) | def fit(self, X, y=None):
    method transform (line 49) | def transform(self, X):
  function test_base_imputer_not_fit (line 53) | def test_base_imputer_not_fit(data):
  function test_base_imputer_not_transform (line 62) | def test_base_imputer_not_transform(data):
  function test_base_no_precomputed_mask_fit (line 73) | def test_base_no_precomputed_mask_fit(data):
  function test_base_no_precomputed_mask_transform (line 82) | def test_base_no_precomputed_mask_transform(data):

FILE: sklearn/impute/tests/test_common.py
  function test_imputation_missing_value_in_test_array (line 24) | def test_imputation_missing_value_in_test_array(imputer):
  function test_imputers_add_indicator (line 37) | def test_imputers_add_indicator(marker, imputer):
  function test_imputers_add_indicator_sparse (line 69) | def test_imputers_add_indicator_sparse(imputer, marker):
  function test_imputers_pandas_na_integer_array_support (line 101) | def test_imputers_pandas_na_integer_array_support(imputer, add_indicator):
  function test_imputers_feature_names_out_pandas (line 129) | def test_imputers_feature_names_out_pandas(imputer, add_indicator):

FILE: sklearn/impute/tests/test_impute.py
  function _assert_array_equal_and_same_dtype (line 31) | def _assert_array_equal_and_same_dtype(x, y):
  function _assert_allclose_and_same_dtype (line 36) | def _assert_allclose_and_same_dtype(x, y):
  function _check_statistics (line 41) | def _check_statistics(X, X_true, strategy, statistics, missing_values):
  function test_imputation_shape (line 79) | def test_imputation_shape(strategy):
  function test_imputation_error_invalid_strategy (line 96) | def test_imputation_error_invalid_strategy(strategy):
  function test_imputation_deletion_warning (line 106) | def test_imputation_deletion_warning(strategy):
  function test_imputation_error_sparse_0 (line 120) | def test_imputation_error_sparse_0(strategy):
  function safe_median (line 135) | def safe_median(arr, *args, **kwargs):
  function safe_mean (line 141) | def safe_mean(arr, *args, **kwargs):
  function test_imputation_mean_median (line 147) | def test_imputation_mean_median():
  function test_imputation_median_special_cases (line 214) | def test_imputation_median_special_cases():
  function test_imputation_mean_median_error_invalid_type (line 248) | def test_imputation_mean_median_error_invalid_type(strategy, dtype):
  function test_imputation_mean_median_error_invalid_type_list_pandas (line 258) | def test_imputation_mean_median_error_invalid_type_list_pandas(strategy,...
  function test_imputation_const_mostf_error_invalid_types (line 271) | def test_imputation_const_mostf_error_invalid_types(strategy, dtype):
  function test_imputation_most_frequent (line 290) | def test_imputation_most_frequent():
  function test_imputation_most_frequent_objects (line 318) | def test_imputation_most_frequent_objects(marker):
  function test_imputation_most_frequent_pandas (line 347) | def test_imputation_most_frequent_pandas(dtype):
  function test_imputation_constant_error_invalid_type (line 367) | def test_imputation_constant_error_invalid_type(X_data, missing_value):
  function test_imputation_constant_integer (line 379) | def test_imputation_constant_integer():
  function test_imputation_constant_float (line 392) | def test_imputation_constant_float(array_constructor):
  function test_imputation_constant_object (line 418) | def test_imputation_constant_object(marker):
  function test_imputation_constant_pandas (line 449) | def test_imputation_constant_pandas(dtype):
  function test_iterative_imputer_one_feature (line 474) | def test_iterative_imputer_one_feature(X):
  function test_imputation_pipeline_grid_search (line 485) | def test_imputation_pipeline_grid_search():
  function test_imputation_copy (line 504) | def test_imputation_copy():
  function test_iterative_imputer_zero_iters (line 547) | def test_iterative_imputer_zero_iters():
  function test_iterative_imputer_verbose (line 571) | def test_iterative_imputer_verbose():
  function test_iterative_imputer_all_missing (line 585) | def test_iterative_imputer_all_missing():
  function test_iterative_imputer_imputation_order (line 597) | def test_iterative_imputer_imputation_order(imputation_order):
  function test_iterative_imputer_estimators (line 637) | def test_iterative_imputer_estimators(estimator):
  function test_iterative_imputer_clip (line 662) | def test_iterative_imputer_clip():
  function test_iterative_imputer_clip_truncnorm (line 678) | def test_iterative_imputer_clip_truncnorm():
  function test_iterative_imputer_truncated_normal_posterior (line 702) | def test_iterative_imputer_truncated_normal_posterior():
  function test_iterative_imputer_missing_at_transform (line 736) | def test_iterative_imputer_missing_at_transform(strategy):
  function test_iterative_imputer_transform_stochasticity (line 758) | def test_iterative_imputer_transform_stochasticity():
  function test_iterative_imputer_no_missing (line 808) | def test_iterative_imputer_no_missing():
  function test_iterative_imputer_rank_one (line 822) | def test_iterative_imputer_rank_one():
  function test_iterative_imputer_transform_recovery (line 838) | def test_iterative_imputer_transform_recovery(rank):
  function test_iterative_imputer_additive_matrix (line 862) | def test_iterative_imputer_additive_matrix():
  function test_iterative_imputer_error_param (line 895) | def test_iterative_imputer_error_param(max_iter, tol, error_type, warning):
  function test_iterative_imputer_early_stopping (line 902) | def test_iterative_imputer_early_stopping():
  function test_iterative_imputer_catch_warning (line 932) | def test_iterative_imputer_catch_warning():
  function test_iterative_imputer_min_max_array_like (line 972) | def test_iterative_imputer_min_max_array_like(min_value, max_value, corr...
  function test_iterative_imputer_catch_min_max_error (line 998) | def test_iterative_imputer_catch_min_max_error(min_value, max_value, err...
  function test_iterative_imputer_min_max_array_like_imputation (line 1012) | def test_iterative_imputer_min_max_array_like_imputation(min_max_1, min_...
  function test_iterative_imputer_skip_non_missing (line 1037) | def test_iterative_imputer_skip_non_missing(skip_complete):
  function test_iterative_imputer_dont_set_random_state (line 1057) | def test_iterative_imputer_dont_set_random_state(rs_imputer, rs_estimator):
  function test_missing_indicator_error (line 1104) | def test_missing_indicator_error(X_fit, X_trans, params, msg_err):
  function test_missing_indicator_new (line 1133) | def test_missing_indicator_new(
  function test_missing_indicator_raise_on_sparse_with_missing_0 (line 1187) | def test_missing_indicator_raise_on_sparse_with_missing_0(arr_type):
  function test_missing_indicator_sparse_param (line 1220) | def test_missing_indicator_sparse_param(arr_type, missing_values, param_...
  function test_missing_indicator_string (line 1249) | def test_missing_indicator_string():
  function test_missing_indicator_with_imputer (line 1281) | def test_missing_indicator_with_imputer(X, missing_values, X_trans_exp):
  function test_inconsistent_dtype_X_missing_values (line 1298) | def test_inconsistent_dtype_X_missing_values(
  function test_missing_indicator_no_missing (line 1313) | def test_missing_indicator_no_missing():
  function test_missing_indicator_sparse_no_explicit_zeros (line 1324) | def test_missing_indicator_sparse_no_explicit_zeros():
  function test_imputer_without_indicator (line 1336) | def test_imputer_without_indicator(imputer_constructor):
  function test_simple_imputation_add_indicator_sparse_matrix (line 1354) | def test_simple_imputation_add_indicator_sparse_matrix(arr_type):
  function test_simple_imputation_string_list (line 1376) | def test_simple_imputation_string_list(strategy, expected):
  function test_imputation_order (line 1391) | def test_imputation_order(order, idx_order):
  function test_simple_imputation_inverse_transform (line 1409) | def test_simple_imputation_inverse_transform(missing_value):
  function test_simple_imputation_inverse_transform_exceptions (line 1467) | def test_simple_imputation_inverse_transform_exceptions(missing_value):
  function test_most_frequent (line 1506) | def test_most_frequent(expected, array, dtype, extra_value, n_repeat):
  function test_simple_impute_pd_na (line 1512) | def test_simple_impute_pd_na():
  function test_missing_indicator_feature_names_out (line 1572) | def test_missing_indicator_feature_names_out():

FILE: sklearn/impute/tests/test_knn.py
  function test_knn_imputer_shape (line 14) | def test_knn_imputer_shape(weights, n_neighbors):
  function test_knn_imputer_default_with_invalid_input (line 28) | def test_knn_imputer_default_with_invalid_input(na):
  function test_knn_imputer_removes_all_na_features (line 104) | def test_knn_imputer_removes_all_na_features(na):
  function test_knn_imputer_zero_nan_imputes_the_same (line 125) | def test_knn_imputer_zero_nan_imputes_the_same(na):
  function test_knn_imputer_verify (line 165) | def test_knn_imputer_verify(na):
  function test_knn_imputer_one_n_neighbors (line 239) | def test_knn_imputer_one_n_neighbors(na):
  function test_knn_imputer_all_samples_are_neighbors (line 251) | def test_knn_imputer_all_samples_are_neighbors(na):
  function test_knn_imputer_weight_uniform (line 267) | def test_knn_imputer_weight_uniform(na):
  function test_knn_imputer_weight_distance (line 295) | def test_knn_imputer_weight_distance(na):
  function test_knn_imputer_callable_metric (line 443) | def test_knn_imputer_callable_metric():
  function test_knn_imputer_with_simple_example (line 469) | def test_knn_imputer_with_simple_example(na, working_memory):
  function test_knn_imputer_not_enough_valid_distances (line 510) | def test_knn_imputer_not_enough_valid_distances(na, weights):
  function test_knn_imputer_drops_all_nan_features (line 524) | def test_knn_imputer_drops_all_nan_features(na):
  function test_knn_imputer_distance_weighted_not_enough_neighbors (line 537) | def test_knn_imputer_distance_weighted_not_enough_neighbors(na, working_...
  function test_knn_tags (line 560) | def test_knn_tags(na, allow_nan):

FILE: sklearn/inspection/_partial_dependence.py
  function _grid_from_X (line 38) | def _grid_from_X(X, percentiles, grid_resolution):
  function _partial_dependence_recursion (line 109) | def _partial_dependence_recursion(est, grid, features):
  function _partial_dependence_brute (line 119) | def _partial_dependence_brute(est, grid, features, X, response_method):
  function partial_dependence (line 208) | def partial_dependence(

FILE: sklearn/inspection/_permutation_importance.py
  function _weights_scorer (line 16) | def _weights_scorer(scorer, estimator, X, y, sample_weight):
  function _calculate_permutation_scores (line 22) | def _calculate_permutation_scores(
  function _create_importances_bunch (line 74) | def _create_importances_bunch(baseline_score, permuted_score):
  function permutation_importance (line 103) | def permutation_importance(

FILE: sklearn/inspection/_plot/partial_dependence.py
  function plot_partial_dependence (line 25) | def plot_partial_dependence(
  function _plot_partial_dependence (line 314) | def _plot_partial_dependence(
  class PartialDependenceDisplay (line 508) | class PartialDependenceDisplay:
    method __init__ (line 642) | def __init__(
    method from_estimator (line 666) | def from_estimator(
    method _get_sample_count (line 936) | def _get_sample_count(self, n_samples):
    method _plot_ice_lines (line 946) | def _plot_ice_lines(
    method _plot_average_dependence (line 995) | def _plot_average_dependence(
    method _plot_one_way_partial_dependence (line 1027) | def _plot_one_way_partial_dependence(
    method _plot_two_way_partial_dependence (line 1125) | def _plot_two_way_partial_dependence(
    method plot (line 1205) | def plot(

FILE: sklearn/inspection/_plot/tests/test_plot_partial_dependence.py
  function plot_partial_dependence (line 35) | def plot_partial_dependence(request):
  function diabetes (line 40) | def diabetes():
  function clf_diabetes (line 45) | def clf_diabetes(diabetes):
  function test_plot_partial_dependence_deprecation (line 51) | def test_plot_partial_dependence_deprecation(pyplot, clf_diabetes, diabe...
  function test_plot_partial_dependence (line 59) | def test_plot_partial_dependence(
  function test_plot_partial_dependence_kind (line 147) | def test_plot_partial_dependence_kind(
  function test_plot_partial_dependence_str_features (line 182) | def test_plot_partial_dependence_str_features(
  function test_plot_partial_dependence_custom_axes (line 256) | def test_plot_partial_dependence_custom_axes(
  function test_plot_partial_dependence_passing_numpy_axes (line 300) | def test_plot_partial_dependence_passing_numpy_axes(
  function test_plot_partial_dependence_incorrent_num_axes (line 339) | def test_plot_partial_dependence_incorrent_num_axes(
  function test_plot_partial_dependence_with_same_axes (line 373) | def test_plot_partial_dependence_with_same_axes(
  function test_plot_partial_dependence_feature_name_reuse (line 415) | def test_plot_partial_dependence_feature_name_reuse(
  function test_plot_partial_dependence_multiclass (line 439) | def test_plot_partial_dependence_multiclass(plot_partial_dependence, pyp...
  function test_plot_partial_dependence_multioutput (line 494) | def test_plot_partial_dependence_multioutput(plot_partial_dependence, py...
  function test_plot_partial_dependence_dataframe (line 519) | def test_plot_partial_dependence_dataframe(
  function test_plot_partial_dependence_error (line 615) | def test_plot_partial_dependence_error(
  function test_plot_partial_dependence_multiclass_error (line 637) | def test_plot_partial_dependence_multiclass_error(
  function test_plot_partial_dependence_does_not_override_ylabel (line 648) | def test_plot_partial_dependence_does_not_override_ylabel(
  function test_plot_partial_dependence_subsampling (line 665) | def test_plot_partial_dependence_subsampling(
  function test_partial_dependence_overwrite_labels (line 703) | def test_partial_dependence_overwrite_labels(
  function test_plot_partial_dependence_lines_kw (line 744) | def test_plot_partial_dependence_lines_kw(

FILE: sklearn/inspection/setup.py
  function configuration (line 4) | def configuration(parent_package="", top_path=None):

FILE: sklearn/inspection/tests/test_partial_dependence.py
  function test_output_shape (line 88) | def test_output_shape(Estimator, method, data, grid_resolution, features...
  function test_grid_from_X (line 136) | def test_grid_from_X():
  function test_grid_from_X_error (line 182) | def test_grid_from_X_error(grid_resolution, percentiles, err_msg):
  function test_partial_dependence_helpers (line 199) | def test_partial_dependence_helpers(est, method, target_feature):
  function test_recursion_decision_tree_vs_forest_and_gbdt (line 244) | def test_recursion_decision_tree_vs_forest_and_gbdt(seed):
  function test_recursion_decision_function (line 322) | def test_recursion_decision_function(est, target_feature):
  function test_partial_dependence_easy_target (line 364) | def test_partial_dependence_easy_target(est, power):
  function test_multiclass_multioutput (line 406) | def test_multiclass_multioutput(Estimator):
  class NoPredictProbaNoDecisionFunction (line 422) | class NoPredictProbaNoDecisionFunction(ClassifierMixin, BaseEstimator):
    method fit (line 423) | def fit(self, X, y):
  function test_partial_dependence_error (line 499) | def test_partial_dependence_error(estimator, params, err_msg):
  function test_partial_dependence_slice_error (line 514) | def test_partial_dependence_slice_error(with_dataframe, err_msg):
  function test_partial_dependence_unknown_feature_indices (line 529) | def test_partial_dependence_unknown_feature_indices(estimator, features):
  function test_partial_dependence_unknown_feature_string (line 541) | def test_partial_dependence_unknown_feature_string(estimator):
  function test_partial_dependence_X_list (line 556) | def test_partial_dependence_X_list(estimator):
  function test_warning_recursion_non_constant_init (line 563) | def test_warning_recursion_non_constant_init():
  function test_partial_dependence_sample_weight (line 581) | def test_partial_dependence_sample_weight():
  function test_hist_gbdt_sw_not_supported (line 607) | def test_hist_gbdt_sw_not_supported():
  function test_partial_dependence_pipeline (line 618) | def test_partial_dependence_pipeline():
  function test_partial_dependence_dataframe (line 675) | def test_partial_dependence_dataframe(estimator, preprocessor, features):
  function test_partial_dependence_feature_type (line 729) | def test_partial_dependence_feature_type(features, expected_pd_shape):
  function test_partial_dependence_unfitted (line 758) | def test_partial_dependence_unfitted(estimator):
  function test_kind_average_and_average_of_individual (line 777) | def test_kind_average_and_average_of_individual(Estimator, data):
  function test_warning_for_kind_legacy (line 788) | def test_warning_for_kind_legacy():

FILE: sklearn/inspection/tests/test_permutation_importance.py
  function test_permutation_importance_correlated_feature_regression (line 35) | def test_permutation_importance_correlated_feature_regression(n_jobs, ma...
  function test_permutation_importance_correlated_feature_regression_pandas (line 68) | def test_permutation_importance_correlated_feature_regression_pandas(
  function test_robustness_to_high_cardinality_noisy_feature (line 108) | def test_robustness_to_high_cardinality_noisy_feature(n_jobs, max_sample...
  function test_permutation_importance_mixed_types (line 187) | def test_permutation_importance_mixed_types():
  function test_permutation_importance_mixed_types_pandas (line 217) | def test_permutation_importance_mixed_types_pandas():
  function test_permutation_importance_linear_regresssion (line 241) | def test_permutation_importance_linear_regresssion():
  function test_permutation_importance_equivalence_sequential_parallel (line 260) | def test_permutation_importance_equivalence_sequential_parallel(max_samp...
  function test_permutation_importance_equivalence_array_dataframe (line 302) | def test_permutation_importance_equivalence_array_dataframe(n_jobs, max_...
  function test_permutation_importance_large_memmaped_data (line 371) | def test_permutation_importance_large_memmaped_data(input_type):
  function test_permutation_importance_sample_weight (line 393) | def test_permutation_importance_sample_weight():
  function test_permutation_importance_no_weights_scoring_function (line 456) | def test_permutation_importance_no_weights_scoring_function():
  function test_permutation_importance_multi_metric (line 507) | def test_permutation_importance_multi_metric(list_single_scorer, multi_s...
  function test_permutation_importance_max_samples_error (line 529) | def test_permutation_importance_max_samples_error(max_samples):

FILE: sklearn/isotonic.py
  function check_increasing (line 21) | def check_increasing(x, y):
  function isotonic_regression (line 80) | def isotonic_regression(
  class IsotonicRegression (line 135) | class IsotonicRegression(RegressorMixin, TransformerMixin, BaseEstimator):
    method __init__ (line 229) | def __init__(self, *, y_min=None, y_max=None, increasing=True, out_of_...
    method _check_input_data_shape (line 235) | def _check_input_data_shape(self, X):
    method _build_f (line 243) | def _build_f(self, X, y):
    method _build_y (line 262) | def _build_y(self, X, y, sample_weight, trim_duplicates=True):
    method fit (line 311) | def fit(self, X, y, sample_weight=None):
    method transform (line 360) | def transform(self, T):
    method predict (line 404) | def predict(self, T):
    method __getstate__ (line 419) | def __getstate__(self):
    method __setstate__ (line 426) | def __setstate__(self, state):
    method _more_tags (line 435) | def _more_tags(self):

FILE: sklearn/kernel_approximation.py
  class PolynomialCountSketch (line 31) | class PolynomialCountSketch(BaseEstimator, TransformerMixin):
    method __init__ (line 116) | def __init__(
    method fit (line 125) | def fit(self, X, y=None):
    method transform (line 163) | def transform(self, X):
  class RBFSampler (line 227) | class RBFSampler(TransformerMixin, BaseEstimator):
    method __init__ (line 305) | def __init__(self, *, gamma=1.0, n_components=100, random_state=None):
    method fit (line 310) | def fit(self, X, y=None):
    method transform (line 342) | def transform(self, X):
  class SkewedChi2Sampler (line 366) | class SkewedChi2Sampler(TransformerMixin, BaseEstimator):
    method __init__ (line 439) | def __init__(self, *, skewedness=1.0, n_components=100, random_state=N...
    method fit (line 444) | def fit(self, X, y=None):
    method transform (line 474) | def transform(self, X):
  class AdditiveChi2Sampler (line 505) | class AdditiveChi2Sampler(TransformerMixin, BaseEstimator):
    method __init__ (line 584) | def __init__(self, *, sample_steps=2, sample_interval=None):
    method fit (line 588) | def fit(self, X, y=None):
    method transform (line 626) | def transform(self, X):
    method _transform_dense (line 659) | def _transform_dense(self, X):
    method _transform_sparse (line 684) | def _transform_sparse(self, X):
    method _more_tags (line 714) | def _more_tags(self):
  class Nystroem (line 718) | class Nystroem(TransformerMixin, BaseEstimator):
    method __init__ (line 834) | def __init__(
    method fit (line 856) | def fit(self, X, y=None):
    method transform (line 914) | def transform(self, X):
    method _get_kernel_params (line 944) | def _get_kernel_params(self):
    method _more_tags (line 966) | def _more_tags(self):

FILE: sklearn/kernel_ridge.py
  class KernelRidge (line 16) | class KernelRidge(MultiOutputMixin, RegressorMixin, BaseEstimator):
    method __init__ (line 133) | def __init__(
    method _get_kernel (line 150) | def _get_kernel(self, X, Y=None):
    method _more_tags (line 157) | def _more_tags(self):
    method _pairwise (line 167) | def _pairwise(self):
    method fit (line 170) | def fit(self, X, y, sample_weight=None):
    method predict (line 214) | def predict(self, X):

FILE: sklearn/linear_model/_base.py
  function _deprecate_normalize (line 54) | def _deprecate_normalize(normalize, default, estimator_name):
  function make_dataset (line 161) | def make_dataset(X, y, sample_weight, random_state=None):
  function _preprocess_data (line 213) | def _preprocess_data(
  function _rescale_data (line 313) | def _rescale_data(X, y, sample_weight):
  class LinearModel (line 335) | class LinearModel(BaseEstimator, metaclass=ABCMeta):
    method fit (line 339) | def fit(self, X, y):
    method _decision_function (line 342) | def _decision_function(self, X):
    method predict (line 348) | def predict(self, X):
    method _set_intercept (line 366) | def _set_intercept(self, X_offset, y_offset, X_scale):
    method _more_tags (line 374) | def _more_tags(self):
  class LinearClassifierMixin (line 380) | class LinearClassifierMixin(ClassifierMixin):
    method decision_function (line 386) | def decision_function(self, X):
    method predict (line 411) | def predict(self, X):
    method _predict_proba_lr (line 432) | def _predict_proba_lr(self, X):
  class SparseCoefMixin (line 449) | class SparseCoefMixin:
    method densify (line 455) | def densify(self):
    method sparsify (line 475) | def sparsify(self):
  class LinearRegression (line 507) | class LinearRegression(MultiOutputMixin, RegressorMixin, LinearModel):
    method __init__ (line 615) | def __init__(
    method fit (line 630) | def fit(self, X, y, sample_weight=None):
  function _check_precomputed_gram_matrix (line 729) | def _check_precomputed_gram_matrix(
  function _pre_fit (line 786) | def _pre_fit(

FILE: sklearn/linear_model/_bayes.py
  class BayesianRidge (line 24) | class BayesianRidge(RegressorMixin, LinearModel):
    method __init__ (line 177) | def __init__(
    method fit (line 208) | def fit(self, X, y, sample_weight=None):
    method predict (line 340) | def predict(self, X, return_std=False):
    method _update_coef_ (line 372) | def _update_coef_(
    method _log_marginal_likelihood (line 395) | def _log_marginal_likelihood(
  class ARDRegression (line 432) | class ARDRegression(RegressorMixin, LinearModel):
    method __init__ (line 569) | def __init__(
    method fit (line 598) | def fit(self, X, y):
    method _update_sigma_woodbury (line 719) | def _update_sigma_woodbury(self, X, alpha_, lambda_, keep_lambda):
    method _update_sigma (line 736) | def _update_sigma(self, X, alpha_, lambda_, keep_lambda):
    method predict (line 747) | def predict(self, X, return_std=False):

FILE: sklearn/linear_model/_coordinate_descent.py
  function _set_order (line 37) | def _set_order(X, y, order="C"):
  function _alpha_grid (line 86) | def _alpha_grid(
  function lasso_path (line 193) | def lasso_path(
  function enet_path (line 367) | def enet_path(
  class ElasticNet (line 679) | class ElasticNet(MultiOutputMixin, RegressorMixin, LinearModel):
    method __init__ (line 837) | def __init__(
    method fit (line 866) | def fit(self, X, y, sample_weight=None, check_input=True):
    method sparse_coef_ (line 1082) | def sparse_coef_(self):
    method _decision_function (line 1086) | def _decision_function(self, X):
  class Lasso (line 1109) | class Lasso(ElasticNet):
    method __init__ (line 1246) | def __init__(
  function _path_residuals (line 1281) | def _path_residuals(
  class LinearModelCV (line 1427) | class LinearModelCV(MultiOutputMixin, LinearModel, ABC):
    method __init__ (line 1431) | def __init__(
    method _get_estimator (line 1466) | def _get_estimator(self):
    method _is_multitask (line 1470) | def _is_multitask(self):
    method path (line 1475) | def path(X, y, **kwargs):
    method fit (line 1478) | def fit(self, X, y, sample_weight=None):
    method _more_tags (line 1725) | def _more_tags(self):
  class LassoCV (line 1737) | class LassoCV(RegressorMixin, LinearModelCV):
    method __init__ (line 1909) | def __init__(
    method _get_estimator (line 1946) | def _get_estimator(self):
    method _is_multitask (line 1949) | def _is_multitask(self):
    method _more_tags (line 1952) | def _more_tags(self):
  class ElasticNetCV (line 1956) | class ElasticNetCV(RegressorMixin, LinearModelCV):
    method __init__ (line 2154) | def __init__(
    method _get_estimator (line 2191) | def _get_estimator(self):
    method _is_multitask (line 2194) | def _is_multitask(self):
    method _more_tags (line 2197) | def _more_tags(self):
  class MultiTaskElasticNet (line 2205) | class MultiTaskElasticNet(Lasso):
    method __init__ (line 2341) | def __init__(
    method fit (line 2366) | def fit(self, X, y):
    method _more_tags (line 2461) | def _more_tags(self):
  class MultiTaskLasso (line 2465) | class MultiTaskLasso(MultiTaskElasticNet):
    method __init__ (line 2591) | def __init__(
  class MultiTaskElasticNetCV (line 2616) | class MultiTaskElasticNetCV(RegressorMixin, LinearModelCV):
    method __init__ (line 2801) | def __init__(
    method _get_estimator (line 2834) | def _get_estimator(self):
    method _is_multitask (line 2837) | def _is_multitask(self):
    method _more_tags (line 2840) | def _more_tags(self):
    method fit (line 2845) | def fit(self, X, y):
  class MultiTaskLassoCV (line 2865) | class MultiTaskLassoCV(RegressorMixin, LinearModelCV):
    method __init__ (line 3034) | def __init__(
    method _get_estimator (line 3067) | def _get_estimator(self):
    method _is_multitask (line 3070) | def _is_multitask(self):
    method _more_tags (line 3073) | def _more_tags(self):
    method fit (line 3078) | def fit(self, X, y):

FILE: sklearn/linear_model/_glm/glm.py
  function _safe_lin_pred (line 29) | def _safe_lin_pred(X, coef):
  function _y_pred_deviance_derivative (line 37) | def _y_pred_deviance_derivative(coef, X, y, weights, family, link):
  class GeneralizedLinearRegressor (line 50) | class GeneralizedLinearRegressor(RegressorMixin, BaseEstimator):
    method __init__ (line 129) | def __init__(
    method fit (line 152) | def fit(self, X, y, sample_weight=None):
    method _linear_predictor (line 336) | def _linear_predictor(self, X):
    method predict (line 360) | def predict(self, X):
    method score (line 378) | def score(self, X, y, sample_weight=None):
    method _more_tags (line 419) | def _more_tags(self):
  class PoissonRegressor (line 432) | class PoissonRegressor(GeneralizedLinearRegressor):
    method __init__ (line 515) | def __init__(
    method family (line 538) | def family(self):
    method family (line 544) | def family(self, value):
  class GammaRegressor (line 549) | class GammaRegressor(GeneralizedLinearRegressor):
    method __init__ (line 632) | def __init__(
    method family (line 655) | def family(self):
    method family (line 661) | def family(self, value):
  class TweedieRegressor (line 666) | class TweedieRegressor(GeneralizedLinearRegressor):
    method __init__ (line 778) | def __init__(
    method family (line 803) | def family(self):
    method family (line 813) | def family(self, value):

FILE: sklearn/linear_model/_glm/link.py
  class BaseLink (line 14) | class BaseLink(metaclass=ABCMeta):
    method __call__ (line 18) | def __call__(self, y_pred):
    method derivative (line 31) | def derivative(self, y_pred):
    method inverse (line 41) | def inverse(self, lin_pred):
    method inverse_derivative (line 54) | def inverse_derivative(self, lin_pred):
  class IdentityLink (line 64) | class IdentityLink(BaseLink):
    method __call__ (line 67) | def __call__(self, y_pred):
    method derivative (line 70) | def derivative(self, y_pred):
    method inverse (line 73) | def inverse(self, lin_pred):
    method inverse_derivative (line 76) | def inverse_derivative(self, lin_pred):
  class LogLink (line 80) | class LogLink(BaseLink):
    method __call__ (line 83) | def __call__(self, y_pred):
    method derivative (line 86) | def derivative(self, y_pred):
    method inverse (line 89) | def inverse(self, lin_pred):
    method inverse_derivative (line 92) | def inverse_derivative(self, lin_pred):
  class LogitLink (line 96) | class LogitLink(BaseLink):
    method __call__ (line 99) | def __call__(self, y_pred):
    method derivative (line 102) | def derivative(self, y_pred):
    method inverse (line 105) | def inverse(self, lin_pred):
    method inverse_derivative (line 108) | def inverse_derivative(self, lin_pred):

FILE: sklearn/linear_model/_glm/tests/test_glm.py
  function regression_data (line 30) | def regression_data():
  function test_sample_weights_validation (line 37) | def test_sample_weights_validation():
  function test_glm_family_argument (line 69) | def test_glm_family_argument(name, instance):
  function test_glm_link_argument (line 84) | def test_glm_link_argument(name, instance):
  function test_glm_link_auto (line 105) | def test_glm_link_auto(family, expected_link_class):
  function test_glm_alpha_argument (line 114) | def test_glm_alpha_argument(alpha):
  function test_glm_fit_intercept_argument (line 124) | def test_glm_fit_intercept_argument(fit_intercept):
  function test_glm_solver_argument (line 134) | def test_glm_solver_argument(solver):
  function test_glm_max_iter_argument (line 144) | def test_glm_max_iter_argument(max_iter):
  function test_glm_tol_argument (line 154) | def test_glm_tol_argument(tol):
  function test_glm_warm_start_argument (line 164) | def test_glm_warm_start_argument(warm_start):
  function test_glm_identity_regression (line 174) | def test_glm_identity_regression(fit_intercept):
  function test_glm_sample_weight_consistentcy (line 198) | def test_glm_sample_weight_consistentcy(fit_intercept, alpha, family):
  function test_glm_log_regression (line 258) | def test_glm_log_regression(fit_intercept, family):
  function test_warm_start (line 276) | def test_warm_start(fit_intercept):
  function test_normal_ridge_comparison (line 314) | def test_normal_ridge_comparison(
  function test_poisson_glmnet (line 373) | def test_poisson_glmnet():
  function test_convergence_warning (line 401) | def test_convergence_warning(regression_data):
  function test_poisson_regression_family (line 409) | def test_poisson_regression_family(regression_data):
  function test_gamma_regression_family (line 420) | def test_gamma_regression_family(regression_data):
  function test_tweedie_regression_family (line 431) | def test_tweedie_regression_family(regression_data):
  function test_tags (line 461) | def test_tags(estimator, value):

FILE: sklearn/linear_model/_glm/tests/test_link.py
  function test_link_properties (line 20) | def test_link_properties(Link):
  function test_link_derivative (line 36) | def test_link_derivative(Link):

FILE: sklearn/linear_model/_huber.py
  function _huber_loss_and_gradient (line 16) | def _huber_loss_and_gradient(w, X, y, epsilon, alpha, sample_weight=None):
  class HuberRegressor (line 126) | class HuberRegressor(LinearModel, RegressorMixin, BaseEstimator):
    method __init__ (line 245) | def __init__(
    method fit (line 262) | def fit(self, X, y, sample_weight=None):

FILE: sklearn/linear_model/_least_angle.py
  function lars_path (line 34) | def lars_path(
  function lars_path_gram (line 190) | def lars_path_gram(
  function _lars_path_solver (line 331) | def _lars_path_solver(
  class Lars (line 849) | class Lars(MultiOutputMixin, RegressorMixin, LinearModel):
    method __init__ (line 974) | def __init__(
    method _get_gram (line 1000) | def _get_gram(precompute, X, y):
    method _fit (line 1010) | def _fit(self, X, y, max_iter, alpha, fit_path, normalize, Xy=None):
    method fit (line 1090) | def fit(self, X, y, Xy=None):
  class LassoLars (line 1143) | class LassoLars(Lars):
    method __init__ (line 1298) | def __init__(
  function _check_copy_and_writeable (line 1332) | def _check_copy_and_writeable(array, copy=False):
  function _lars_path_residues (line 1338) | def _lars_path_residues(
  class LarsCV (line 1474) | class LarsCV(Lars):
    method __init__ (line 1620) | def __init__(
    method _more_tags (line 1649) | def _more_tags(self):
    method fit (line 1652) | def fit(self, X, y):
  class LassoLarsCV (line 1755) | class LassoLarsCV(LarsCV):
    method __init__ (line 1927) | def __init__(
  class LassoLarsIC (line 1957) | class LassoLarsIC(LassoLars):
    method __init__ (line 2100) | def __init__(
    method _more_tags (line 2124) | def _more_tags(self):
    method fit (line 2127) | def fit(self, X, y, copy_X=None):

FILE: sklearn/linear_model/_logistic.py
  function _intercept_dot (line 46) | def _intercept_dot(w, X, y):
  function _logistic_loss_and_grad (line 84) | def _logistic_loss_and_grad(w, X, y, alpha, sample_weight=None):
  function _logistic_loss (line 135) | def _logistic_loss(w, X, y, alpha, sample_weight=None):
  function _logistic_grad_hess (line 171) | def _logistic_grad_hess(w, X, y, alpha, sample_weight=None):
  function _multinomial_loss (line 250) | def _multinomial_loss(w, X, Y, alpha, sample_weight):
  function _multinomial_loss_grad (line 306) | def _multinomial_loss_grad(w, X, Y, alpha, sample_weight):
  function _multinomial_grad_hess (line 358) | def _multinomial_grad_hess(w, X, Y, alpha, sample_weight):
  function _check_solver (line 431) | def _check_solver(solver, penalty, dual):
  function _check_multi_class (line 469) | def _check_multi_class(multi_class, solver, n_classes):
  function _logistic_regression_path (line 487) | def _logistic_regression_path(
  function _log_reg_scoring_path (line 902) | def _log_reg_scoring_path(
  class LogisticRegression (line 1120) | class LogisticRegression(LinearClassifierMixin, SparseCoefMixin, BaseEst...
    method __init__ (line 1396) | def __init__(
    method fit (line 1432) | def fit(self, X, y, sample_weight=None):
    method predict_proba (line 1637) | def predict_proba(self, X):
    method predict_log_proba (line 1681) | def predict_log_proba(self, X):
  class LogisticRegressionCV (line 1703) | class LogisticRegressionCV(LogisticRegression, LinearClassifierMixin, Ba...
    method __init__ (line 1971) | def __init__(
    method fit (line 2010) | def fit(self, X, y, sample_weight=None):
    method score (line 2362) | def score(self, X, y, sample_weight=None):
    method _more_tags (line 2386) | def _more_tags(self):

FILE: sklearn/linear_model/_omp.py
  function _cholesky_omp (line 29) | def _cholesky_omp(X, y, n_nonzero_coefs, tol=None, copy_X=True, return_p...
  function _gram_omp (line 145) | def _gram_omp(
  function orthogonal_mp (line 283) | def orthogonal_mp(
  function orthogonal_mp_gram (line 441) | def orthogonal_mp_gram(
  class OrthogonalMatchingPursuit (line 592) | class OrthogonalMatchingPursuit(MultiOutputMixin, RegressorMixin, Linear...
    method __init__ (line 693) | def __init__(
    method fit (line 708) | def fit(self, X, y):
  function _omp_path_residues (line 773) | def _omp_path_residues(
  class OrthogonalMatchingPursuitCV (line 868) | class OrthogonalMatchingPursuitCV(RegressorMixin, LinearModel):
    method __init__ (line 985) | def __init__(
    method fit (line 1004) | def fit(self, X, y):

FILE: sklearn/linear_model/_passive_aggressive.py
  class PassiveAggressiveClassifier (line 9) | class PassiveAggressiveClassifier(BaseSGDClassifier):
    method __init__ (line 175) | def __init__(
    method partial_fit (line 215) | def partial_fit(self, X, y, classes=None):
    method fit (line 267) | def fit(self, X, y, coef_init=None, intercept_init=None):
  class PassiveAggressiveRegressor (line 303) | class PassiveAggressiveRegressor(BaseSGDRegressor):
    method __init__ (line 448) | def __init__(
    method partial_fit (line 486) | def partial_fit(self, X, y):
    method fit (line 517) | def fit(self, X, y, coef_init=None, intercept_init=None):

FILE: sklearn/linear_model/_perceptron.py
  class Perceptron (line 7) | class Perceptron(BaseSGDClassifier):
    method __init__ (line 167) | def __init__(

FILE: sklearn/linear_model/_quantile.py
  class QuantileRegressor (line 16) | class QuantileRegressor(LinearModel, RegressorMixin, BaseEstimator):
    method __init__ (line 95) | def __init__(
    method fit (line 110) | def fit(self, X, y, sample_weight=None):

FILE: sklearn/linear_model/_ransac.py
  function _dynamic_max_trials (line 22) | def _dynamic_max_trials(n_inliers, n_samples, min_samples, probability):
  class RANSACRegressor (line 56) | class RANSACRegressor(
    method __init__ (line 242) | def __init__(
    method fit (line 272) | def fit(self, X, y, sample_weight=None):
    method predict (line 561) | def predict(self, X):
    method score (line 585) | def score(self, X, y):
    method _more_tags (line 612) | def _more_tags(self):

FILE: sklearn/linear_model/_ridge.py
  function _solve_sparse_cg (line 40) | def _solve_sparse_cg(
  function _solve_lsqr (line 126) | def _solve_lsqr(X, y, alpha, max_iter=None, tol=1e-3):
  function _solve_cholesky (line 145) | def _solve_cholesky(X, y, alpha):
  function _solve_cholesky_kernel (line 167) | def _solve_cholesky_kernel(K, y, alpha, sample_weight=None, copy=False):
  function _solve_svd (line 229) | def _solve_svd(X, y, alpha):
  function _solve_lbfgs (line 240) | def _solve_lbfgs(
  function _get_valid_accept_sparse (line 298) | def _get_valid_accept_sparse(is_X_sparse, solver):
  function ridge_regression (line 305) | def ridge_regression(
  function _ridge_regression (line 470) | def _ridge_regression(
  class _BaseRidge (line 673) | class _BaseRidge(LinearModel, metaclass=ABCMeta):
    method __init__ (line 675) | def __init__(
    method fit (line 698) | def fit(self, X, y, sample_weight=None):
  class Ridge (line 802) | class Ridge(MultiOutputMixin, RegressorMixin, _BaseRidge):
    method __init__ (line 957) | def __init__(
    method fit (line 982) | def fit(self, X, y, sample_weight=None):
  class _RidgeClassifierMixin (line 1014) | class _RidgeClassifierMixin(LinearClassifierMixin):
    method _prepare_data (line 1015) | def _prepare_data(self, X, y, sample_weight, solver):
    method predict (line 1066) | def predict(self, X):
    method classes_ (line 1092) | def classes_(self):
    method _more_tags (line 1096) | def _more_tags(self):
  class RidgeClassifier (line 1100) | class RidgeClassifier(_RidgeClassifierMixin, _BaseRidge):
    method __init__ (line 1250) | def __init__(
    method fit (line 1277) | def fit(self, X, y, sample_weight=None):
  function _check_gcv_mode (line 1306) | def _check_gcv_mode(X, gcv_mode):
  function _find_smallest_angle (line 1323) | def _find_smallest_angle(query, vectors):
  class _X_CenterStackOp (line 1341) | class _X_CenterStackOp(sparse.linalg.LinearOperator):
    method __init__ (line 1348) | def __init__(self, X, X_mean, sqrt_sw):
    method _matvec (line 1355) | def _matvec(self, v):
    method _matmat (line 1363) | def _matmat(self, v):
    method _transpose (line 1370) | def _transpose(self):
  class _XT_CenterStackOp (line 1374) | class _XT_CenterStackOp(sparse.linalg.LinearOperator):
    method __init__ (line 1381) | def __init__(self, X, X_mean, sqrt_sw):
    method _matvec (line 1388) | def _matvec(self, v):
    method _matmat (line 1398) | def _matmat(self, v):
  class _IdentityRegressor (line 1408) | class _IdentityRegressor:
    method decision_function (line 1411) | def decision_function(self, y_predict):
    method predict (line 1414) | def predict(self, y_predict):
  class _IdentityClassifier (line 1418) | class _IdentityClassifier(LinearClassifierMixin):
    method __init__ (line 1425) | def __init__(self, classes):
    method decision_function (line 1428) | def decision_function(self, y_predict):
  class _RidgeGCV (line 1432) | class _RidgeGCV(LinearModel):
    method __init__ (line 1473) | def __init__(
    method _decomp_diag (line 1497) | def _decomp_diag(v_prime, Q):
    method _diag_dot (line 1502) | def _diag_dot(D, B):
    method _compute_gram (line 1509) | def _compute_gram(self, X, sqrt_sw):
    method _compute_covariance (line 1561) | def _compute_covariance(self, X, sqrt_sw):
    method _sparse_multidot_diag (line 1609) | def _sparse_multidot_diag(self, X, A, X_mean, sqrt_sw):
    method _eigen_decompose_gram (line 1646) | def _eigen_decompose_gram(self, X, y, sqrt_sw):
    method _solve_eigen_gram (line 1660) | def _solve_eigen_gram(self, alpha, y, sqrt_sw, X_mean, eigvals, Q, QT_y):
    method _eigen_decompose_covariance (line 1683) | def _eigen_decompose_covariance(self, X, y, sqrt_sw):
    method _solve_eigen_covariance_no_intercept (line 1708) | def _solve_eigen_covariance_no_intercept(
    method _solve_eigen_covariance_intercept (line 1726) | def _solve_eigen_covariance_intercept(
    method _solve_eigen_covariance (line 1757) | def _solve_eigen_covariance(self, alpha, y, sqrt_sw, X_mean, eigvals, ...
    method _svd_decompose_design_matrix (line 1771) | def _svd_decompose_design_matrix(self, X, y, sqrt_sw):
    method _solve_svd_design_matrix (line 1785) | def _solve_svd_design_matrix(self, alpha, y, sqrt_sw, X_mean, singvals...
    method fit (line 1805) | def fit(self, X, y, sample_weight=None):
  class _BaseRidgeCV (line 1969) | class _BaseRidgeCV(LinearModel):
    method __init__ (line 1970) | def __init__(
    method fit (line 1991) | def fit(self, X, y, sample_weight=None):
  class RidgeCV (line 2069) | class RidgeCV(MultiOutputMixin, RegressorMixin, _BaseRidgeCV):
  class RidgeClassifierCV (line 2213) | class RidgeClassifierCV(_RidgeClassifierMixin, _BaseRidgeCV):
    method __init__ (line 2343) | def __init__(
    method fit (line 2364) | def fit(self, X, y, sample_weight=None):
    method _more_tags (line 2400) | def _more_tags(self):

FILE: sklearn/linear_model/_sag.py
  function get_auto_step_size (line 19) | def get_auto_step_size(
  function sag_solver (line 89) | def sag_solver(

FILE: sklearn/linear_model/_stochastic_gradient.py
  class _ValidationScoreCallback (line 58) | class _ValidationScoreCallback:
    method __init__ (line 61) | def __init__(self, estimator, X_val, y_val, sample_weight_val, classes...
    method __call__ (line 70) | def __call__(self, coef, intercept):
  class BaseSGD (line 77) | class BaseSGD(SparseCoefMixin, BaseEstimator, metaclass=ABCMeta):
    method __init__ (line 80) | def __init__(
    method fit (line 126) | def fit(self, X, y):
    method _validate_params (line 129) | def _validate_params(self, for_partial_fit=False):
    method _get_loss_function (line 172) | def _get_loss_function(self, loss):
    method _get_learning_rate_type (line 183) | def _get_learning_rate_type(self, learning_rate):
    method _get_penalty_type (line 191) | def _get_penalty_type(self, penalty):
    method _allocate_parameter_mem (line 198) | def _allocate_parameter_mem(
    method _make_validation_split (line 265) | def _make_validation_split(self, y):
    method _make_validation_score_cb (line 309) | def _make_validation_score_cb(
  function _prepare_fit_binary (line 324) | def _prepare_fit_binary(est, y, i):
  function fit_binary (line 356) | def fit_binary(
  class BaseSGDClassifier (line 490) | class BaseSGDClassifier(LinearClassifierMixin, BaseSGD, metaclass=ABCMeta):
    method __init__ (line 507) | def __init__(
    method _partial_fit (line 557) | def _partial_fit(
    method _fit (line 637) | def _fit(
    method _fit_binary (line 704) | def _fit_binary(self, X, y, alpha, C, sample_weight, learning_rate, ma...
    method _fit_multiclass (line 738) | def _fit_multiclass(self, X, y, alpha, C, learning_rate, sample_weight...
    method partial_fit (line 795) | def partial_fit(self, X, y, classes=None, sample_weight=None):
    method fit (line 855) | def fit(self, X, y, coef_init=None, intercept_init=None, sample_weight...
  class SGDClassifier (line 896) | class SGDClassifier(BaseSGDClassifier):
    method __init__ (line 1148) | def __init__(
    method _check_proba (line 1197) | def _check_proba(self):
    method predict_proba (line 1205) | def predict_proba(self, X):
    method predict_log_proba (line 1287) | def predict_log_proba(self, X):
    method _more_tags (line 1311) | def _more_tags(self):
  class BaseSGDRegressor (line 1321) | class BaseSGDRegressor(RegressorMixin, BaseSGD):
    method __init__ (line 1333) | def __init__(
    method _partial_fit (line 1378) | def _partial_fit(
    method partial_fit (line 1421) | def partial_fit(self, X, y, sample_weight=None):
    method _fit (line 1460) | def _fit(
    method fit (line 1512) | def fit(self, X, y, coef_init=None, intercept_init=None, sample_weight...
    method _decision_function (line 1549) | def _decision_function(self, X):
    method predict (line 1568) | def predict(self, X):
    method _fit_regressor (line 1583) | def _fit_regressor(
  class SGDRegressor (line 1668) | class SGDRegressor(BaseSGDRegressor):
    method __init__ (line 1888) | def __init__(
    method _more_tags (line 1933) | def _more_tags(self):
  class SGDOneClassSVM (line 1943) | class SGDOneClassSVM(BaseSGD, OutlierMixin):
    method __init__ (line 2085) | def __init__(
    method _validate_params (line 2126) | def _validate_params(self, for_partial_fit=False):
    method _fit_one_class (line 2133) | def _fit_one_class(self, X, alpha, C, sample_weight, learning_rate, ma...
    method _partial_fit (line 2229) | def _partial_fit(
    method partial_fit (line 2288) | def partial_fit(self, X, y=None, sample_weight=None):
    method _fit (line 2323) | def _fit(
    method fit (line 2374) | def fit(self, X, y=None, coef_init=None, offset_init=None, sample_weig...
    method decision_function (line 2421) | def decision_function(self, X):
    method score_samples (line 2445) | def score_samples(self, X):
    method predict (line 2461) | def predict(self, X):
    method _more_tags (line 2478) | def _more_tags(self):

FILE: sklearn/linear_model/_theil_sen.py
  function _modified_weiszfeld_step (line 29) | def _modified_weiszfeld_step(X, x_old):
  function _spatial_median (line 80) | def _spatial_median(X, max_iter=300, tol=1.0e-3):
  function _breakdown_point (line 136) | def _breakdown_point(n_samples, n_subsamples):
  function _lstsq (line 163) | def _lstsq(X, y, indices, fit_intercept):
  class TheilSenRegressor (line 207) | class TheilSenRegressor(RegressorMixin, LinearModel):
    method __init__ (line 323) | def __init__(
    method _check_subparams (line 346) | def _check_subparams(self, n_samples, n_features):
    method fit (line 390) | def fit(self, X, y):

FILE: sklearn/linear_model/setup.py
  function configuration (line 7) | def configuration(parent_package="", top_path=None):

FILE: sklearn/linear_model/tests/test_base.py
  function test_linear_regression (line 34) | def test_linear_regression():
  function test_linear_regression_sample_weights (line 58) | def test_linear_regression_sample_weights():
  function test_raises_value_error_if_positive_and_sparse (line 99) | def test_raises_value_error_if_positive_and_sparse():
  function test_raises_value_error_if_sample_weights_greater_than_1d (line 111) | def test_raises_value_error_if_sample_weights_greater_than_1d():
  function test_fit_intercept (line 132) | def test_fit_intercept():
  function test_error_on_wrong_normalize (line 151) | def test_error_on_wrong_normalize():
  function test_deprecate_normalize (line 162) | def test_deprecate_normalize(normalize, default):
  function test_linear_regression_sparse (line 200) | def test_linear_regression_sparse(random_state=0):
  function test_linear_regression_sparse_equal_dense (line 220) | def test_linear_regression_sparse_equal_dense(normalize, fit_intercept):
  function test_linear_regression_multiple_outcome (line 238) | def test_linear_regression_multiple_outcome(random_state=0):
  function test_linear_regression_sparse_multiple_outcome (line 254) | def test_linear_regression_sparse_multiple_outcome(random_state=0):
  function test_linear_regression_positive (line 271) | def test_linear_regression_positive():
  function test_linear_regression_positive_multiple_outcome (line 294) | def test_linear_regression_positive_multiple_outcome(random_state=0):
  function test_linear_regression_positive_vs_nonpositive (line 311) | def test_linear_regression_positive_vs_nonpositive():
  function test_linear_regression_positive_vs_nonpositive_when_positive (line 323) | def test_linear_regression_positive_vs_nonpositive_when_positive():
  function test_linear_regression_pd_sparse_dataframe_warning (line 339) | def test_linear_regression_pd_sparse_dataframe_warning():
  function test_preprocess_data (line 370) | def test_preprocess_data():
  function test_preprocess_data_multioutput (line 407) | def test_preprocess_data_multioutput():
  function test_preprocess_data_weighted (line 435) | def test_preprocess_data_weighted(is_sparse):
  function test_sparse_preprocess_data_with_return_mean (line 540) | def test_sparse_preprocess_data_with_return_mean():
  function test_csr_preprocess_data (line 578) | def test_csr_preprocess_data():
  function test_preprocess_copy_data_no_checks (line 589) | def test_preprocess_copy_data_no_checks(is_sparse, to_copy):
  function test_dtype_preprocess_data (line 608) | def test_dtype_preprocess_data():
  function test_rescale_data_dense (line 691) | def test_rescale_data_dense(n_targets):
  function test_fused_types_make_dataset (line 711) | def test_fused_types_make_dataset():

FILE: sklearn/linear_model/tests/test_bayes.py
  function test_n_iter (line 25) | def test_n_iter():
  function test_bayesian_ridge_scores (line 35) | def test_bayesian_ridge_scores():
  function test_bayesian_ridge_score_values (line 45) | def test_bayesian_ridge_score_values():
  function test_bayesian_ridge_parameter (line 96) | def test_bayesian_ridge_parameter():
  function test_bayesian_sample_weights (line 109) | def test_bayesian_sample_weights():
  function test_toy_bayesian_ridge_object (line 125) | def test_toy_bayesian_ridge_object():
  function test_bayesian_initial_params (line 137) | def test_bayesian_initial_params():
  function test_prediction_bayesian_ridge_ard_with_constant_input (line 150) | def test_prediction_bayesian_ridge_ard_with_constant_input():
  function test_std_bayesian_ridge_ard_with_constant_input (line 166) | def test_std_bayesian_ridge_ard_with_constant_input():
  function test_update_of_sigma_in_ard (line 183) | def test_update_of_sigma_in_ard():
  function test_toy_ard_object (line 197) | def test_toy_ard_object():
  function test_ard_accuracy_on_easy_problem (line 211) | def test_ard_accuracy_on_easy_problem(seed, n_samples, n_features):
  function test_return_std (line 224) | def test_return_std():
  function test_update_sigma (line 257) | def test_update_sigma(seed):
  function test_ard_regression_predict_normalize_true (line 283) | def test_ard_regression_predict_normalize_true():

FILE: sklearn/linear_model/tests/test_common.py
  function test_linear_model_normalize_deprecation_message (line 44) | def test_linear_model_normalize_deprecation_message(

FILE: sklearn/linear_model/tests/test_coordinate_descent.py
  function test_assure_warning_when_normalize (line 89) | def test_assure_warning_when_normalize(CoordinateDescentModel, normalize...
  function test_l1_ratio_param_invalid (line 110) | def test_l1_ratio_param_invalid(l1_ratio):
  function test_set_order_dense (line 124) | def test_set_order_dense(order, input_order):
  function test_set_order_sparse (line 143) | def test_set_order_sparse(order, input_order):
  function test_lasso_zero (line 159) | def test_lasso_zero():
  function test_lasso_toy (line 170) | def test_lasso_toy():
  function test_enet_toy (line 208) | def test_enet_toy():
  function test_lasso_dual_gap (line 255) | def test_lasso_dual_gap():
  function build_dataset (line 273) | def build_dataset(n_samples=50, n_features=200, n_informative_features=1...
  function test_lasso_cv (line 291) | def test_lasso_cv():
  function test_lasso_cv_with_some_model_selection (line 323) | def test_lasso_cv_with_some_model_selection():
  function test_lasso_cv_positive_constraint (line 335) | def test_lasso_cv_positive_constraint():
  function _scale_alpha_inplace (line 352) | def _scale_alpha_inplace(estimator, n_samples):
  function test_model_pipeline_same_as_normalize_true (line 410) | def test_model_pipeline_same_as_normalize_true(LinearModel, params):
  function test_linear_model_sample_weights_normalize_in_pipeline (line 481) | def test_linear_model_sample_weights_normalize_in_pipeline(
  function test_model_pipeline_same_dense_and_sparse (line 572) | def test_model_pipeline_same_dense_and_sparse(LinearModel, params):
  function test_lasso_path_return_models_vs_new_return_gives_same_coefficients (line 609) | def test_lasso_path_return_models_vs_new_return_gives_same_coefficients():
  function test_enet_path (line 634) | def test_enet_path():
  function test_path_parameters (line 698) | def test_path_parameters():
  function test_warm_start (line 709) | def test_warm_start():
  function test_lasso_alpha_warning (line 720) | def test_lasso_alpha_warning():
  function test_lasso_positive_constraint (line 734) | def test_lasso_positive_constraint():
  function test_enet_positive_constraint (line 747) | def test_enet_positive_constraint():
  function test_enet_cv_positive_constraint (line 756) | def test_enet_cv_positive_constraint():
  function test_uniform_targets (line 775) | def test_uniform_targets():
  function test_multi_task_lasso_and_enet (line 806) | def test_multi_task_lasso_and_enet():
  function test_lasso_readonly_data (line 827) | def test_lasso_readonly_data():
  function test_multi_task_lasso_readonly_data (line 840) | def test_multi_task_lasso_readonly_data():
  function test_enet_multitarget (line 850) | def test_enet_multitarget():
  function test_multioutput_enetcv_error (line 870) | def test_multioutput_enetcv_error():
  function test_multitask_enet_and_lasso_cv (line 879) | def test_multitask_enet_and_lasso_cv():
  function test_1d_multioutput_enet_and_multitask_enet_cv (line 906) | def test_1d_multioutput_enet_and_multitask_enet_cv():
  function test_1d_multioutput_lasso_and_multitask_lasso_cv (line 919) | def test_1d_multioutput_lasso_and_multitask_lasso_cv():
  function test_sparse_input_dtype_enet_and_lassocv (line 931) | def test_sparse_input_dtype_enet_and_lassocv():
  function test_precompute_invalid_argument (line 948) | def test_precompute_invalid_argument():
  function test_elasticnet_precompute_incorrect_gram (line 965) | def test_elasticnet_precompute_incorrect_gram():
  function test_elasticnet_precompute_gram_weighted_samples (line 982) | def test_elasticnet_precompute_gram_weighted_samples():
  function test_warm_start_convergence (line 1004) | def test_warm_start_convergence():
  function test_warm_start_convergence_with_regularizer_decrement (line 1026) | def test_warm_start_convergence_with_regularizer_decrement():
  function test_random_descent (line 1049) | def test_random_descent():
  function test_enet_path_positive (line 1094) | def test_enet_path_positive():
  function test_sparse_dense_descent_paths (line 1112) | def test_sparse_dense_descent_paths():
  function test_path_unknown_parameter (line 1123) | def test_path_unknown_parameter(path_func):
  function test_check_input_false (line 1132) | def test_check_input_false():
  function test_enet_copy_X_True (line 1152) | def test_enet_copy_X_True(check_input):
  function test_enet_copy_X_False_check_input_False (line 1163) | def test_enet_copy_X_False_check_input_False():
  function test_overrided_gram_matrix (line 1175) | def test_overrided_gram_matrix():
  function test_lasso_non_float_y (line 1189) | def test_lasso_non_float_y(model):
  function test_enet_float_precision (line 1203) | def test_enet_float_precision():
  function test_enet_l1_ratio (line 1266) | def test_enet_l1_ratio():
  function test_coef_shape_not_zero (line 1301) | def test_coef_shape_not_zero():
  function test_warm_start_multitask_lasso (line 1307) | def test_warm_start_multitask_lasso():
  function test_enet_coordinate_descent (line 1328) | def test_enet_coordinate_descent(klass, n_classes, kwargs):
  function test_convergence_warnings (line 1345) | def test_convergence_warnings():
  function test_sparse_input_convergence_warning (line 1361) | def test_sparse_input_convergence_warning():
  function test_lassoCV_does_not_set_precompute (line 1382) | def test_lassoCV_does_not_set_precompute(monkeypatch, precompute, inner_...
  function test_multi_task_lasso_cv_dtype (line 1399) | def test_multi_task_lasso_cv_dtype():
  function test_enet_sample_weight_consistency (line 1413) | def test_enet_sample_weight_consistency(fit_intercept, alpha, normalize,...
  function test_enet_sample_weight_sparse (line 1481) | def test_enet_sample_weight_sparse(estimator):
  function test_enet_cv_sample_weight_correctness (line 1493) | def test_enet_cv_sample_weight_correctness(fit_intercept):
  function test_enet_cv_grid_search (line 1540) | def test_enet_cv_grid_search(sample_weight):
  function test_enet_cv_sample_weight_consistency (line 1577) | def test_enet_cv_sample_weight_consistency(fit_intercept, l1_ratio, prec...
  function test_enet_cv_sample_weight_sparse (line 1624) | def test_enet_cv_sample_weight_sparse(estimator):
  function test_linear_models_cv_fit_for_all_backends (line 1639) | def test_linear_models_cv_fit_for_all_backends(backend, estimator):
  function test_enet_sample_weight_does_not_overwrite_sample_weight (line 1656) | def test_enet_sample_weight_does_not_overwrite_sample_weight(check_input):
  function test_enet_ridge_consistency (line 1678) | def test_enet_ridge_consistency(normalize, ridge_alpha):
  function test_sample_weight_invariance (line 1722) | def test_sample_weight_invariance(estimator):

FILE: sklearn/linear_model/tests/test_huber.py
  function make_regression_with_outliers (line 16) | def make_regression_with_outliers(n_samples=50, n_features=20):
  function test_huber_equals_lr_for_high_epsilon (line 30) | def test_huber_equals_lr_for_high_epsilon():
  function test_huber_max_iter (line 41) | def test_huber_max_iter():
  function test_huber_gradient (line 48) | def test_huber_gradient():
  function test_huber_sample_weights (line 72) | def test_huber_sample_weights():
  function test_huber_sparse (line 112) | def test_huber_sparse():
  function test_huber_scaling_invariant (line 124) | def test_huber_scaling_invariant():
  function test_huber_and_sgd_same_results (line 141) | def test_huber_and_sgd_same_results():
  function test_huber_warm_start (line 169) | def test_huber_warm_start():
  function test_huber_better_r2_score (line 184) | def test_huber_better_r2_score():
  function test_huber_bool (line 207) | def test_huber_bool():

FILE: sklearn/linear_model/tests/test_least_angle.py
  function test_assure_warning_when_normalize (line 40) | def test_assure_warning_when_normalize(LeastAngleModel, normalize, n_war...
  function test_simple (line 57) | def test_simple():
  function test_simple_precomputed (line 87) | def test_simple_precomputed():
  function _assert_same_lars_path_result (line 105) | def _assert_same_lars_path_result(output1, output2):
  function test_lars_path_gram_equivalent (line 113) | def test_lars_path_gram_equivalent(method, return_path):
  function test_x_none_gram_none_raises_value_error (line 122) | def test_x_none_gram_none_raises_value_error():
  function test_all_precomputed (line 129) | def test_all_precomputed():
  function test_lars_lstsq (line 144) | def test_lars_lstsq():
  function test_lasso_gives_lstsq_solution (line 158) | def test_lasso_gives_lstsq_solution():
  function test_collinearity (line 166) | def test_collinearity():
  function test_no_path (line 195) | def test_no_path():
  function test_no_path_precomputed (line 204) | def test_no_path_precomputed():
  function test_no_path_all_precomputed (line 215) | def test_no_path_all_precomputed():
  function test_lars_precompute (line 236) | def test_lars_precompute(classifier):
  function test_singular_matrix (line 248) | def test_singular_matrix():
  function test_rank_deficient_design (line 257) | def test_rank_deficient_design():
  function test_lasso_lars_vs_lasso_cd (line 279) | def test_lasso_lars_vs_lasso_cd():
  function test_lasso_lars_vs_lasso_cd_early_stopping (line 317) | def test_lasso_lars_vs_lasso_cd_early_stopping():
  function test_lasso_lars_path_length (line 351) | def test_lasso_lars_path_length():
  function test_lasso_lars_vs_lasso_cd_ill_conditioned (line 362) | def test_lasso_lars_vs_lasso_cd_ill_conditioned():
  function test_lasso_lars_vs_lasso_cd_ill_conditioned2 (line 392) | def test_lasso_lars_vs_lasso_cd_ill_conditioned2():
  function test_lars_add_features (line 423) | def test_lars_add_features():
  function test_lars_n_nonzero_coefs (line 434) | def test_lars_n_nonzero_coefs(verbose=False):
  function test_multitarget (line 445) | def test_multitarget():
  function test_lars_cv (line 477) | def test_lars_cv():
  function test_lars_cv_max_iter (line 494) | def test_lars_cv_max_iter(recwarn):
  function test_lasso_lars_ic (line 517) | def test_lasso_lars_ic():
  function test_lars_path_readonly_data (line 542) | def test_lars_path_readonly_data():
  function test_lars_path_positive_constraint (line 553) | def test_lars_path_positive_constraint():
  function test_estimatorclasses_positive_constraint (line 593) | def test_estimatorclasses_positive_constraint():
  function test_lasso_lars_vs_lasso_cd_positive (line 615) | def test_lasso_lars_vs_lasso_cd_positive():
  function test_lasso_lars_vs_R_implementation (line 668) | def test_lasso_lars_vs_R_implementation():
  function test_lasso_lars_copyX_behaviour (line 814) | def test_lasso_lars_copyX_behaviour(copy_X):
  function test_lasso_lars_fit_copyX_behaviour (line 831) | def test_lasso_lars_fit_copyX_behaviour(copy_X):
  function test_lars_with_jitter (line 847) | def test_lars_with_jitter(est):
  function test_X_none_gram_not_none (line 867) | def test_X_none_gram_not_none():
  function test_copy_X_with_auto_gram (line 872) | def test_copy_X_with_auto_gram():
  function test_lars_dtype_match (line 898) | def test_lars_dtype_match(LARS, has_coef_path, args, dtype):
  function test_lars_numeric_consistency (line 924) | def test_lars_numeric_consistency(LARS, has_coef_path, args):

FILE: sklearn/linear_model/tests/test_logistic.py
  function check_predictions (line 47) | def check_predictions(clf, X, y):
  function test_predict_2_classes (line 65) | def test_predict_2_classes():
  function test_error (line 78) | def test_error():
  function test_logistic_cv_mock_scorer (line 110) | def test_logistic_cv_mock_scorer():
  function test_logistic_cv_score_does_not_warn_by_default (line 142) | def test_logistic_cv_score_does_not_warn_by_default():
  function test_lr_liblinear_warning (line 152) | def test_lr_liblinear_warning():
  function test_predict_3_classes (line 166) | def test_predict_3_classes():
  function test_predict_iris (line 171) | def test_predict_iris():
  function test_multinomial_validation (line 211) | def test_multinomial_validation(solver):
  function test_check_solver_option (line 219) | def test_check_solver_option(LR):
  function test_multinomial_binary (line 272) | def test_multinomial_binary(solver):
  function test_multinomial_binary_probabilities (line 294) | def test_multinomial_binary_probabilities():
  function test_sparsify (line 310) | def test_sparsify():
  function test_inconsistent_input (line 333) | def test_inconsistent_input():
  function test_write_parameters (line 353) | def test_write_parameters():
  function test_nan (line 362) | def test_nan():
  function test_consistency_path (line 373) | def test_consistency_path():
  function test_logistic_regression_path_convergence_fail (line 439) | def test_logistic_regression_path_convergence_fail():
  function test_liblinear_dual_random_state (line 464) | def test_liblinear_dual_random_state():
  function test_logistic_loss_and_grad (line 503) | def test_logistic_loss_and_grad():
  function test_logistic_grad_hess (line 531) | def test_logistic_grad_hess():
  function test_logistic_cv (line 579) | def test_logistic_cv():
  function test_logistic_cv_multinomial_score (line 623) | def test_logistic_cv_multinomial_score(scoring, multiclass_agg_list):
  function test_multinomial_logistic_regression_string_inputs (line 648) | def test_multinomial_logistic_regression_string_inputs():
  function test_logistic_cv_sparse (line 689) | def test_logistic_cv_sparse():
  function test_intercept_logistic_helper (line 703) | def test_intercept_logistic_helper():
  function test_ovr_multinomial_iris (line 737) | def test_ovr_multinomial_iris():
  function test_logistic_regression_solvers (line 800) | def test_logistic_regression_solvers():
  function test_logistic_regression_solvers_multiclass (line 826) | def test_logistic_regression_solvers_multiclass():
  function test_logistic_regressioncv_class_weights (line 854) | def test_logistic_regressioncv_class_weights():
  function test_logistic_regression_sample_weights (line 920) | def test_logistic_regression_sample_weights():
  function _compute_class_weight_dictionary (line 1012) | def _compute_class_weight_dictionary(y):
  function test_logistic_regression_class_weights (line 1020) | def test_logistic_regression_class_weights():
  function test_logistic_regression_multinomial (line 1056) | def test_logistic_regression_multinomial():
  function test_multinomial_grad_hess (line 1119) | def test_multinomial_grad_hess():
  function test_liblinear_decision_function_zero (line 1154) | def test_liblinear_decision_function_zero():
  function test_liblinear_logregcv_sparse (line 1169) | def test_liblinear_logregcv_sparse():
  function test_saga_sparse (line 1177) | def test_saga_sparse():
  function test_logreg_intercept_scaling (line 1185) | def test_logreg_intercept_scaling():
  function test_logreg_intercept_scaling_zero (line 1202) | def test_logreg_intercept_scaling_zero():
  function test_logreg_l1 (line 1210) | def test_logreg_l1():
  function test_logreg_l1_sparse_data (line 1248) | def test_logreg_l1_sparse_data():
  function test_logistic_regression_cv_refit (line 1303) | def test_logistic_regression_cv_refit(random_seed, penalty):
  function test_logreg_predict_proba_multinomial (line 1327) | def test_logreg_predict_proba_multinomial():
  function test_max_iter (line 1367) | def test_max_iter(max_iter, multi_class, solver, message):
  function test_n_iter (line 1389) | def test_n_iter(solver):
  function test_warm_start (line 1450) | def test_warm_start(solver, warm_start, fit_intercept, multi_class):
  function test_saga_vs_liblinear (line 1482) | def test_saga_vs_liblinear():
  function test_dtype_match (line 1532) | def test_dtype_match(solver, multi_class, fit_intercept):
  function test_warm_start_converge_LR (line 1604) | def test_warm_start_converge_LR():
  function test_elastic_net_coeffs (line 1625) | def test_elastic_net_coeffs():
  function test_elastic_net_l1_l2_equivalence (line 1649) | def test_elastic_net_l1_l2_equivalence(C, penalty, l1_ratio):
  function test_elastic_net_vs_l1_l2 (line 1667) | def test_elastic_net_vs_l1_l2(C):
  function test_LogisticRegression_elastic_net_objective (line 1693) | def test_LogisticRegression_elastic_net_objective(C, l1_ratio):
  function test_LogisticRegressionCV_GridSearchCV_elastic_net (line 1735) | def test_LogisticRegressionCV_GridSearchCV_elastic_net(multi_class):
  function test_LogisticRegressionCV_GridSearchCV_elastic_net_ovr (line 1775) | def test_LogisticRegressionCV_GridSearchCV_elastic_net_ovr():
  function test_LogisticRegressionCV_no_refit (line 1817) | def test_LogisticRegressionCV_no_refit(penalty, multi_class):
  function test_LogisticRegressionCV_elasticnet_attribute_shapes (line 1851) | def test_LogisticRegressionCV_elasticnet_attribute_shapes():
  function test_l1_ratio_param (line 1894) | def test_l1_ratio_param(l1_ratio):
  function test_l1_ratios_param (line 1914) | def test_l1_ratios_param(l1_ratios):
  function test_elastic_net_versus_sgd (line 1940) | def test_elastic_net_versus_sgd(C, l1_ratio):
  function test_logistic_regression_path_coefs_multinomial (line 1980) | def test_logistic_regression_path_coefs_multinomial():
  function test_logistic_regression_multi_class_auto (line 2021) | def test_logistic_regression_multi_class_auto(est, solver):
  function test_penalty_none (line 2063) | def test_penalty_none(solver):
  function test_logisticregression_liblinear_sample_weight (line 2097) | def test_logisticregression_liblinear_sample_weight(params):
  function test_scores_attribute_layout_elasticnet (line 2142) | def test_scores_attribute_layout_elasticnet():
  function test_multinomial_identifiability_on_iris (line 2183) | def test_multinomial_identifiability_on_iris(fit_intercept):
  function test_sample_weight_not_modified (line 2227) | def test_sample_weight_not_modified(multi_class, class_weight):
  function test_large_sparse_matrix (line 2243) | def test_large_sparse_matrix(solver):

FILE: sklearn/linear_model/tests/test_omp.py
  function test_assure_warning_when_normalize (line 45) | def test_assure_warning_when_normalize(OmpModel, normalize, n_warnings):
  function test_correct_shapes (line 62) | def test_correct_shapes():
  function test_correct_shapes_gram (line 67) | def test_correct_shapes_gram():
  function test_n_nonzero_coefs (line 72) | def test_n_nonzero_coefs():
  function test_tol (line 80) | def test_tol():
  function test_with_without_gram (line 88) | def test_with_without_gram():
  function test_with_without_gram_tol (line 95) | def test_with_without_gram_tol():
  function test_unreachable_accuracy (line 101) | def test_unreachable_accuracy():
  function test_bad_input (line 122) | def test_bad_input(positional_params, keyword_params):
  function test_perfect_signal_recovery (line 127) | def test_perfect_signal_recovery():
  function test_orthogonal_mp_gram_readonly (line 137) | def test_orthogonal_mp_gram_readonly():
  function test_estimator (line 154) | def test_estimator():
  function test_identical_regressors (line 183) | def test_identical_regressors():
  function test_swapped_regressors (line 198) | def test_swapped_regressors():
  function test_no_atoms (line 213) | def test_no_atoms():
  function test_omp_path (line 222) | def test_omp_path():
  function test_omp_return_path_prop_with_gram (line 233) | def test_omp_return_path_prop_with_gram():
  function test_omp_cv (line 242) | def test_omp_cv():
  function test_omp_reaches_least_squares (line 260) | def test_omp_reaches_least_squares():

FILE: sklearn/linear_model/tests/test_passive_aggressive.py
  class MyPassiveAggressive (line 25) | class MyPassiveAggressive(ClassifierMixin):
    method __init__ (line 26) | def __init__(
    method fit (line 41) | def fit(self, X, y):
    method project (line 70) | def project(self, X):
  function test_classifier_accuracy (line 74) | def test_classifier_accuracy():
  function test_classifier_partial_fit (line 96) | def test_classifier_partial_fit():
  function test_classifier_refit (line 114) | def test_classifier_refit():
  function test_classifier_correctness (line 124) | def test_classifier_correctness(loss):
  function test_classifier_undefined_methods (line 143) | def test_classifier_undefined_methods(response_method):
  function test_class_weights (line 149) | def test_class_weights():
  function test_partial_fit_weight_class_balanced (line 171) | def test_partial_fit_weight_class_balanced():
  function test_equal_class_weight (line 178) | def test_equal_class_weight():
  function test_wrong_class_weight_label (line 198) | def test_wrong_class_weight_label():
  function test_wrong_class_weight_format (line 208) | def test_wrong_class_weight_format():
  function test_regressor_mse (line 222) | def test_regressor_mse():
  function test_regressor_partial_fit (line 246) | def test_regressor_partial_fit():
  function test_regressor_correctness (line 267) | def test_regressor_correctness(loss):
  function test_regressor_undefined_methods (line 283) | def test_regressor_undefined_methods():
  function test_passive_aggressive_estimator_params_validation (line 307) | def test_passive_aggressive_estimator_params_validation(

FILE: sklearn/linear_model/tests/test_perceptron.py
  class MyPerceptron (line 21) | class MyPerceptron:
    method __init__ (line 22) | def __init__(self, n_iter=1):
    method fit (line 25) | def fit(self, X, y):
    method project (line 36) | def project(self, X):
    method predict (line 39) | def predict(self, X):
  function test_perceptron_accuracy (line 44) | def test_perceptron_accuracy():
  function test_perceptron_correctness (line 52) | def test_perceptron_correctness():
  function test_undefined_methods (line 65) | def test_undefined_methods():
  function test_perceptron_l1_ratio (line 72) | def test_perceptron_l1_ratio():

FILE: sklearn/linear_model/tests/test_quantile.py
  function X_y_data (line 19) | def X_y_data():
  function test_init_parameters_validation (line 41) | def test_init_parameters_validation(X_y_data, params, err_msg):
  function test_too_new_solver_methods_raise_error (line 53) | def test_too_new_solver_methods_raise_error(X_y_data, solver):
  function test_quantile_toy_example (line 75) | def test_quantile_toy_example(quantile, alpha, intercept, coef):
  function test_quantile_equals_huber_for_low_epsilon (line 89) | def test_quantile_equals_huber_for_low_epsilon(fit_intercept):
  function test_quantile_estimates_calibration (line 104) | def test_quantile_estimates_calibration(q):
  function test_quantile_sample_weight (line 115) | def test_quantile_sample_weight():
  function test_asymmetric_error (line 132) | def test_asymmetric_error(quantile):
  function test_equivariance (line 188) | def test_equivariance(quantile):
  function test_linprog_failure (line 234) | def test_linprog_failure():

FILE: sklearn/linear_model/tests/test_ransac.py
  function test_ransac_inliers_outliers (line 31) | def test_ransac_inliers_outliers():
  function test_ransac_is_data_valid (line 48) | def test_ransac_is_data_valid():
  function test_ransac_is_model_valid (line 70) | def test_ransac_is_model_valid():
  function test_ransac_max_trials (line 88) | def test_ransac_max_trials():
  function test_ransac_stop_n_inliers (line 112) | def test_ransac_stop_n_inliers():
  function test_ransac_stop_score (line 126) | def test_ransac_stop_score():
  function test_ransac_score (line 140) | def test_ransac_score():
  function test_ransac_predict (line 156) | def test_ransac_predict():
  function test_ransac_residuals_threshold_no_inliers (line 171) | def test_ransac_residuals_threshold_no_inliers():
  function test_ransac_no_valid_data (line 191) | def test_ransac_no_valid_data():
  function test_ransac_no_valid_model (line 208) | def test_ransac_no_valid_model():
  function test_ransac_exceed_max_skips (line 225) | def test_ransac_exceed_max_skips():
  function test_ransac_warn_exceed_max_skips (line 242) | def test_ransac_warn_exceed_max_skips():
  function test_ransac_sparse_coo (line 271) | def test_ransac_sparse_coo():
  function test_ransac_sparse_csr (line 286) | def test_ransac_sparse_csr():
  function test_ransac_sparse_csc (line 301) | def test_ransac_sparse_csc():
  function test_ransac_none_estimator (line 316) | def test_ransac_none_estimator():
  function test_ransac_min_n_samples (line 335) | def test_ransac_min_n_samples():
  function test_ransac_multi_dimensional_targets (line 395) | def test_ransac_multi_dimensional_targets():
  function test_ransac_residual_loss (line 415) | def test_ransac_residual_loss():
  function test_ransac_default_residual_threshold (line 477) | def test_ransac_default_residual_threshold():
  function test_ransac_dynamic_max_trials (line 491) | def test_ransac_dynamic_max_trials():
  function test_ransac_fit_sample_weight (line 537) | def test_ransac_fit_sample_weight():
  function test_ransac_final_model_fit_sample_weight (line 592) | def test_ransac_final_model_fit_sample_weight():
  function test_perfect_horizontal_line (line 609) | def test_perfect_horizontal_line():
  function test_loss_deprecated (line 633) | def test_loss_deprecated(old_loss, new_loss):

FILE: sklearn/linear_model/tests/test_ridge.py
  function DENSE_FILTER (line 63) | def DENSE_FILTER(X):
  function SPARSE_FILTER (line 67) | def SPARSE_FILTER(X):
  function _accuracy_callable (line 71) | def _accuracy_callable(y_test, y_pred):
  function _mean_squared_error_callable (line 75) | def _mean_squared_error_callable(y_test, y_pred):
  function test_ridge (line 80) | def test_ridge(solver):
  function test_primal_dual_relationship (line 116) | def test_primal_dual_relationship():
  function test_ridge_singular (line 125) | def test_ridge_singular():
  function test_ridge_regression_sample_weights (line 139) | def test_ridge_regression_sample_weights():
  function test_ridge_regression_convergence_fail (line 164) | def test_ridge_regression_convergence_fail():
  function test_ridge_sample_weights (line 175) | def test_ridge_sample_weights():
  function test_ridge_shapes (line 222) | def test_ridge_shapes():
  function test_ridge_intercept (line 246) | def test_ridge_intercept():
  function test_toy_ridge_object (line 264) | def test_toy_ridge_object():
  function test_ridge_vs_lstsq (line 286) | def test_ridge_vs_lstsq():
  function test_ridge_individual_penalties (line 307) | def test_ridge_individual_penalties():
  function test_X_CenterStackOp (line 339) | def test_X_CenterStackOp(n_col):
  function test_compute_gram (line 354) | def test_compute_gram(shape, uniform_weights):
  function test_compute_covariance (line 374) | def test_compute_covariance(shape, uniform_weights):
  function _make_sparse_offset_regression (line 392) | def _make_sparse_offset_regression(
  function test_solver_consistency (line 456) | def test_solver_consistency(
  function test_ridge_gcv_vs_ridge_loo_cv (line 502) | def test_ridge_gcv_vs_ridge_loo_cv(
  function test_ridge_loo_cv_asym_scoring (line 543) | def test_ridge_loo_cv_asym_scoring():
  function test_ridge_gcv_sample_weights (line 585) | def test_ridge_gcv_sample_weights(
  function test_check_gcv_mode_error (line 646) | def test_check_gcv_mode_error(mode):
  function test_check_gcv_mode_choice (line 665) | def test_check_gcv_mode_choice(
  function _test_ridge_loo (line 675) | def _test_ridge_loo(filter_):
  function _test_ridge_cv_normalize (line 730) | def _test_ridge_cv_normalize(filter_):
  function _test_ridge_cv (line 743) | def _test_ridge_cv(filter_):
  function test_ridge_gcv_cv_values_not_stored (line 767) | def test_ridge_gcv_cv_values_not_stored(ridge, make_dataset):
  function test_ridge_best_score (line 779) | def test_ridge_best_score(ridge, make_dataset, cv):
  function test_ridge_cv_individual_penalties (line 788) | def test_ridge_cv_individual_penalties():
  function _test_ridge_diabetes (line 859) | def _test_ridge_diabetes(filter_):
  function _test_multi_ridge_diabetes (line 865) | def _test_multi_ridge_diabetes(filter_):
  function _test_ridge_classifiers (line 879) | def _test_ridge_classifiers(filter_):
  function test_ridge_classifier_with_scoring (line 898) | def test_ridge_classifier_with_scoring(filter_, scoring, cv):
  function test_ridge_regression_custom_scoring (line 910) | def test_ridge_regression_custom_scoring(filter_, cv):
  function _test_tolerance (line 925) | def _test_tolerance(filter_):
  function check_dense_sparse (line 937) | def check_dense_sparse(test_func):
  function test_dense_sparse (line 961) | def test_dense_sparse(test_func):
  function test_ridge_sparse_svd (line 965) | def test_ridge_sparse_svd():
  function test_class_weights (line 973) | def test_class_weights():
  function test_class_weight_vs_sample_weight (line 1009) | def test_class_weight_vs_sample_weight(reg):
  function test_class_weights_cv (line 1037) | def test_class_weights_cv():
  function test_ridgecv_store_cv_values (line 1055) | def test_ridgecv_store_cv_values(scoring):
  function test_ridge_classifier_cv_store_cv_values (line 1085) | def test_ridge_classifier_cv_store_cv_values(scoring):
  function test_ridgecv_alphas_conversion (line 1114) | def test_ridgecv_alphas_conversion(Estimator):
  function test_ridgecv_sample_weight (line 1134) | def test_ridgecv_sample_weight():
  function test_raises_value_error_if_sample_weights_greater_than_1d (line 1158) | def test_raises_value_error_if_sample_weights_greater_than_1d():
  function test_sparse_design_with_sample_weights (line 1197) | def test_sparse_design_with_sample_weights():
  function test_ridgecv_int_alphas (line 1228) | def test_ridgecv_int_alphas():
  function test_ridgecv_negative_alphas (line 1237) | def test_ridgecv_negative_alphas():
  function test_raises_value_error_if_solver_not_supported (line 1252) | def test_raises_value_error_if_solver_not_supported():
  function test_sparse_cg_max_iter (line 1273) | def test_sparse_cg_max_iter():
  function test_n_iter (line 1280) | def test_n_iter():
  function test_ridge_fit_intercept_sparse (line 1299) | def test_ridge_fit_intercept_sparse(solver):
  function test_ridge_fit_intercept_sparse_error (line 1329) | def test_ridge_fit_intercept_sparse_error(solver):
  function test_ridge_fit_intercept_sparse_sag (line 1338) | def test_ridge_fit_intercept_sparse_sag():
  function test_ridge_regression_check_arguments_validity (line 1365) | def test_ridge_regression_check_arguments_validity(
  function test_dtype_match (line 1423) | def test_dtype_match(solver):
  function test_dtype_match_cholesky (line 1457) | def test_dtype_match_cholesky():
  function test_ridge_regression_dtype_stability (line 1491) | def test_ridge_regression_dtype_stability(solver, seed):
  function test_ridge_sag_with_X_fortran (line 1523) | def test_ridge_sag_with_X_fortran():
  function test_ridgeclassifier_multilabel (line 1541) | def test_ridgeclassifier_multilabel(Classifier, params):
  function test_ridge_positive_regression_test (line 1558) | def test_ridge_positive_regression_test(solver, fit_intercept, alpha):
  function test_ridge_ground_truth_positive_test (line 1577) | def test_ridge_ground_truth_positive_test(fit_intercept, alpha):
  function test_ridge_positive_error_test (line 1605) | def test_ridge_positive_error_test(solver):
  function test_positive_ridge_loss (line 1623) | def test_positive_ridge_loss(alpha):
  function test_lbfgs_solver_consistency (line 1661) | def test_lbfgs_solver_consistency(alpha):
  function test_lbfgs_solver_error (line 1677) | def test_lbfgs_solver_error():
  function test_ridge_sample_weight_invariance (line 1700) | def test_ridge_sample_weight_invariance(normalize, solver):

FILE: sklearn/linear_model/tests/test_sag.py
  function log_dloss (line 33) | def log_dloss(p, y):
  function log_loss (line 43) | def log_loss(p, y):
  function squared_dloss (line 48) | def squared_dloss(p, y):
  function squared_loss (line 52) | def squared_loss(p, y):
  function get_pobj (line 57) | def get_pobj(w, alpha, myX, myy, loss):
  function sag (line 65) | def sag(
  function sag_sparse (line 129) | def sag_sparse(
  function get_step_size (line 246) | def get_step_size(X, alpha, fit_intercept, classification=True):
  function test_classifier_matching (line 253) | def test_classifier_matching():
  function test_regressor_matching (line 308) | def test_regressor_matching():
  function test_sag_pobj_matches_logistic_regression (line 357) | def test_sag_pobj_matches_logistic_regression():
  function test_sag_pobj_matches_ridge_regression (line 397) | def test_sag_pobj_matches_ridge_regression():
  function test_sag_regressor_computed_correctly (line 441) | def test_sag_regressor_computed_correctly():
  function test_get_auto_step_size (line 501) | def test_get_auto_step_size():
  function test_sag_regressor (line 552) | def test_sag_regressor(seed):
  function test_sag_classifier_computed_correctly (line 594) | def test_sag_classifier_computed_correctly():
  function test_sag_multiclass_computed_correctly (line 650) | def test_sag_multiclass_computed_correctly():
  function test_classifier_results (line 721) | def test_classifier_results():
  function test_binary_classifier_class_weight (line 751) | def test_binary_classifier_class_weight():
  function test_multiclass_classifier_class_weight (line 814) | def test_multiclass_classifier_class_weight():
  function test_classifier_single_class (line 889) | def test_classifier_single_class():
  function test_step_size_alpha_error (line 899) | def test_step_size_alpha_error():
  function test_multinomial_loss (line 918) | def test_multinomial_loss():
  function test_multinomial_loss_ground_truth (line 950) | def test_multinomial_loss_ground_truth():
  function test_sag_classifier_raises_error (line 989) | def test_sag_classifier_raises_error(solver):

FILE: sklearn/linear_model/tests/test_sgd.py
  function _update_kwargs (line 28) | def _update_kwargs(kwargs):
  class _SparseSGDClassifier (line 38) | class _SparseSGDClassifier(linear_model.SGDClassifier):
    method fit (line 39) | def fit(self, X, y, *args, **kw):
    method partial_fit (line 43) | def partial_fit(self, X, y, *args, **kw):
    method decision_function (line 47) | def decision_function(self, X):
    method predict_proba (line 51) | def predict_proba(self, X):
  class _SparseSGDRegressor (line 56) | class _SparseSGDRegressor(linear_model.SGDRegressor):
    method fit (line 57) | def fit(self, X, y, *args, **kw):
    method partial_fit (line 61) | def partial_fit(self, X, y, *args, **kw):
    method decision_function (line 65) | def decision_function(self, X, *args, **kw):
  class _SparseSGDOneClassSVM (line 71) | class _SparseSGDOneClassSVM(linear_model.SGDOneClassSVM):
    method fit (line 72) | def fit(self, X, *args, **kw):
    method partial_fit (line 76) | def partial_fit(self, X, *args, **kw):
    method decision_function (line 80) | def decision_function(self, X, *args, **kw):
  function SGDClassifier (line 85) | def SGDClassifier(**kwargs):
  function SGDRegressor (line 90) | def SGDRegressor(**kwargs):
  function SGDOneClassSVM (line 95) | def SGDOneClassSVM(**kwargs):
  function SparseSGDClassifier (line 100) | def SparseSGDClassifier(**kwargs):
  function SparseSGDRegressor (line 105) | def SparseSGDRegressor(**kwargs):
  function SparseSGDOneClassSVM (line 110) | def SparseSGDOneClassSVM(**kwargs):
  function asgd (line 184) | def asgd(klass, X, y, eta, alpha, weight_init=None, intercept_init=0.0):
  function test_sgd_estimator_params_validation (line 255) | def test_sgd_estimator_params_validation(klass, fit_method, params, err_...
  function _test_warm_start (line 273) | def _test_warm_start(klass, X, Y, lr):
  function test_warm_start (line 301) | def test_warm_start(klass, lr):
  function test_input_format (line 308) | def test_input_format(klass):
  function test_clone (line 322) | def test_clone(klass):
  function test_plain_has_no_average_attr (line 346) | def test_plain_has_no_average_attr(klass):
  function test_late_onset_averaging_not_reached (line 375) | def test_late_onset_averaging_not_reached(klass):
  function test_late_onset_averaging_reached (line 396) | def test_late_onset_averaging_reached(klass):
  function test_early_stopping (line 442) | def test_early_stopping(klass):
  function test_adaptive_longer_than_constant (line 456) | def test_adaptive_longer_than_constant(klass):
  function test_validation_set_not_used_for_training (line 467) | def test_validation_set_not_used_for_training(klass):
  function test_n_iter_no_change (line 511) | def test_n_iter_no_change(klass):
  function test_not_enough_sample_for_early_stopping (line 532) | def test_not_enough_sample_for_early_stopping(klass):
  function test_sgd_clf (line 544) | def test_sgd_clf(klass):
  function test_provide_coef (line 564) | def test_provide_coef(klass):
  function test_set_intercept_offset (line 579) | def test_set_intercept_offset(klass, fit_params):
  function test_sgd_early_stopping_with_partial_fit (line 589) | def test_sgd_early_stopping_with_partial_fit(klass):
  function test_set_intercept_offset_binary (line 607) | def test_set_intercept_offset_binary(klass, fit_params):
  function test_average_binary_computed_correctly (line 614) | def test_average_binary_computed_correctly(klass):
  function test_set_intercept_to_intercept (line 648) | def test_set_intercept_to_intercept(klass):
  function test_sgd_at_least_two_labels (line 658) | def test_sgd_at_least_two_labels(klass):
  function test_partial_fit_weight_class_balanced (line 666) | def test_partial_fit_weight_class_balanced(klass):
  function test_sgd_multiclass (line 683) | def test_sgd_multiclass(klass):
  function test_sgd_multiclass_average (line 694) | def test_sgd_multiclass_average(klass):
  function test_sgd_multiclass_with_init_coef (line 722) | def test_sgd_multiclass_with_init_coef(klass):
  function test_sgd_multiclass_njobs (line 733) | def test_sgd_multiclass_njobs(klass):
  function test_set_coef_multiclass (line 744) | def test_set_coef_multiclass(klass):
  function test_sgd_predict_proba_method_access (line 767) | def test_sgd_predict_proba_method_access(klass):
  function test_sgd_proba (line 791) | def test_sgd_proba(klass):
  function test_sgd_l1 (line 860) | def test_sgd_l1(klass):
  function test_class_weights (line 897) | def test_class_weights(klass):
  function test_equal_class_weight (line 916) | def test_equal_class_weight(klass):
  function test_wrong_class_weight_label (line 933) | def test_wrong_class_weight_label(klass):
  function test_wrong_class_weight_format (line 941) | def test_wrong_class_weight_format(klass):
  function test_weights_multiplied (line 949) | def test_weights_multiplied(klass):
  function test_balanced_weight (line 968) | def test_balanced_weight(klass):
  function test_sample_weights (line 1015) | def test_sample_weights(klass):
  function test_wrong_sample_weights (line 1035) | def test_wrong_sample_weights(klass):
  function test_partial_fit_exception (line 1047) | def test_partial_fit_exception(klass):
  function test_partial_fit_binary (line 1055) | def test_partial_fit_binary(klass):
  function test_partial_fit_multiclass (line 1076) | def test_partial_fit_multiclass(klass):
  function test_partial_fit_multiclass_average (line 1094) | def test_partial_fit_multiclass_average(klass):
  function test_fit_then_partial_fit (line 1109) | def test_fit_then_partial_fit(klass):
  function test_partial_fit_equal_fit_classif (line 1120) | def test_partial_fit_equal_fit_classif(klass, lr):
  function test_regression_losses (line 1138) | def test_regression_losses(klass):
  function test_warm_start_multiclass (line 1176) | def test_warm_start_multiclass(klass):
  function test_multiple_fit (line 1181) | def test_multiple_fit(klass):
  function test_sgd_reg (line 1197) | def test_sgd_reg(klass):
  function test_sgd_averaged_computed_correctly (line 1205) | def test_sgd_averaged_computed_correctly(klass):
  function test_sgd_averaged_partial_fit (line 1238) | def test_sgd_averaged_partial_fit(klass):
  function test_average_sparse (line 1271) | def test_average_sparse(klass):
  function test_sgd_least_squares_fit (line 1298) | def test_sgd_least_squares_fit(klass):
  function test_sgd_epsilon_insensitive (line 1322) | def test_sgd_epsilon_insensitive(klass):
  function test_sgd_huber_fit (line 1358) | def test_sgd_huber_fit(klass):
  function test_elasticnet_convergence (line 1382) | def test_elasticnet_convergence(klass):
  function test_partial_fit (line 1417) | def test_partial_fit(klass):
  function test_partial_fit_equal_fit (line 1435) | def test_partial_fit_equal_fit(klass, lr):
  function test_loss_function_epsilon (line 1451) | def test_loss_function_epsilon(klass):
  function asgd_oneclass (line 1461) | def asgd_oneclass(klass, X, eta, nu, coef_init=None, offset_init=0.0):
  function _test_warm_start_oneclass (line 1500) | def _test_warm_start_oneclass(klass, X, lr):
  function test_warm_start_oneclass (line 1524) | def test_warm_start_oneclass(klass, lr):
  function test_clone_oneclass (line 1529) | def test_clone_oneclass(klass):
  function test_partial_fit_oneclass (line 1543) | def test_partial_fit_oneclass(klass):
  function test_partial_fit_equal_fit_oneclass (line 1564) | def test_partial_fit_equal_fit_oneclass(klass, lr):
  function test_late_onset_averaging_reached_oneclass (line 1584) | def test_late_onset_averaging_reached_oneclass(klass):
  function test_sgd_averaged_computed_correctly_oneclass (line 1612) | def test_sgd_averaged_computed_correctly_oneclass(klass):
  function test_sgd_averaged_partial_fit_oneclass (line 1639) | def test_sgd_averaged_partial_fit_oneclass(klass):
  function test_average_sparse_oneclass (line 1667) | def test_average_sparse_oneclass(klass):
  function test_sgd_oneclass (line 1691) | def test_sgd_oneclass():
  function test_ocsvm_vs_sgdocsvm (line 1713) | def test_ocsvm_vs_sgdocsvm():
  function test_l1_ratio (line 1754) | def test_l1_ratio():
  function test_underflow_or_overlow (line 1789) | def test_underflow_or_overlow():
  function test_numerical_stability_large_gradient (line 1827) | def test_numerical_stability_large_gradient():
  function test_large_regularization (line 1847) | def test_large_regularization(penalty):
  function test_tol_parameter (line 1864) | def test_tol_parameter():
  function _test_loss_common (line 1900) | def _test_loss_common(loss_function, cases):
  function test_loss_hinge (line 1908) | def test_loss_hinge():
  function test_gradient_squared_hinge (line 1941) | def test_gradient_squared_hinge():
  function test_loss_log (line 1956) | def test_loss_log():
  function test_loss_squared_loss (line 1977) | def test_loss_squared_loss():
  function test_loss_huber (line 1991) | def test_loss_huber():
  function test_loss_modified_huber (line 2006) | def test_loss_modified_huber():
  function test_loss_epsilon_insensitive (line 2023) | def test_loss_epsilon_insensitive():
  function test_loss_squared_epsilon_insensitive (line 2040) | def test_loss_squared_epsilon_insensitive():
  function test_multi_thread_multi_class_and_early_stopping (line 2057) | def test_multi_thread_multi_class_and_early_stopping():
  function test_multi_core_gridsearch_and_early_stopping (line 2075) | def test_multi_core_gridsearch_and_early_stopping():
  function test_SGDClassifier_fit_for_all_backends (line 2091) | def test_SGDClassifier_fit_for_all_backends(backend):
  function test_loss_squared_loss_deprecated (line 2133) | def test_loss_squared_loss_deprecated(Estimator):

FILE: sklearn/linear_model/tests/test_sparse_coordinate_descent.py
  function test_sparse_coef (line 20) | def test_sparse_coef():
  function test_normalize_option (line 30) | def test_normalize_option():
  function test_lasso_zero (line 43) | def test_lasso_zero():
  function test_enet_toy_list_input (line 55) | def test_enet_toy_list_input():
  function test_enet_toy_explicit_sparse_input (line 88) | def test_enet_toy_explicit_sparse_input():
  function make_sparse_data (line 127) | def make_sparse_data(
  function _test_sparse_enet_not_as_toy_dataset (line 158) | def _test_sparse_enet_not_as_toy_dataset(alpha, fit_intercept, positive):
  function test_sparse_enet_not_as_toy_dataset (line 203) | def test_sparse_enet_not_as_toy_dataset():
  function test_sparse_lasso_not_as_toy_dataset (line 210) | def test_sparse_lasso_not_as_toy_dataset():
  function test_enet_multitarget (line 234) | def test_enet_multitarget():
  function test_path_parameters (line 254) | def test_path_parameters():
  function test_same_output_sparse_dense_lasso_and_enet_cv (line 274) | def test_same_output_sparse_dense_lasso_and_enet_cv():
  function test_same_multiple_output_sparse_dense (line 296) | def test_same_multiple_output_sparse_dense():
  function test_sparse_enet_coordinate_descent (line 324) | def test_sparse_enet_coordinate_descent():

FILE: sklearn/linear_model/tests/test_theil_sen.py
  function no_stdout_stderr (line 24) | def no_stdout_stderr():
  function gen_toy_problem_1d (line 36) | def gen_toy_problem_1d(intercept=True):
  function gen_toy_problem_2d (line 64) | def gen_toy_problem_2d():
  function gen_toy_problem_4d (line 80) | def gen_toy_problem_4d():
  function test_modweiszfeld_step_1d (line 96) | def test_modweiszfeld_step_1d():
  function test_modweiszfeld_step_2d (line 121) | def test_modweiszfeld_step_2d():
  function test_spatial_median_1d (line 135) | def test_spatial_median_1d():
  function test_spatial_median_2d (line 148) | def test_spatial_median_2d():
  function test_theil_sen_1d (line 165) | def test_theil_sen_1d():
  function test_theil_sen_1d_no_intercept (line 176) | def test_theil_sen_1d_no_intercept():
  function test_theil_sen_2d (line 190) | def test_theil_sen_2d():
  function test_calc_breakdown_point (line 201) | def test_calc_breakdown_point():
  function test_checksubparams_negative_subpopulation (line 206) | def test_checksubparams_negative_subpopulation():
  function test_checksubparams_too_few_subsamples (line 214) | def test_checksubparams_too_few_subsamples():
  function test_checksubparams_too_many_subsamples (line 221) | def test_checksubparams_too_many_subsamples():
  function test_checksubparams_n_subsamples_if_less_samples_than_features (line 228) | def test_checksubparams_n_subsamples_if_less_samples_than_features():
  function test_subpopulation (line 238) | def test_subpopulation():
  function test_subsamples (line 245) | def test_subsamples():
  function test_verbosity (line 253) | def test_verbosity():
  function test_theil_sen_parallel (line 261) | def test_theil_sen_parallel():
  function test_less_samples_than_features (line 274) | def test_less_samples_than_features():

FILE: sklearn/manifold/_isomap.py
  class Isomap (line 21) | class Isomap(TransformerMixin, BaseEstimator):
    method __init__ (line 154) | def __init__(
    method _fit_transform (line 181) | def _fit_transform(self, X):
    method reconstruction_error (line 259) | def reconstruction_error(self):
    method fit (line 284) | def fit(self, X, y=None):
    method fit_transform (line 305) | def fit_transform(self, X, y=None):
    method transform (line 325) | def transform(self, X):

FILE: sklearn/manifold/_locally_linear.py
  function barycenter_weights (line 21) | def barycenter_weights(X, Y, indices, reg=1e-3):
  function barycenter_kneighbors_graph (line 75) | def barycenter_kneighbors_graph(X, n_neighbors, reg=1e-3, n_jobs=None):
  function null_space (line 117) | def null_space(
  function locally_linear_embedding (line 193) | def locally_linear_embedding(
  class LocallyLinearEmbedding (line 545) | class LocallyLinearEmbedding(TransformerMixin, _UnstableArchMixin, BaseE...
    method __init__ (line 678) | def __init__(
    method _fit_transform (line 707) | def _fit_transform(self, X):
    method fit (line 732) | def fit(self, X, y=None):
    method fit_transform (line 751) | def fit_transform(self, X, y=None):
    method transform (line 770) | def transform(self, X):

FILE: sklearn/manifold/_mds.py
  function _smacof_single (line 21) | def _smacof_single(
  function smacof (line 143) | def smacof(
  class MDS (line 310) | class MDS(BaseEstimator):
    method __init__ (line 428) | def __init__(
    method _more_tags (line 451) | def _more_tags(self):
    method _pairwise (line 461) | def _pairwise(self):
    method fit (line 464) | def fit(self, X, y=None, init=None):
    method fit_transform (line 491) | def fit_transform(self, X, y=None, init=None):

FILE: sklearn/manifold/_spectral_embedding.py
  function _graph_connected_component (line 31) | def _graph_connected_component(graph, node_id):
  function _graph_is_connected (line 74) | def _graph_is_connected(graph):
  function _set_diag (line 97) | def _set_diag(laplacian, value, norm_laplacian):
  function spectral_embedding (line 143) | def spectral_embedding(
  class SpectralEmbedding (line 390) | class SpectralEmbedding(BaseEstimator):
    method __init__ (line 510) | def __init__(
    method _more_tags (line 529) | def _more_tags(self):
    method _pairwise (line 542) | def _pairwise(self):
    method _get_affinity_matrix (line 545) | def _get_affinity_matrix(self, X, Y=None):
    method fit (line 603) | def fit(self, X, y=None):
    method fit_transform (line 657) | def fit_transform(self, X, y=None):

FILE: sklearn/manifold/_t_sne.py
  function _joint_probabilities (line 36) | def _joint_probabilities(distances, desired_perplexity, verbose):
  function _joint_probabilities_nn (line 69) | def _joint_probabilities_nn(distances, desired_perplexity, verbose):
  function _kl_divergence (line 126) | def _kl_divergence(
  function _kl_divergence_bh (line 203) | def _kl_divergence_bh(
  function _gradient_descent (line 299) | def _gradient_descent(
  function trustworthiness (line 445) | def trustworthiness(X, X_embedded, *, n_neighbors=5, metric="euclidean"):
  class TSNE (line 524) | class TSNE(BaseEstimator):
    method __init__ (line 739) | def __init__(
    method _fit (line 775) | def _fit(self, X, skip_num_points=0):
    method _tsne (line 1013) | def _tsne(
    method fit_transform (line 1088) | def fit_transform(self, X, y=None):
    method fit (line 1112) | def fit(self, X, y=None):

FILE: sklearn/manifold/setup.py
  function configuration (line 6) | def configuration(parent_package="", top_path=None):

FILE: sklearn/manifold/tests/test_isomap.py
  function test_isomap_simple_grid (line 18) | def test_isomap_simple_grid():
  function test_isomap_reconstruction_error (line 46) | def test_isomap_reconstruction_error():
  function test_transform (line 88) | def test_transform():
  function test_pipeline (line 109) | def test_pipeline():
  function test_pipeline_with_nearest_neighbors_transformer (line 121) | def test_pipeline_with_nearest_neighbors_transformer():
  function test_different_metric (line 150) | def test_different_metric():
  function test_isomap_clone_bug (line 177) | def test_isomap_clone_bug():
  function test_sparse_input (line 186) | def test_sparse_input():
  function test_multiple_connected_components (line 201) | def test_multiple_connected_components():
  function test_multiple_connected_components_metric_precomputed (line 208) | def test_multiple_connected_components_metric_precomputed():

FILE: sklearn/manifold/tests/test_locally_linear.py
  function test_barycenter_kneighbors_graph (line 17) | def test_barycenter_kneighbors_graph():
  function test_lle_simple_grid (line 36) | def test_lle_simple_grid():
  function test_lle_manifold (line 74) | def test_lle_manifold():
  function test_lle_init_parameters (line 107) | def test_lle_init_parameters():
  function test_pipeline (line 121) | def test_pipeline():
  function test_singular_matrix (line 139) | def test_singular_matrix():
  function test_integer_input (line 155) | def test_integer_input():

FILE: sklearn/manifold/tests/test_mds.py
  function test_smacof (line 9) | def test_smacof():
  function test_smacof_error (line 21) | def test_smacof_error():
  function test_MDS (line 42) | def test_MDS():
  function test_MDS_pairwise_deprecated (line 49) | def test_MDS_pairwise_deprecated():
  function test_MDS_pairwise (line 65) | def test_MDS_pairwise(dissimilarity, expected_pairwise):

FILE: sklearn/manifold/tests/test_spectral_embedding.py
  function _assert_equal_with_sign_flipping (line 47) | def _assert_equal_with_sign_flipping(A, B, tol=0.0):
  function test_sparse_graph_connected_component (line 58) | def test_sparse_graph_connected_component():
  function test_spectral_embedding_two_components (line 106) | def test_spectral_embedding_two_components(eigen_solver, dtype, seed=36):
  function test_spectral_embedding_precomputed_affinity (line 160) | def test_spectral_embedding_precomputed_affinity(X, eigen_solver, dtype,...
  function test_precomputed_nearest_neighbors_filtering (line 182) | def test_precomputed_nearest_neighbors_filtering():
  function test_spectral_embedding_callable_affinity (line 205) | def test_spectral_embedding_callable_affinity(X, seed=36):
  function test_spectral_embedding_amg_solver (line 245) | def test_spectral_embedding_amg_solver(dtype, seed=36):
  function test_spectral_embedding_amg_solver_failure (line 299) | def test_spectral_embedding_amg_solver_failure(dtype, seed=36):
  function test_pipeline_spectral_clustering (line 319) | def test_pipeline_spectral_clustering(seed=36):
  function test_spectral_embedding_unknown_eigensolver (line 339) | def test_spectral_embedding_unknown_eigensolver(seed=36):
  function test_spectral_embedding_unknown_affinity (line 351) | def test_spectral_embedding_unknown_affinity(seed=36):
  function test_connectivity (line 362) | def test_connectivity(seed=36):
  function test_spectral_embedding_deterministic (line 390) | def test_spectral_embedding_deterministic():
  function test_spectral_embedding_unnormalized (line 400) | def test_spectral_embedding_unnormalized():
  function test_spectral_embedding_first_eigen_vector (line 420) | def test_spectral_embedding_first_eigen_vector():
  function test_spectral_embedding_preserves_dtype (line 450) | def test_spectral_embedding_preserves_dtype(eigen_solver, dtype):
  function test_error_pyamg_not_available (line 474) | def test_error_pyamg_not_available():
  function test_spectral_embedding_pairwise_deprecated (line 487) | def test_spectral_embedding_pairwise_deprecated(affinity):

FILE: sklearn/manifold/tests/test_t_sne.py
  function test_gradient_descent_stops (line 47) | def test_gradient_descent_stops():
  function test_binary_search (line 133) | def test_binary_search():
  function test_binary_search_underflow (line 147) | def test_binary_search_underflow():
  function test_binary_search_neighbors (line 159) | def test_binary_search_neighbors():
  function test_binary_perplexity_stability (line 203) | def test_binary_perplexity_stability():
  function test_gradient (line 230) | def test_gradient():
  function test_trustworthiness (line 255) | def test_trustworthiness():
  function test_preserve_trustworthiness_approximately (line 279) | def test_preserve_trustworthiness_approximately(method, init):
  function test_optimization_minimizes_kl_divergence (line 294) | def test_optimization_minimizes_kl_divergence():
  function test_fit_csr_matrix (line 316) | def test_fit_csr_matrix(method):
  function test_preserve_trustworthiness_approximately_with_precomputed_distances (line 336) | def test_preserve_trustworthiness_approximately_with_precomputed_distanc...
  function test_trustworthiness_not_euclidean_metric (line 359) | def test_trustworthiness_not_euclidean_metric():
  function test_early_exaggeration_too_small (line 371) | def test_early_exaggeration_too_small():
  function test_too_few_iterations (line 380) | def test_too_few_iterations():
  function test_bad_precomputed_distances (line 404) | def test_bad_precomputed_distances(method, D, retype, message_regex):
  function test_exact_no_precomputed_sparse (line 418) | def test_exact_no_precomputed_sparse():
  function test_high_perplexity_precomputed_sparse_distances (line 432) | def test_high_perplexity_precomputed_sparse_distances():
  function test_sparse_precomputed_distance (line 447) | def test_sparse_precomputed_distance():
  function test_non_positive_computed_distances (line 469) | def test_non_positive_computed_distances():
  function test_init_not_available (line 483) | def test_init_not_available():
  function test_init_ndarray (line 493) | def test_init_ndarray():
  function test_init_ndarray_precomputed (line 500) | def test_init_ndarray_precomputed():
  function test_distance_not_available (line 514) | def test_distance_not_available():
  function test_method_not_available (line 527) | def test_method_not_available():
  function test_square_distances_not_available (line 536) | def test_square_distances_not_available():
  function test_angle_out_of_range_checks (line 545) | def test_angle_out_of_range_checks():
  function test_pca_initialization_not_compatible_with_precomputed_kernel (line 555) | def test_pca_initialization_not_compatible_with_precomputed_kernel():
  function test_pca_initialization_not_compatible_with_sparse_input (line 565) | def test_pca_initialization_not_compatible_with_sparse_input():
  function test_n_components_range (line 574) | def test_n_components_range():
  function test_early_exaggeration_used (line 583) | def test_early_exaggeration_used():
  function test_n_iter_used (line 616) | def test_n_iter_used():
  function test_answer_gradient_two_points (line 639) | def test_answer_gradient_two_points():
  function test_answer_gradient_four_points (line 655) | def test_answer_gradient_four_points():
  function test_skip_num_points_gradient (line 681) | def test_skip_num_points_gradient():
  function _run_answer_test (line 710) | def _run_answer_test(
  function test_verbose (line 742) | def test_verbose():
  function test_chebyshev_metric (line 766) | def test_chebyshev_metric():
  function test_reduction_to_one_component (line 776) | def test_reduction_to_one_component():
  function test_64bit (line 789) | def test_64bit(method, dt):
  function test_kl_divergence_not_nan (line 814) | def test_kl_divergence_not_nan(method):
  function test_barnes_hut_angle (line 834) | def test_barnes_hut_angle():
  function test_n_iter_without_progress (line 877) | def test_n_iter_without_progress():
  function test_min_grad_norm (line 909) | def test_min_grad_norm():
  function test_accessible_kl_divergence (line 954) | def test_accessible_kl_divergence():
  function test_uniform_grid (line 985) | def test_uniform_grid(method):
  function assert_uniform_grid (line 1023) | def assert_uniform_grid(Y, try_name=None):
  function test_bh_match_exact (line 1038) | def test_bh_match_exact():
  function test_gradient_bh_multithread_match_sequential (line 1066) | def test_gradient_bh_multithread_match_sequential():
  function test_tsne_with_different_distance_metrics (line 1119) | def test_tsne_with_different_distance_metrics():
  function test_tsne_different_square_distances (line 1151) | def test_tsne_different_square_distances(method, metric, square_distances):
  function test_tsne_square_distances_futurewarning (line 1187) | def test_tsne_square_distances_futurewarning(metric, square_distances):
  function test_tsne_init_futurewarning (line 1211) | def test_tsne_init_futurewarning(init):
  function test_tsne_learning_rate_futurewarning (line 1234) | def test_tsne_learning_rate_futurewarning(learning_rate):
  function test_tsne_negative_learning_rate (line 1254) | def test_tsne_negative_learning_rate():
  function test_tsne_n_jobs (line 1265) | def test_tsne_n_jobs(method):

FILE: sklearn/metrics/_base.py
  function _average_binary_score (line 23) | def _average_binary_score(binary_metric, y_true, y_score, average, sampl...
  function _average_multiclass_ovo_score (line 132) | def _average_multiclass_ovo_score(binary_metric, y_true, y_score, averag...
  function _check_pos_label_consistency (line 202) | def _check_pos_label_consistency(pos_label, y_true):

FILE: sklearn/metrics/_classification.py
  function _check_zero_division (line 47) | def _check_zero_division(zero_division):
  function _check_targets (line 57) | def _check_targets(y_true, y_pred):
  function _weighted_sum (line 135) | def _weighted_sum(sample_score, sample_weight, normalize=False):
  function accuracy_score (line 144) | def accuracy_score(y_true, y_pred, *, normalize=True, sample_weight=None):
  function confusion_matrix (line 222) | def confusion_matrix(
  function multilabel_confusion_matrix (line 379) | def multilabel_confusion_matrix(
  function cohen_kappa_score (line 588) | def cohen_kappa_score(y1, y2, *, labels=None, weights=None, sample_weigh...
  function jaccard_score (line 667) | def jaccard_score(
  function matthews_corrcoef (line 829) | def matthews_corrcoef(y_true, y_pred, *, sample_weight=None):
  function zero_one_loss (line 917) | def zero_one_loss(y_true, y_pred, *, normalize=True, sample_weight=None):
  function f1_score (line 992) | def f1_score(
  function fbeta_score (line 1135) | def fbeta_score(
  function _prf_divide (line 1275) | def _prf_divide(
  function _warn_prf (line 1323) | def _warn_prf(average, modifier, msg_start, result_size):
  function _check_set_wise_labels (line 1339) | def _check_set_wise_labels(y_true, y_pred, average, labels, pos_label):
  function precision_recall_fscore_support (line 1380) | def precision_recall_fscore_support(
  function precision_score (line 1628) | def precision_score(
  function recall_score (line 1770) | def recall_score(
  function balanced_accuracy_score (line 1914) | def balanced_accuracy_score(y_true, y_pred, *, sample_weight=None, adjus...
  function classification_report (line 1998) | def classification_report(
  function hamming_loss (line 2215) | def hamming_loss(y_true, y_pred, *, sample_weight=None):
  function log_loss (line 2309) | def log_loss(
  function hinge_loss (line 2447) | def hinge_loss(y_true, pred_decision, *, labels=None, sample_weight=None):
  function brier_score_loss (line 2591) | def brier_score_loss(y_true, y_prob, *, sample_weight=None, pos_label=No...

FILE: sklearn/metrics/_plot/base.py
  function _check_classifier_response_method (line 4) | def _check_classifier_response_method(estimator, response_method):
  function _get_response (line 50) | def _get_response(X, estimator, response_method, pos_label=None):

FILE: sklearn/metrics/_plot/confusion_matrix.py
  class ConfusionMatrixDisplay (line 12) | class ConfusionMatrixDisplay:
    method __init__ (line 78) | def __init__(self, confusion_matrix, *, display_labels=None):
    method plot (line 82) | def plot(
    method from_estimator (line 180) | def from_estimator(
    method from_predictions (line 310) | def from_predictions(
  function plot_confusion_matrix (line 449) | def plot_confusion_matrix(

FILE: sklearn/metrics/_plot/det_curve.py
  class DetCurveDisplay (line 12) | class DetCurveDisplay:
    method __init__ (line 77) | def __init__(self, *, fpr, fnr, estimator_name=None, pos_label=None):
    method from_estimator (line 84) | def from_estimator(
    method from_predictions (line 191) | def from_predictions(
    method plot (line 287) | def plot(self, ax=None, *, name=None, **kwargs):
  function plot_det_curve (line 359) | def plot_det_curve(

FILE: sklearn/metrics/_plot/precision_recall_curve.py
  class PrecisionRecallDisplay (line 12) | class PrecisionRecallDisplay:
    method __init__ (line 85) | def __init__(
    method plot (line 100) | def plot(self, ax=None, *, name=None, **kwargs):
    method from_estimator (line 158) | def from_estimator(
    method from_predictions (line 260) | def from_predictions(
  function plot_precision_recall_curve (line 357) | def plot_precision_recall_curve(

FILE: sklearn/metrics/_plot/roc_curve.py
  class RocCurveDisplay (line 10) | class RocCurveDisplay:
    method __init__ (line 78) | def __init__(self, *, fpr, tpr, roc_auc=None, estimator_name=None, pos...
    method plot (line 85) | def plot(self, ax=None, *, name=None, **kwargs):
    method from_estimator (line 141) | def from_estimator(
    method from_predictions (line 250) | def from_predictions(
  function plot_roc_curve (line 358) | def plot_roc_curve(

FILE: sklearn/metrics/_plot/tests/test_base.py
  function test_get_response_error (line 31) | def test_get_response_error(estimator, err_msg, params):
  function test_get_response_predict_proba (line 40) | def test_get_response_predict_proba():
  function test_get_response_decision_function (line 59) | def test_get_response_decision_function():

FILE: sklearn/metrics/_plot/tests/test_common_curve_display.py
  function data (line 20) | def data():
  function data_binary (line 25) | def data_binary(data):
  function test_display_curve_error_non_binary (line 33) | def test_display_curve_error_non_binary(pyplot, data, Display):
  function test_display_curve_error_no_response (line 71) | def test_display_curve_error_no_response(
  function test_display_curve_estimator_name_multiple_calls (line 97) | def test_display_curve_estimator_name_multiple_calls(
  function test_display_curve_not_fitted_errors (line 140) | def test_display_curve_not_fitted_errors(pyplot, data_binary, clf, Displ...

FILE: sklearn/metrics/_plot/tests/test_confusion_matrix_display.py
  function test_confusion_matrix_display_validation (line 27) | def test_confusion_matrix_display_validation(pyplot):
  function test_confusion_matrix_display_invalid_option (line 57) | def test_confusion_matrix_display_invalid_option(pyplot, constructor_name):
  function test_confusion_matrix_display_custom_labels (line 80) | def test_confusion_matrix_display_custom_labels(
  function test_confusion_matrix_display_plotting (line 130) | def test_confusion_matrix_display_plotting(
  function test_confusion_matrix_display (line 207) | def test_confusion_matrix_display(pyplot, constructor_name):
  function test_confusion_matrix_contrast (line 257) | def test_confusion_matrix_contrast(pyplot):
  function test_confusion_matrix_pipeline (line 306) | def test_confusion_matrix_pipeline(pyplot, clf):
  function test_confusion_matrix_with_unknown_labels (line 325) | def test_confusion_matrix_with_unknown_labels(pyplot, constructor_name):
  function test_colormap_max (line 355) | def test_colormap_max(pyplot):

FILE: sklearn/metrics/_plot/tests/test_det_curve_display.py
  function test_det_curve_display (line 16) | def test_det_curve_display(
  function test_det_curve_display_default_name (line 89) | def test_det_curve_display_default_name(

FILE: sklearn/metrics/_plot/tests/test_plot_confusion_matrix.py
  function n_classes (line 28) | def n_classes():
  function data (line 33) | def data(n_classes):
  function fitted_clf (line 41) | def fitted_clf(data):
  function y_pred (line 46) | def y_pred(data, fitted_clf):
  function test_error_on_regressor (line 52) | def test_error_on_regressor(pyplot, data):
  function test_error_on_invalid_option (line 62) | def test_error_on_invalid_option(pyplot, fitted_clf, data):
  function test_plot_confusion_matrix_custom_labels (line 73) | def test_plot_confusion_matrix_custom_labels(
  function test_plot_confusion_matrix (line 108) | def test_plot_confusion_matrix(
  function test_confusion_matrix_display (line 170) | def test_confusion_matrix_display(pyplot, data, fitted_clf, y_pred, n_cl...
  function test_confusion_matrix_contrast (line 209) | def test_confusion_matrix_contrast(pyplot):
  function test_confusion_matrix_pipeline (line 257) | def test_confusion_matrix_pipeline(pyplot, clf, data, n_classes):
  function test_plot_confusion_matrix_colorbar (line 273) | def test_plot_confusion_matrix_colorbar(pyplot, data, fitted_clf, colorb...
  function test_confusion_matrix_text_format (line 292) | def test_confusion_matrix_text_format(
  function test_confusion_matrix_standard_format (line 309) | def test_confusion_matrix_standard_format(pyplot):
  function test_default_labels (line 333) | def test_default_labels(pyplot, display_labels, expected_labels):
  function test_error_on_a_dataset_with_unseen_labels (line 345) | def test_error_on_a_dataset_with_unseen_labels(pyplot, fitted_clf, data,...
  function test_plot_confusion_matrix_deprecation_warning (line 363) | def test_plot_confusion_matrix_deprecation_warning(pyplot, fitted_clf, d...

FILE: sklearn/metrics/_plot/tests/test_plot_curve_common.py
  function data (line 22) | def data():
  function data_binary (line 27) | def data_binary(data):
  function test_plot_curve_error_non_binary (line 34) | def test_plot_curve_error_non_binary(pyplot, data, plot_func):
  function test_plot_curve_error_no_response (line 70) | def test_plot_curve_error_no_response(
  function test_plot_curve_estimator_name_multiple_calls (line 92) | def test_plot_curve_estimator_name_multiple_calls(pyplot, data_binary, p...
  function test_plot_det_curve_not_fitted_errors (line 121) | def test_plot_det_curve_not_fitted_errors(pyplot, data_binary, clf, plot...

FILE: sklearn/metrics/_plot/tests/test_plot_det_curve.py
  function data (line 14) | def data():
  function data_binary (line 19) | def data_binary(data):
  function test_plot_det_curve (line 28) | def test_plot_det_curve(

FILE: sklearn/metrics/_plot/tests/test_plot_precision_recall.py
  function test_errors (line 29) | def test_errors(pyplot):
  function test_error_bad_response (line 80) | def test_error_bad_response(pyplot, response_method, msg):
  function test_plot_precision_recall (line 97) | def test_plot_precision_recall(pyplot, response_method, with_sample_weig...
  function test_precision_recall_curve_pipeline (line 158) | def test_precision_recall_curve_pipeline(pyplot, clf):
  function test_precision_recall_curve_string_labels (line 167) | def test_precision_recall_curve_string_labels(pyplot):
  function test_plot_precision_recall_curve_estimator_name_multiple_calls (line 186) | def test_plot_precision_recall_curve_estimator_name_multiple_calls(pyplot):
  function test_plot_precision_recall_pos_label (line 204) | def test_plot_precision_recall_pos_label(pyplot, response_method):

FILE: sklearn/metrics/_plot/tests/test_plot_roc_curve.py
  function data (line 27) | def data():
  function data_binary (line 32) | def data_binary(data):
  function test_plot_roc_curve (line 41) | def test_plot_roc_curve(
  function test_roc_curve_not_fitted_errors (line 121) | def test_roc_curve_not_fitted_errors(pyplot, data_binary, clf):
  function test_plot_roc_curve_pos_label (line 132) | def test_plot_roc_curve_pos_label(pyplot, response_method):

FILE: sklearn/metrics/_plot/tests/test_precision_recall_display.py
  function test_precision_recall_display_validation (line 24) | def test_precision_recall_display_validation(pyplot):
  function test_plot_precision_recall_curve_deprecation (line 67) | def test_plot_precision_recall_curve_deprecation(pyplot):
  function test_precision_recall_display_plotting (line 80) | def test_precision_recall_display_plotting(pyplot, constructor_name, res...
  function test_precision_recall_display_name (line 133) | def test_precision_recall_display_name(pyplot, constructor_name, default...
  function test_precision_recall_display_pipeline (line 175) | def test_precision_recall_display_pipeline(pyplot, clf):
  function test_precision_recall_display_string_labels (line 184) | def test_precision_recall_display_string_labels(pyplot):
  function test_default_labels (line 219) | def test_default_labels(pyplot, average_precision, estimator_name, expec...
  function test_plot_precision_recall_pos_label (line 235) | def test_plot_precision_recall_pos_label(pyplot, constructor_name, respo...

FILE: sklearn/metrics/_plot/tests/test_roc_curve_display.py
  function data (line 25) | def data():
  function data_binary (line 30) | def data_binary(data):
  function test_roc_curve_display_plotting (line 46) | def test_roc_curve_display_plotting(
  function test_roc_curve_display_complex_pipeline (line 139) | def test_roc_curve_display_complex_pipeline(pyplot, data_binary, clf, co...
  function test_roc_curve_display_default_labels (line 168) | def test_roc_curve_display_default_labels(
  function test_plot_roc_curve_pos_label (line 182) | def test_plot_roc_curve_pos_label(pyplot, response_method, constructor_n...
  function test_plot_precision_recall_curve_deprecation (line 255) | def test_plot_precision_recall_curve_deprecation(pyplot):

FILE: sklearn/metrics/_ranking.py
  function auc (line 47) | def auc(x, y):
  function average_precision_score (line 111) | def average_precision_score(
  function det_curve (line 237) | def det_curve(y_true, y_score, pos_label=None, sample_weight=None):
  function _binary_roc_auc_score (line 334) | def _binary_roc_auc_score(y_true, y_score, sample_weight=None, max_fpr=N...
  function roc_auc_score (line 363) | def roc_auc_score(
  function _multiclass_roc_auc_score (line 584) | def _multiclass_roc_auc_score(
  function _binary_clf_curve (line 694) | def _binary_clf_curve(y_true, y_score, pos_label=None, sample_weight=None):
  function precision_recall_curve (line 779) | def precision_recall_curve(y_true, probas_pred, *, pos_label=None, sampl...
  function roc_curve (line 873) | def roc_curve(
  function label_ranking_average_precision_score (line 1010) | def label_ranking_average_precision_score(y_true, y_score, *, sample_wei...
  function coverage_error (line 1099) | def coverage_error(y_true, y_score, *, sample_weight=None):
  function label_ranking_loss (line 1158) | def label_ranking_loss(y_true, y_score, *, sample_weight=None):
  function _dcg_sample_scores (line 1239) | def _dcg_sample_scores(y_true, y_score, k=None, log_base=2, ignore_ties=...
  function _tie_averaged_dcg (line 1299) | def _tie_averaged_dcg(y_true, y_score, discount_cumsum):
  function _check_dcg_target_type (line 1347) | def _check_dcg_target_type(y_true):
  function dcg_score (line 1362) | def dcg_score(
  function _ndcg_sample_scores (line 1470) | def _ndcg_sample_scores(y_true, y_score, k=None, ignore_ties=False):
  function ndcg_score (line 1521) | def ndcg_score(y_true, y_score, *, k=None, sample_weight=None, ignore_ti...
  function top_k_accuracy_score (line 1623) | def top_k_accuracy_score(

FILE: sklearn/metrics/_regression.py
  function _check_reg_targets (line 60) | def _check_reg_targets(y_true, y_pred, multioutput, dtype="numeric"):
  function mean_absolute_error (line 135) | def mean_absolute_error(
  function mean_pinball_loss (line 206) | def mean_pinball_loss(
  function mean_absolute_percentage_error (line 292) | def mean_absolute_percentage_error(
  function mean_squared_error (line 378) | def mean_squared_error(
  function mean_squared_log_error (line 457) | def mean_squared_log_error(
  function median_absolute_error (line 535) | def median_absolute_error(
  function explained_variance_score (line 611) | def explained_variance_score(
  function r2_score (line 702) | def r2_score(y_true, y_pred, *, sample_weight=None, multioutput="uniform...
  function max_error (line 838) | def max_error(y_true, y_pred):
  function mean_tweedie_deviance (line 871) | def mean_tweedie_deviance(y_true, y_pred, *, sample_weight=None, power=0):
  function mean_poisson_deviance (line 936) | def mean_poisson_deviance(y_true, y_pred, *, sample_weight=None):
  function mean_gamma_deviance (line 971) | def mean_gamma_deviance(y_true, y_pred, *, sample_weight=None):
  function d2_tweedie_score (line 1007) | def d2_tweedie_score(y_true, y_pred, *, sample_weight=None, power=0):

FILE: sklearn/metrics/_scorer.py
  function _cached_call (line 65) | def _cached_call(cache, estimator, method, *args, **kwargs):
  class _MultimetricScorer (line 78) | class _MultimetricScorer:
    method __init__ (line 92) | def __init__(self, **scorers):
    method __call__ (line 95) | def __call__(self, estimator, *args, **kwargs):
    method _use_cache (line 109) | def _use_cache(self, estimator):
  class _BaseScorer (line 141) | class _BaseScorer:
    method __init__ (line 142) | def __init__(self, score_func, sign, kwargs):
    method _check_pos_label (line 148) | def _check_pos_label(pos_label, classes):
    method _select_proba_binary (line 152) | def _select_proba_binary(self, y_pred, classes):
    method __repr__ (line 182) | def __repr__(self):
    method __call__ (line 193) | def __call__(self, estimator, X, y_true, sample_weight=None):
    method _factory_args (line 224) | def _factory_args(self):
  class _PredictScorer (line 229) | class _PredictScorer(_BaseScorer):
    method _score (line 230) | def _score(self, method_caller, estimator, X, y_true, sample_weight=No...
  class _ProbaScorer (line 267) | class _ProbaScorer(_BaseScorer):
    method _score (line 268) | def _score(self, method_caller, clf, X, y, sample_weight=None):
    method _factory_args (line 311) | def _factory_args(self):
  class _ThresholdScorer (line 315) | class _ThresholdScorer(_BaseScorer):
    method _score (line 316) | def _score(self, method_caller, clf, X, y, sample_weight=None):
    method _factory_args (line 383) | def _factory_args(self):
  function get_scorer (line 387) | def get_scorer(scoring):
  function _passthrough_scorer (line 416) | def _passthrough_scorer(estimator, *args, **kwargs):
  function check_scoring (line 421) | def check_scoring(estimator, scoring=None, *, allow_none=False):
  function _check_multimetric_scoring (line 494) | def _check_multimetric_scoring(estimator, scoring):
  function make_scorer (line 578) | def make_scorer(

FILE: sklearn/metrics/cluster/_bicluster.py
  function _check_rows_and_columns (line 9) | def _check_rows_and_columns(a, b):
  function _jaccard (line 19) | def _jaccard(a_rows, a_cols, b_rows, b_cols):
  function _pairwise_similarity (line 29) | def _pairwise_similarity(a, b, similarity):
  function consensus_score (line 51) | def consensus_score(a, b, *, similarity="jaccard"):

FILE: sklearn/metrics/cluster/_supervised.py
  function check_clusterings (line 31) | def check_clusterings(labels_true, labels_pred):
  function _generalized_average (line 77) | def _generalized_average(U, V, average_method):
  function contingency_matrix (line 93) | def contingency_matrix(
  function pair_confusion_matrix (line 162) | def pair_confusion_matrix(labels_true, labels_pred):
  function rand_score (line 240) | def rand_score(labels_true, labels_pred):
  function adjusted_rand_score (line 310) | def adjusted_rand_score(labels_true, labels_pred):
  function homogeneity_completeness_v_measure (line 402) | def homogeneity_completeness_v_measure(labels_true, labels_pred, *, beta...
  function homogeneity_score (line 488) | def homogeneity_score(labels_true, labels_pred):
  function completeness_score (line 557) | def completeness_score(labels_true, labels_pred):
  function v_measure_score (line 626) | def v_measure_score(labels_true, labels_pred, *, beta=1.0):
  function mutual_info_score (line 724) | def mutual_info_score(labels_true, labels_pred, *, contingency=None):
  function adjusted_mutual_info_score (line 819) | def adjusted_mutual_info_score(
  function normalized_mutual_info_score (line 943) | def normalized_mutual_info_score(
  function fowlkes_mallows_score (line 1045) | def fowlkes_mallows_score(labels_true, labels_pred, *, sparse=False):
  function entropy (line 1123) | def entropy(labels):

FILE: sklearn/metrics/cluster/_unsupervised.py
  function check_number_of_labels (line 21) | def check_number_of_labels(n_labels, n_samples):
  function silhouette_score (line 39) | def silhouette_score(
  function _silhouette_reduce (line 121) | def _silhouette_reduce(D_chunk, start, labels, label_freqs):
  function silhouette_samples (line 153) | def silhouette_samples(X, labels, *, metric="euclidean", **kwds):
  function calinski_harabasz_score (line 251) | def calinski_harabasz_score(X, labels):
  function davies_bouldin_score (line 305) | def davies_bouldin_score(X, labels):

FILE: sklearn/metrics/cluster/setup.py
  function configuration (line 7) | def configuration(parent_package="", top_path=None):

FILE: sklearn/metrics/cluster/tests/test_bicluster.py
  function test_jaccard (line 11) | def test_jaccard():
  function test_consensus_score (line 23) | def test_consensus_score():
  function test_consensus_score_issue2445 (line 38) | def test_consensus_score_issue2445():

FILE: sklearn/metrics/cluster/tests/test_common.py
  function test_symmetric_non_symmetric_union (line 93) | def test_symmetric_non_symmetric_union():
  function test_symmetry (line 104) | def test_symmetry(metric_name, y1, y2):
  function test_non_symmetry (line 112) | def test_non_symmetry(metric_name, y1, y2):
  function test_normalized_output (line 120) | def test_normalized_output(metric_name):
  function test_permute_labels (line 141) | def test_permute_labels(metric_name):
  function test_format_invariance (line 164) | def test_format_invariance(metric_name):
  function test_single_sample (line 198) | def test_single_sample(metric):
  function test_inf_nan_input (line 207) | def test_inf_nan_input(metric_name, metric_func):

FILE: sklearn/metrics/cluster/tests/test_supervised.py
  function test_error_messages_on_wrong_input (line 38) | def test_error_messages_on_wrong_input():
  function test_generalized_average (line 55) | def test_generalized_average():
  function test_perfect_matches (line 66) | def test_perfect_matches():
  function test_homogeneous_but_not_complete_labeling (line 101) | def test_homogeneous_but_not_complete_labeling():
  function test_complete_but_not_homogeneous_labeling (line 109) | def test_complete_but_not_homogeneous_labeling():
  function test_not_complete_and_not_homogeneous_labeling (line 117) | def test_not_complete_and_not_homogeneous_labeling():
  function test_beta_parameter (line 125) | def test_beta_parameter():
  function test_non_consecutive_labels (line 145) | def test_non_consecutive_labels():
  function uniform_labelings_scores (line 169) | def uniform_labelings_scores(score_func, n_samples, k_range, n_runs=10, ...
  function test_adjustment_for_chance (line 182) | def test_adjustment_for_chance():
  function test_adjusted_mutual_info_score (line 196) | def test_adjusted_mutual_info_score():
  function test_expected_mutual_info_overflow (line 227) | def test_expected_mutual_info_overflow():
  function test_int_overflow_mutual_info_fowlkes_mallows_score (line 233) | def test_int_overflow_mutual_info_fowlkes_mallows_score():
  function test_entropy (line 259) | def test_entropy():
  function test_contingency_matrix (line 265) | def test_contingency_matrix():
  function test_contingency_matrix_sparse (line 275) | def test_contingency_matrix_sparse():
  function test_exactly_zero_info_score (line 286) | def test_exactly_zero_info_score():
  function test_v_measure_and_mutual_information (line 303) | def test_v_measure_and_mutual_information(seed=36):
  function test_fowlkes_mallows_score (line 325) | def test_fowlkes_mallows_score():
  function test_fowlkes_mallows_score_properties (line 339) | def test_fowlkes_mallows_score_properties():
  function test_mutual_info_score_positive_constant_label (line 371) | def test_mutual_info_score_positive_constant_label(labels_true, labels_p...
  function test_check_clustering_error (line 376) | def test_check_clustering_error():
  function test_pair_confusion_matrix_fully_dispersed (line 391) | def test_pair_confusion_matrix_fully_dispersed():
  function test_pair_confusion_matrix_single_cluster (line 400) | def test_pair_confusion_matrix_single_cluster():
  function test_pair_confusion_matrix (line 409) | def test_pair_confusion_matrix():
  function test_rand_score_edge_cases (line 430) | def test_rand_score_edge_cases(clustering1, clustering2):
  function test_rand_score (line 436) | def test_rand_score():
  function test_adjusted_rand_score_overflow (line 452) | def test_adjusted_rand_score_overflow():

FILE: sklearn/metrics/cluster/tests/test_unsupervised.py
  function test_silhouette (line 15) | def test_silhouette():
  function test_cluster_size_1 (line 56) | def test_cluster_size_1():
  function test_silhouette_paper_example (line 79) | def test_silhouette_paper_example():
  function test_correct_labelsize (line 221) | def test_correct_labelsize():
  function test_non_encoded_labels (line 245) | def test_non_encoded_labels():
  function test_non_numpy_labels (line 255) | def test_non_numpy_labels():
  function test_silhouette_nonzero_diag (line 263) | def test_silhouette_nonzero_diag(dtype):
  function assert_raises_on_only_one_label (line 283) | def assert_raises_on_only_one_label(func):
  function assert_raises_on_all_points_same_cluster (line 290) | def assert_raises_on_all_points_same_cluster(func):
  function test_calinski_harabasz_score (line 297) | def test_calinski_harabasz_score():
  function test_davies_bouldin_score (line 319) | def test_davies_bouldin_score():

FILE: sklearn/metrics/pairwise.py
  function _return_float_dtype (line 39) | def _return_float_dtype(X, Y):
  function check_pairwise_arrays (line 63) | def check_pairwise_arrays(
  function check_paired_arrays (line 189) | def check_paired_arrays(X, Y):
  function euclidean_distances (line 226) | def euclidean_distances(
  function _euclidean_distances (line 333) | def _euclidean_distances(X, Y, X_norm_squared=None, Y_norm_squared=None,...
  function nan_euclidean_distances (line 384) | def nan_euclidean_distances(
  function _euclidean_distances_upcast (line 501) | def _euclidean_distances_upcast(X, XX=None, Y=None, YY=None, batch_size=...
  function _argmin_min_reduce (line 574) | def _argmin_min_reduce(dist, start):
  function pairwise_distances_argmin_min (line 580) | def pairwise_distances_argmin_min(
  function pairwise_distances_argmin (line 669) | def pairwise_distances_argmin(X, Y, *, axis=1, metric="euclidean", metri...
  function haversine_distances (line 741) | def haversine_distances(X, Y=None):
  function manhattan_distances (line 791) | def manhattan_distances(X, Y=None, *, sum_over_features=True):
  function cosine_distances (line 872) | def cosine_distances(X, Y=None):
  function paired_euclidean_distances (line 910) | def paired_euclidean_distances(X, Y):
  function paired_manhattan_distances (line 930) | def paired_manhattan_distances(X, Y):
  function paired_cosine_distances (line 954) | def paired_cosine_distances(X, Y):
  function paired_distances (line 989) | def paired_distances(X, Y, *, metric="euclidean", **kwds):
  function linear_kernel (line 1047) | def linear_kernel(X, Y=None, dense_output=True):
  function polynomial_kernel (line 1076) | def polynomial_kernel(X, Y=None, degree=3, gamma=None, coef0=1):
  function sigmoid_kernel (line 1112) | def sigmoid_kernel(X, Y=None, gamma=None, coef0=1):
  function rbf_kernel (line 1147) | def rbf_kernel(X, Y=None, gamma=None):
  function laplacian_kernel (line 1181) | def laplacian_kernel(X, Y=None, gamma=None):
  function cosine_similarity (line 1216) | def cosine_similarity(X, Y=None, dense_output=True):
  function additive_chi2_kernel (line 1264) | def additive_chi2_kernel(X, Y=None):
  function chi2_kernel (line 1325) | def chi2_kernel(X, Y=None, gamma=1.0):
  function distance_metrics (line 1388) | def distance_metrics():
  function _dist_wrapper (line 1416) | def _dist_wrapper(dist_func, dist_matrix, slice_, *args, **kwargs):
  function _parallel_pairwise (line 1421) | def _parallel_pairwise(X, Y, func, n_jobs, **kwds):
  function _pairwise_callable (line 1448) | def _pairwise_callable(X, Y, metric, force_all_finite=True, **kwds):
  function _check_chunk_size (line 1512) | def _check_chunk_size(reduced, chunk_size):
  function _precompute_metric_params (line 1533) | def _precompute_metric_params(X, Y, metric=None, **kwds):
  function pairwise_distances_chunked (line 1559) | def pairwise_distances_chunked(
  function pairwise_distances (line 1731) | def pairwise_distances(
  function kernel_metrics (line 1921) | def kernel_metrics():
  function pairwise_kernels (line 1961) | def pairwise_kernels(

FILE: sklearn/metrics/setup.py
  function configuration (line 7) | def configuration(parent_package="", top_path=None):

FILE: sklearn/metrics/tests/test_classification.py
  function make_prediction (line 55) | def make_prediction(dataset=None, binary=False):
  function test_classification_report_dictionary_output (line 103) | def test_classification_report_dictionary_output():
  function test_classification_report_output_dict_empty_input (line 169) | def test_classification_report_output_dict_empty_input():
  function test_classification_report_zero_division_warning (line 200) | def test_classification_report_zero_division_warning(zero_division):
  function test_multilabel_accuracy_score_subset_accuracy (line 215) | def test_multilabel_accuracy_score_subset_accuracy():
  function test_precision_recall_f1_score_binary (line 229) | def test_precision_recall_f1_score_binary():
  function test_precision_recall_f_binary_single_class (line 264) | def test_precision_recall_f_binary_single_class():
  function test_precision_recall_f_extra_labels (line 283) | def test_precision_recall_f_extra_labels():
  function test_precision_recall_f_ignored_labels (line 329) | def test_precision_recall_f_ignored_labels():
  function test_average_precision_score_score_non_binary_class (line 351) | def test_average_precision_score_score_non_binary_class():
  function test_average_precision_score_duplicate_values (line 364) | def test_average_precision_score_duplicate_values():
  function test_average_precision_score_tied_values (line 375) | def test_average_precision_score_tied_values():
  function test_precision_recall_fscore_support_errors (line 389) | def test_precision_recall_fscore_support_errors():
  function test_precision_recall_f_unused_pos_label (line 405) | def test_precision_recall_f_unused_pos_label():
  function test_confusion_matrix_binary (line 421) | def test_confusion_matrix_binary():
  function test_multilabel_confusion_matrix_binary (line 442) | def test_multilabel_confusion_matrix_binary():
  function test_multilabel_confusion_matrix_multiclass (line 454) | def test_multilabel_confusion_matrix_multiclass():
  function test_multilabel_confusion_matrix_multilabel (line 489) | def test_multilabel_confusion_matrix_multilabel():
  function test_multilabel_confusion_matrix_errors (line 530) | def test_multilabel_confusion_matrix_errors():
  function test_confusion_matrix_normalize (line 569) | def test_confusion_matrix_normalize(normalize, cm_dtype, expected_results):
  function test_confusion_matrix_normalize_wrong_option (line 577) | def test_confusion_matrix_normalize_wrong_option():
  function test_confusion_matrix_normalize_single_class (line 584) | def test_confusion_matrix_normalize_single_class():
  function test_cohen_kappa (line 602) | def test_cohen_kappa():
  function test_matthews_corrcoef_nan (line 633) | def test_matthews_corrcoef_nan():
  function test_matthews_corrcoef_against_numpy_corrcoef (line 638) | def test_matthews_corrcoef_against_numpy_corrcoef():
  function test_matthews_corrcoef_against_jurman (line 648) | def test_matthews_corrcoef_against_jurman():
  function test_matthews_corrcoef (line 687) | def test_matthews_corrcoef():
  function test_matthews_corrcoef_multiclass (line 722) | def test_matthews_corrcoef_multiclass():
  function test_matthews_corrcoef_overflow (line 779) | def test_matthews_corrcoef_overflow(n_points):
  function test_precision_recall_f1_score_multiclass (line 812) | def test_precision_recall_f1_score_multiclass():
  function test_precision_refcall_f1_score_multilabel_unordered_labels (line 871) | def test_precision_refcall_f1_score_multilabel_unordered_labels(average):
  function test_precision_recall_f1_score_binary_averaged (line 885) | def test_precision_recall_f1_score_binary_averaged():
  function test_zero_precision_recall (line 902) | def test_zero_precision_recall():
  function test_confusion_matrix_multiclass_subset_labels (line 919) | def test_confusion_matrix_multiclass_subset_labels():
  function test_confusion_matrix_error (line 946) | def test_confusion_matrix_error(labels, err_msg):
  function test_confusion_matrix_on_zero_length_input (line 955) | def test_confusion_matrix_on_zero_length_input(labels):
  function test_confusion_matrix_dtype (line 962) | def test_confusion_matrix_dtype():
  function test_classification_report_multiclass (line 989) | def test_classification_report_multiclass():
  function test_classification_report_multiclass_balanced (line 1015) | def test_classification_report_multiclass_balanced():
  function test_classification_report_multiclass_with_label_detection (line 1033) | def test_classification_report_multiclass_with_label_detection():
  function test_classification_report_multiclass_with_digits (line 1053) | def test_classification_report_multiclass_with_digits():
  function test_classification_report_multiclass_with_string_label (line 1080) | def test_classification_report_multiclass_with_string_label():
  function test_classification_report_multiclass_with_unicode_label (line 1115) | def test_classification_report_multiclass_with_unicode_label():
  function test_classification_report_multiclass_with_long_string_label (line 1137) | def test_classification_report_multiclass_with_long_string_label():
  function test_classification_report_labels_target_names_unequal_length (line 1160) | def test_classification_report_labels_target_names_unequal_length():
  function test_classification_report_no_labels_target_names_unequal_length (line 1170) | def test_classification_report_no_labels_target_names_unequal_length():
  function test_multilabel_classification_report (line 1185) | def test_multilabel_classification_report():
  function test_multilabel_zero_one_loss_subset (line 1215) | def test_multilabel_zero_one_loss_subset():
  function test_multilabel_hamming_loss (line 1229) | def test_multilabel_hamming_loss():
  function test_jaccard_score_validation (line 1249) | def test_jaccard_score_validation():
  function test_multilabel_jaccard_score (line 1289) | def test_multilabel_jaccard_score(recwarn):
  function test_multiclass_jaccard_score (line 1366) | def test_multiclass_jaccard_score(recwarn):
  function test_average_binary_jaccard_score (line 1403) | def test_average_binary_jaccard_score(recwarn):
  function test_jaccard_score_zero_division_warning (line 1426) | def test_jaccard_score_zero_division_warning():
  function test_jaccard_score_zero_division_set_value (line 1442) | def test_jaccard_score_zero_division_set_value(zero_division, expected_s...
  function test_precision_recall_f1_score_multilabel_1 (line 1455) | def test_precision_recall_f1_score_multilabel_1():
  function test_precision_recall_f1_score_multilabel_2 (line 1522) | def test_precision_recall_f1_score_multilabel_2():
  function test_precision_recall_f1_score_with_an_empty_prediction (line 1588) | def test_precision_recall_f1_score_with_an_empty_prediction(zero_division):
  function test_precision_recall_f1_no_labels (line 1667) | def test_precision_recall_f1_no_labels(beta, average, zero_division):
  function test_precision_recall_f1_no_labels_check_warnings (line 1698) | def test_precision_recall_f1_no_labels_check_warnings(average):
  function test_precision_recall_f1_no_labels_average_none (line 1718) | def test_precision_recall_f1_no_labels_average_none(zero_division):
  function test_precision_recall_f1_no_labels_average_none_warn (line 1751) | def test_precision_recall_f1_no_labels_average_none_warn():
  function test_prf_warnings (line 1779) | def test_prf_warnings():
  function test_prf_no_warnings_if_zero_division_set (line 1879) | def test_prf_no_warnings_if_zero_division_set(zero_division):
  function test_recall_warnings (line 1944) | def test_recall_warnings(zero_division):
  function test_precision_warnings (line 1983) | def test_precision_warnings(zero_division):
  function test_fscore_warnings (line 2023) | def test_fscore_warnings(zero_division):
  function test_prf_average_binary_data_non_binary (line 2062) | def test_prf_average_binary_data_non_binary():
  function test__check_targets (line 2093) | def test__check_targets():
  function test__check_targets_multiclass_with_both_y_true_and_y_pred_binary (line 2191) | def test__check_targets_multiclass_with_both_y_true_and_y_pred_binary():
  function test_hinge_loss_binary (line 2198) | def test_hinge_loss_binary():
  function test_hinge_loss_multiclass (line 2208) | def test_hinge_loss_multiclass():
  function test_hinge_loss_multiclass_missing_labels_with_labels_none (line 2235) | def test_hinge_loss_multiclass_missing_labels_with_labels_none():
  function test_hinge_loss_multiclass_no_consistent_pred_decision_shape (line 2252) | def test_hinge_loss_multiclass_no_consistent_pred_decision_shape():
  function test_hinge_loss_multiclass_with_missing_labels (line 2280) | def test_hinge_loss_multiclass_with_missing_labels():
  function test_hinge_loss_multiclass_missing_labels_only_two_unq_in_y_true (line 2306) | def test_hinge_loss_multiclass_missing_labels_only_two_unq_in_y_true():
  function test_hinge_loss_multiclass_invariance_lists (line 2338) | def test_hinge_loss_multiclass_invariance_lists():
  function test_log_loss (line 2366) | def test_log_loss():
  function test_log_loss_pandas_input (line 2434) | def test_log_loss_pandas_input():
  function test_brier_score_loss (line 2452) | def test_brier_score_loss():
  function test_balanced_accuracy_score_unseen (line 2487) | def test_balanced_accuracy_score_unseen():
  function test_balanced_accuracy_score (line 2501) | def test_balanced_accuracy_score(y_true, y_pred):

FILE: sklearn/metrics/tests/test_common.py
  function precision_recall_curve_padded_thresholds (line 174) | def precision_recall_curve_padded_thresholds(*args, **kwargs):
  function _require_positive_targets (line 536) | def _require_positive_targets(y1, y2):
  function test_symmetry_consistency (line 544) | def test_symmetry_consistency():
  function test_symmetric_metric (line 558) | def test_symmetric_metric(name):
  function test_not_symmetric_metric (line 589) | def test_not_symmetric_metric(name):
  function test_sample_order_invariance (line 609) | def test_sample_order_invariance(name):
  function test_sample_order_invariance_multilabel_and_multioutput (line 629) | def test_sample_order_invariance_multilabel_and_multioutput():
  function test_format_invariance_with_1d_vectors (line 674) | def test_format_invariance_with_1d_vectors(name):
  function test_classification_invariance_string_vs_numbers_labels (line 795) | def test_classification_invariance_string_vs_numbers_labels(name):
  function test_thresholded_invariance_string_vs_numbers_labels (line 849) | def test_thresholded_invariance_string_vs_numbers_labels(name):
  function test_regression_thresholded_inf_nan_input (line 904) | def test_regression_thresholded_inf_nan_input(metric, y_true, y_score):
  function test_classification_inf_nan_input (line 921) | def test_classification_inf_nan_input(metric, y_true, y_score):
  function test_classification_binary_continuous_input (line 944) | def test_classification_binary_continuous_input(metric):
  function check_single_sample (line 956) | def check_single_sample(name):
  function check_single_sample_multioutput (line 973) | def check_single_sample_multioutput(name):
  function test_single_sample (line 989) | def test_single_sample(name):
  function test_single_sample_multioutput (line 994) | def test_single_sample_multioutput(name):
  function test_multioutput_number_of_output_differ (line 999) | def test_multioutput_number_of_output_differ(name):
  function test_multioutput_regression_invariance_to_dimension_shuffling (line 1009) | def test_multioutput_regression_invariance_to_dimension_shuffling(name):
  function test_multilabel_representation_invariance (line 1028) | def test_multilabel_representation_invariance():
  function test_raise_value_error_multilabel_sequences (line 1104) | def test_raise_value_error_multilabel_sequences(name):
  function test_normalize_option_binary_classification (line 1121) | def test_normalize_option_binary_classification(name):
  function test_normalize_option_multiclass_classification (line 1150) | def test_normalize_option_multiclass_classification(name):
  function test_normalize_option_multilabel_classification (line 1181) | def test_normalize_option_multilabel_classification(name):
  function _check_averaging (line 1229) | def _check_averaging(
  function check_averaging (line 1283) | def check_averaging(name, y_true, y_true_binarize, y_pred, y_pred_binari...
  function test_averaging_multiclass (line 1301) | def test_averaging_multiclass(name):
  function test_averaging_multilabel (line 1318) | def test_averaging_multilabel(name):
  function test_averaging_multilabel_all_zeroes (line 1337) | def test_averaging_multilabel_all_zeroes(name):
  function test_averaging_binary_multilabel_all_zeroes (line 1347) | def test_averaging_binary_multilabel_all_zeroes():
  function test_averaging_multilabel_all_ones (line 1367) | def test_averaging_multilabel_all_ones(name):
  function check_sample_weight_invariance (line 1378) | def check_sample_weight_invariance(name, metric, y1, y2):
  function test_regression_sample_weight_invariance (line 1482) | def test_regression_sample_weight_invariance(name):
  function test_binary_sample_weight_invariance (line 1501) | def test_binary_sample_weight_invariance(name):
  function test_multiclass_sample_weight_invariance (line 1524) | def test_multiclass_sample_weight_invariance(name):
  function test_multilabel_sample_weight_invariance (line 1548) | def test_multilabel_sample_weight_invariance(name):
  function test_no_averaging_labels (line 1569) | def test_no_averaging_labels():
  function test_multilabel_label_permutations_invariance (line 1597) | def test_multilabel_label_permutations_invariance(name):
  function test_thresholded_multilabel_multioutput_permutations_invariance (line 1618) | def test_thresholded_multilabel_multioutput_permutations_invariance(name):
  function test_thresholded_metric_permutation_invariance (line 1651) | def test_thresholded_metric_permutation_invariance(name):
  function test_metrics_consistent_type_error (line 1673) | def test_metrics_consistent_type_error(metric_name):
  function test_metrics_pos_label_error_str (line 1700) | def test_metrics_pos_label_error_str(metric, y_pred_threshold, dtype_y_s...

FILE: sklearn/metrics/tests/test_dist_metrics.py
  function dist_func (line 16) | def dist_func(x1, x2, p):
  function test_cdist (line 66) | def test_cdist(metric, X1, X2):
  function test_cdist_bool_metric (line 94) | def test_cdist_bool_metric(metric, X1_bool, X2_bool):
  function check_cdist (line 99) | def check_cdist(metric, kwargs, D_true):
  function check_cdist_bool (line 105) | def check_cdist_bool(metric, D_true):
  function test_pdist (line 113) | def test_pdist(metric, X1, X2):
  function test_pdist_bool_metrics (line 139) | def test_pdist_bool_metrics(metric, X1_bool):
  function check_pdist (line 144) | def check_pdist(metric, kwargs, D_true):
  function check_pdist_bool (line 150) | def check_pdist_bool(metric, D_true):
  function test_pickle (line 163) | def test_pickle(use_read_only_kwargs, metric):
  function test_pickle_bool_metrics (line 177) | def test_pickle_bool_metrics(metric, X1_bool):
  function check_pickle (line 185) | def check_pickle(metric, kwargs):
  function test_haversine_metric (line 193) | def test_haversine_metric():
  function test_pyfunc_metric (line 216) | def test_pyfunc_metric():
  function test_input_data_size (line 237) | def test_input_data_size():
  function test_readonly_kwargs (line 252) | def test_readonly_kwargs():

FILE: sklearn/metrics/tests/test_pairwise.py
  function test_pairwise_distances (line 60) | def test_pairwise_distances():
  function test_pairwise_boolean_distance (line 170) | def test_pairwise_boolean_distance(metric):
  function test_no_data_conversion_warning (line 200) | def test_no_data_conversion_warning():
  function test_pairwise_precomputed (line 210) | def test_pairwise_precomputed(func):
  function test_pairwise_precomputed_non_negative (line 239) | def test_pairwise_precomputed_non_negative():
  function callable_rbf_kernel (line 249) | def callable_rbf_kernel(x, y, **kwds):
  function test_pairwise_parallel (line 300) | def test_pairwise_parallel(func, metric, kwds, dtype):
  function test_pairwise_callable_nonstrict_metric (line 314) | def test_pairwise_callable_nonstrict_metric():
  function test_pairwise_kernels (line 326) | def test_pairwise_kernels(metric):
  function test_pairwise_kernels_callable (line 359) | def test_pairwise_kernels_callable():
  function test_pairwise_kernels_filter_param (line 378) | def test_pairwise_kernels_filter_param():
  function test_paired_distances (line 392) | def test_paired_distances(metric, func):
  function test_paired_distances_callable (line 413) | def test_paired_distances_callable():
  function test_pairwise_distances_argmin_min (line 433) | def test_pairwise_distances_argmin_min():
  function _reduce_func (line 507) | def _reduce_func(dist, start):
  function test_pairwise_distances_chunked_reduce (line 511) | def test_pairwise_distances_chunked_reduce():
  function test_pairwise_distances_chunked_reduce_none (line 526) | def test_pairwise_distances_chunked_reduce_none():
  function test_pairwise_distances_chunked_reduce_valid (line 549) | def test_pairwise_distances_chunked_reduce_valid(good_reduce):
  function test_pairwise_distances_chunked_reduce_invalid (line 588) | def test_pairwise_distances_chunked_reduce_invalid(bad_reduce, err_type,...
  function check_pairwise_distances_chunked (line 597) | def check_pairwise_distances_chunked(X, Y, working_memory, metric="eucli...
  function test_pairwise_distances_chunked_diagonal (line 614) | def test_pairwise_distances_chunked_diagonal(metric):
  function test_parallel_pairwise_distances_diagonal (line 623) | def test_parallel_pairwise_distances_diagonal(metric):
  function test_pairwise_distances_chunked (line 631) | def test_pairwise_distances_chunked():
  function test_euclidean_distances_known_result (line 676) | def test_euclidean_distances_known_result(x_array_constr, y_array_constr):
  function test_euclidean_distances_with_norms (line 688) | def test_euclidean_distances_with_norms(dtype, y_array_constr):
  function test_euclidean_distances_norm_shapes (line 720) | def test_euclidean_distances_norm_shapes():
  function test_euclidean_distances (line 761) | def test_euclidean_distances(dtype, x_array_constr, y_array_constr):
  function test_euclidean_distances_sym (line 786) | def test_euclidean_distances_sym(dtype, x_array_constr):
  function test_euclidean_distances_upcast (line 811) | def test_euclidean_distances_upcast(batch_size, x_array_constr, y_array_...
  function test_euclidean_distances_upcast_sym (line 835) | def test_euclidean_distances_upcast_sym(batch_size, x_array_constr):
  function test_euclidean_distances_extreme_values (line 865) | def test_euclidean_distances_extreme_values(dtype, eps, rtol, dim):
  function test_nan_euclidean_distances_equal_to_euclidean_distance (line 878) | def test_nan_euclidean_distances_equal_to_euclidean_distance(squared):
  function test_nan_euclidean_distances_infinite_values (line 891) | def test_nan_euclidean_distances_infinite_values(X, Y):
  function test_nan_euclidean_distances_2x2 (line 915) | def test_nan_euclidean_distances_2x2(X, X_diag, missing_value):
  function test_nan_euclidean_distances_complete_nan (line 933) | def test_nan_euclidean_distances_complete_nan(missing_value):
  function test_nan_euclidean_distances_not_trival (line 946) | def test_nan_euclidean_distances_not_trival(missing_value):
  function test_nan_euclidean_distances_one_feature_match_positive (line 999) | def test_nan_euclidean_distances_one_feature_match_positive(missing_value):
  function test_cosine_distances (line 1019) | def test_cosine_distances():
  function test_haversine_distances (line 1049) | def test_haversine_distances():
  function test_paired_euclidean_distances (line 1076) | def test_paired_euclidean_distances():
  function test_paired_manhattan_distances (line 1084) | def test_paired_manhattan_distances():
  function test_chi_square_kernel (line 1092) | def test_chi_square_kernel():
  function test_kernel_symmetry (line 1163) | def test_kernel_symmetry(kernel):
  function test_kernel_sparse (line 1182) | def test_kernel_sparse(kernel):
  function test_linear_kernel (line 1191) | def test_linear_kernel():
  function test_rbf_kernel (line 1199) | def test_rbf_kernel():
  function test_laplacian_kernel (line 1207) | def test_laplacian_kernel():
  function test_pairwise_similarity_sparse_output (line 1222) | def test_pairwise_similarity_sparse_output(metric, pairwise_func):
  function test_cosine_similarity (line 1243) | def test_cosine_similarity():
  function test_check_dense_matrices (line 1263) | def test_check_dense_matrices():
  function test_check_XB_returned (line 1272) | def test_check_XB_returned():
  function test_check_different_dimensions (line 1288) | def test_check_different_dimensions():
  function test_check_invalid_dimensions (line 1300) | def test_check_invalid_dimensions():
  function test_check_sparse_arrays (line 1314) | def test_check_sparse_arrays():
  function tuplify (line 1336) | def tuplify(X):
  function test_check_tuple_input (line 1347) | def test_check_tuple_input():
  function test_check_preserve_type (line 1359) | def test_check_preserve_type():
  function test_pairwise_distances_data_derived_params (line 1388) | def test_pairwise_distances_data_derived_params(n_jobs, metric, dist_fun...
  function test_pairwise_distances_data_derived_params_error (line 1402) | def test_pairwise_distances_data_derived_params_error(metric):
  function test_numeric_pairwise_distances_datatypes (line 1435) | def test_numeric_pairwise_distances_datatypes(metric, dtype, y_is_x):

FILE: sklearn/metrics/tests/test_ranking.py
  function make_prediction (line 50) | def make_prediction(dataset=None, binary=False):
  function _auc (line 98) | def _auc(y_true, y_score):
  function _average_precision (line 113) | def _average_precision(y_true, y_score):
  function _average_precision_slow (line 143) | def _average_precision_slow(y_true, y_score):
  function _partial_roc_auc_score (line 162) | def _partial_roc_auc_score(y_true, y_predict, max_fpr):
  function test_roc_curve (line 191) | def test_roc_curve(drop):
  function test_roc_curve_end_points (line 204) | def test_roc_curve_end_points():
  function test_roc_returns_consistency (line 217) | def test_roc_returns_consistency():
  function test_roc_curve_multi (line 236) | def test_roc_curve_multi():
  function test_roc_curve_confidence (line 244) | def test_roc_curve_confidence():
  function test_roc_curve_hard (line 255) | def test_roc_curve_hard():
  function test_roc_curve_one_label (line 283) | def test_roc_curve_one_label():
  function test_roc_curve_toydata (line 310) | def test_roc_curve_toydata():
  function test_roc_curve_drop_intermediate (line 414) | def test_roc_curve_drop_intermediate():
  function test_roc_curve_fpr_tpr_increasing (line 428) | def test_roc_curve_fpr_tpr_increasing():
  function test_auc (line 440) | def test_auc():
  function test_auc_errors (line 459) | def test_auc_errors():
  function test_multiclass_ovo_roc_auc_toydata (line 485) | def test_multiclass_ovo_roc_auc_toydata(y_true, labels):
  function test_multiclass_ovo_roc_auc_toydata_binary (line 537) | def test_multiclass_ovo_roc_auc_toydata_binary(y_true, labels):
  function test_multiclass_ovr_roc_auc_toydata (line 575) | def test_multiclass_ovr_roc_auc_toydata(y_true, labels):
  function test_roc_auc_score_multiclass_labels_error (line 666) | def test_roc_auc_score_multiclass_labels_error(msg, y_true, labels, mult...
  function test_roc_auc_score_multiclass_error (line 717) | def test_roc_auc_score_multiclass_error(msg, kwargs):
  function test_auc_score_non_binary_class (line 729) | def test_auc_score_non_binary_class():
  function test_binary_clf_curve_multiclass_error (line 762) | def test_binary_clf_curve_multiclass_error(curve_func):
  function test_binary_clf_curve_implicit_pos_label (line 772) | def test_binary_clf_curve_implicit_pos_label(curve_func):
  function test_binary_clf_curve_zero_sample_weight (line 808) | def test_binary_clf_curve_zero_sample_weight(curve_func):
  function test_precision_recall_curve (line 820) | def test_precision_recall_curve():
  function _test_precision_recall_curve (line 840) | def _test_precision_recall_curve(y_true, y_score):
  function test_precision_recall_curve_toydata (line 860) | def test_precision_recall_curve_toydata():
  function test_average_precision_constant_values (line 986) | def test_average_precision_constant_values():
  function test_average_precision_score_pos_label_errors (line 1000) | def test_average_precision_score_pos_label_errors():
  function test_score_scale_invariance (line 1019) | def test_score_scale_invariance():
  function test_det_curve_toydata (line 1069) | def test_det_curve_toydata(y_true, y_score, expected_fpr, expected_fnr):
  function test_det_curve_tie_handling (line 1090) | def test_det_curve_tie_handling(y_true, y_score, expected_fpr, expected_...
  function test_det_curve_sanity_check (line 1097) | def test_det_curve_sanity_check():
  function test_det_curve_constant_scores (line 1106) | def test_det_curve_constant_scores(y_score):
  function test_det_curve_perfect_scores (line 1126) | def test_det_curve_perfect_scores(y_true):
  function test_det_curve_bad_input (line 1147) | def test_det_curve_bad_input(y_true, y_pred, err_msg):
  function test_det_curve_pos_label (line 1153) | def test_det_curve_pos_label():
  function check_lrap_toy (line 1179) | def check_lrap_toy(lrap_score):
  function check_zero_or_all_relevant_labels (line 1238) | def check_zero_or_all_relevant_labels(lrap_score):
  function check_lrap_error_raised (line 1261) | def check_lrap_error_raised(lrap_score):
  function check_lrap_only_ties (line 1287) | def check_lrap_only_ties(lrap_score):
  function check_lrap_without_tie_and_increasing_score (line 1302) | def check_lrap_without_tie_and_increasing_score(lrap_score):
  function _my_lrap (line 1329) | def _my_lrap(y_true, y_score):
  function check_alternative_lrap_implementation (line 1367) | def check_alternative_lrap_implementation(
  function test_label_ranking_avp (line 1409) | def test_label_ranking_avp(check, func):
  function test_lrap_error_raised (line 1413) | def test_lrap_error_raised():
  function test_alternative_lrap_implementation (line 1420) | def test_alternative_lrap_implementation(n_samples, n_classes, random_st...
  function test_lrap_sample_weighting_zero_labels (line 1427) | def test_lrap_sample_weighting_zero_labels():
  function test_coverage_error (line 1448) | def test_coverage_error():
  function test_coverage_tie_handling (line 1503) | def test_coverage_tie_handling():
  function test_label_ranking_loss (line 1519) | def test_label_ranking_loss():
  function test_ranking_appropriate_input_shape (line 1570) | def test_ranking_appropriate_input_shape():
  function test_ranking_loss_ties_handling (line 1586) | def test_ranking_loss_ties_handling():
  function test_dcg_score (line 1598) | def test_dcg_score():
  function _test_dcg_score_for (line 1606) | def _test_dcg_score_for(y_true, y_score):
  function test_dcg_ties (line 1617) | def test_dcg_ties():
  function test_ndcg_ignore_ties_with_k (line 1637) | def test_ndcg_ignore_ties_with_k():
  function test_ndcg_invariant (line 1644) | def test_ndcg_invariant():
  function test_ndcg_toy_examples (line 1656) | def test_ndcg_toy_examples(ignore_ties):
  function test_ndcg_score (line 1694) | def test_ndcg_score():
  function _test_ndcg_score_for (line 1702) | def _test_ndcg_score_for(y_true, y_score):
  function test_partial_roc_auc_score (line 1718) | def test_partial_roc_auc_score():
  function test_top_k_accuracy_score (line 1752) | def test_top_k_accuracy_score(y_true, k, true_score):
  function test_top_k_accuracy_score_binary (line 1776) | def test_top_k_accuracy_score_binary(y_score, k, true_score):
  function test_top_k_accuracy_score_multiclass_with_labels (line 1798) | def test_top_k_accuracy_score_multiclass_with_labels(
  function test_top_k_accuracy_score_increasing (line 1817) | def test_top_k_accuracy_score_increasing():
  function test_top_k_accuracy_score_ties (line 1844) | def test_top_k_accuracy_score_ties(y_true, k, true_score):
  function test_top_k_accuracy_score_warning (line 1864) | def test_top_k_accuracy_score_warning(y_true, k):
  function test_top_k_accuracy_score_error (line 1915) | def test_top_k_accuracy_score_error(y_true, labels, msg):

FILE: sklearn/metrics/tests/test_regression.py
  function test_regression_metrics (line 32) | def test_regression_metrics(n_samples=50):
  function test_mean_squared_error_multioutput_raw_value_squared (line 98) | def test_mean_squared_error_multioutput_raw_value_squared():
  function test_multioutput_regression (line 106) | def test_multioutput_regression():
  function test_regression_metrics_at_limits (line 139) | def test_regression_metrics_at_limits():
  function test__check_reg_targets (line 220) | def test__check_reg_targets():
  function test__check_reg_targets_exception (line 246) | def test__check_reg_targets_exception():
  function test_regression_multioutput_array (line 257) | def test_regression_multioutput_array():
  function test_regression_custom_weights (line 325) | def test_regression_custom_weights():
  function test_regression_single_sample (line 354) | def test_regression_single_sample(metric):
  function test_deprecation_positional_arguments_mape (line 365) | def test_deprecation_positional_arguments_mape():
  function test_tweedie_deviance_continuity (line 378) | def test_tweedie_deviance_continuity():
  function test_mean_absolute_percentage_error (line 412) | def test_mean_absolute_percentage_error():
  function test_mean_pinball_loss_on_constant_predictions (line 423) | def test_mean_pinball_loss_on_constant_predictions(distribution, target_...
  function test_dummy_quantile_parameter_tuning (line 473) | def test_dummy_quantile_parameter_tuning():

FILE: sklearn/metrics/tests/test_score_objects.py
  function _require_positive_y (line 130) | def _require_positive_y(y):
  function _make_estimators (line 137) | def _make_estimators(X_train, y_train, y_ml_train):
  function setup_module (line 159) | def setup_module():
  function teardown_module (line 171) | def teardown_module():
  class EstimatorWithoutFit (line 178) | class EstimatorWithoutFit:
  class EstimatorWithFit (line 184) | class EstimatorWithFit(BaseEstimator):
    method fit (line 187) | def fit(self, X, y):
  class EstimatorWithFitAndScore (line 191) | class EstimatorWithFitAndScore:
    method fit (line 194) | def fit(self, X, y):
    method score (line 197) | def score(self, X, y):
  class EstimatorWithFitAndPredict (line 201) | class EstimatorWithFitAndPredict:
    method fit (line 204) | def fit(self, X, y):
    method predict (line 208) | def predict(self, X):
  class DummyScorer (line 212) | class DummyScorer:
    method __call__ (line 215) | def __call__(self, est, X, y):
  function test_all_scorers_repr (line 219) | def test_all_scorers_repr():
  function check_scoring_validator_for_single_metric_usecases (line 225) | def check_scoring_validator_for_single_metric_usecases(scoring_validator):
  function test_check_scoring_and_check_multimetric_scoring (line 285) | def test_check_scoring_and_check_multimetric_scoring(scoring):
  function test_check_scoring_and_check_multimetric_scoring_errors (line 338) | def test_check_scoring_and_check_multimetric_scoring_errors(scoring, msg):
  function test_check_scoring_gridsearchcv (line 348) | def test_check_scoring_gridsearchcv():
  function test_make_scorer (line 369) | def test_make_scorer():
  function test_classification_binary_scores (line 398) | def test_classification_binary_scores(scorer_name, metric):
  function test_classification_multiclass_scores (line 430) | def test_classification_multiclass_scores(scorer_name, metric):
  function test_custom_scorer_pickling (line 449) | def test_custom_scorer_pickling():
  function test_regression_scorers (line 466) | def test_regression_scorers():
  function test_thresholded_scorers (line 478) | def test_thresholded_scorers():
  function test_thresholded_scorers_multilabel_indicator_data (line 529) | def test_thresholded_scorers_multilabel_indicator_data():
  function test_supervised_cluster_scorers (line 571) | def test_supervised_cluster_scorers():
  function test_raises_on_score_list (line 584) | def test_raises_on_score_list():
  function test_classification_scorer_sample_weight (line 599) | def test_classification_scorer_sample_weight():
  function test_regression_scorer_sample_weight (line 656) | def test_regression_scorer_sample_weight():
  function test_scorer_memmap_input (line 702) | def test_scorer_memmap_input(name):
  function test_scoring_is_not_metric (line 723) | def test_scoring_is_not_metric():
  function test_multimetric_scorer_calls_method_once (line 757) | def test_multimetric_scorer_calls_method_once(
  function test_multimetric_scorer_calls_method_once_classifier_no_decision (line 792) | def test_multimetric_scorer_calls_method_once_classifier_no_decision():
  function test_multimetric_scorer_calls_method_once_regressor_threshold (line 815) | def test_multimetric_scorer_calls_method_once_regressor_threshold():
  function test_multimetric_scorer_sanity_check (line 838) | def test_multimetric_scorer_sanity_check():
  function test_multiclass_roc_proba_scorer (line 884) | def test_multiclass_roc_proba_scorer(scorer_name, metric):
  function test_multiclass_roc_proba_scorer_label (line 896) | def test_multiclass_roc_proba_scorer_label():
  function test_multiclass_roc_no_proba_scorer_errors (line 918) | def test_multiclass_roc_no_proba_scorer_errors(scorer_name):
  function string_labeled_classification_problem (line 931) | def string_labeled_classification_problem():
  function test_average_precision_pos_label (line 986) | def test_average_precision_pos_label(string_labeled_classification_probl...
  function test_brier_score_loss_pos_label (line 1050) | def test_brier_score_loss_pos_label(string_labeled_classification_problem):
  function test_non_symmetric_metric_pos_label (line 1077) | def test_non_symmetric_metric_pos_label(
  function test_scorer_select_proba_error (line 1106) | def test_scorer_select_proba_error(scorer):
  function test_scorer_no_op_multiclass_select_proba (line 1120) | def test_scorer_no_op_multiclass_select_proba():

FILE: sklearn/mixture/_base.py
  function _check_shape (line 22) | def _check_shape(param, param_shape, name):
  class BaseMixture (line 41) | class BaseMixture(DensityMixin, BaseEstimator, metaclass=ABCMeta):
    method __init__ (line 48) | def __init__(
    method _check_initial_parameters (line 72) | def _check_initial_parameters(self, X):
    method _check_parameters (line 118) | def _check_parameters(self, X):
    method _initialize_parameters (line 127) | def _initialize_parameters(self, X, random_state):
    method _initialize (line 161) | def _initialize(self, X, resp):
    method fit (line 172) | def fit(self, X, y=None):
    method fit_predict (line 201) | def fit_predict(self, X, y=None):
    method _e_step (line 296) | def _e_step(self, X):
    method _m_step (line 316) | def _m_step(self, X, log_resp):
    method _get_parameters (line 330) | def _get_parameters(self):
    method _set_parameters (line 334) | def _set_parameters(self, params):
    method score_samples (line 337) | def score_samples(self, X):
    method score (line 356) | def score(self, X, y=None):
    method predict (line 375) | def predict(self, X):
    method predict_proba (line 393) | def predict_proba(self, X):
    method sample (line 412) | def sample(self, n_samples=1):
    method _estimate_weighted_log_prob (line 472) | def _estimate_weighted_log_prob(self, X):
    method _estimate_log_weights (line 486) | def _estimate_log_weights(self):
    method _estimate_log_prob (line 496) | def _estimate_log_prob(self, X):
    method _estimate_log_prob_resp (line 511) | def _estimate_log_prob_resp(self, X):
    method _print_verbose_msg_init_beg (line 537) | def _print_verbose_msg_init_beg(self, n_init):
    method _print_verbose_msg_iter_end (line 546) | def _print_verbose_msg_iter_end(self, n_iter, diff_ll):
    method _print_verbose_msg_init_end (line 559) | def _print_verbose_msg_init_end(self, ll):

FILE: sklearn/mixture/_bayesian_mixture.py
  function _log_dirichlet_norm (line 20) | def _log_dirichlet_norm(dirichlet_concentration):
  function _log_wishart_norm (line 38) | def _log_wishart_norm(degrees_of_freedom, log_det_precisions_chol, n_fea...
  class BayesianGaussianMixture (line 69) | class BayesianGaussianMixture(BaseMixture):
    method __init__ (line 339) | def __init__(
    method _check_parameters (line 381) | def _check_parameters(self, X):
    method _check_weights_parameters (line 412) | def _check_weights_parameters(self):
    method _check_means_parameters (line 425) | def _check_means_parameters(self, X):
    method _check_precision_parameters (line 453) | def _check_precision_parameters(self, X):
    method _checkcovariance_prior_parameter (line 473) | def _checkcovariance_prior_parameter(self, X):
    method _initialize (line 520) | def _initialize(self, X, resp):
    method _estimate_weights (line 537) | def _estimate_weights(self, nk):
    method _estimate_means (line 558) | def _estimate_means(self, nk, xk):
    method _estimate_precisions (line 572) | def _estimate_precisions(self, nk, xk, sk):
    method _estimate_wishart_full (line 599) | def _estimate_wishart_full(self, nk, xk, sk):
    method _estimate_wishart_tied (line 635) | def _estimate_wishart_tied(self, nk, xk, sk):
    method _estimate_wishart_diag (line 669) | def _estimate_wishart_diag(self, nk, xk, sk):
    method _estimate_wishart_spherical (line 699) | def _estimate_wishart_spherical(self, nk, xk, sk):
    method _m_step (line 730) | def _m_step(self, X, log_resp):
    method _estimate_log_weights (line 750) | def _estimate_log_weights(self):
    method _estimate_log_prob (line 768) | def _estimate_log_prob(self, X):
    method _compute_lower_bound (line 786) | def _compute_lower_bound(self, log_resp, log_prob_norm):
    method _get_parameters (line 845) | def _get_parameters(self):
    method _set_parameters (line 855) | def _set_parameters(self, params):

FILE: sklearn/mixture/_gaussian_mixture.py
  function _check_weights (line 20) | def _check_weights(weights, n_components):
  function _check_means (line 55) | def _check_means(means, n_components, n_features):
  function _check_precision_positivity (line 78) | def _check_precision_positivity(precision, covariance_type):
  function _check_precision_matrix (line 84) | def _check_precision_matrix(precision, covariance_type):
  function _check_precisions_full (line 94) | def _check_precisions_full(precisions, covariance_type):
  function _check_precisions (line 100) | def _check_precisions(precisions, covariance_type, n_components, n_featu...
  function _estimate_gaussian_covariances_full (line 154) | def _estimate_gaussian_covariances_full(resp, X, nk, means, reg_covar):
  function _estimate_gaussian_covariances_tied (line 183) | def _estimate_gaussian_covariances_tied(resp, X, nk, means, reg_covar):
  function _estimate_gaussian_covariances_diag (line 211) | def _estimate_gaussian_covariances_diag(resp, X, nk, means, reg_covar):
  function _estimate_gaussian_covariances_spherical (line 237) | def _estimate_gaussian_covariances_spherical(resp, X, nk, means, reg_cov...
  function _estimate_gaussian_parameters (line 260) | def _estimate_gaussian_parameters(X, resp, reg_covar, covariance_type):
  function _compute_precision_cholesky (line 300) | def _compute_precision_cholesky(covariances, covariance_type):
  function _compute_log_det_cholesky (line 354) | def _compute_log_det_cholesky(matrix_chol, covariance_type, n_features):
  function _estimate_log_gaussian_prob (line 394) | def _estimate_log_gaussian_prob(X, means, precisions_chol, covariance_ty...
  class GaussianMixture (line 456) | class GaussianMixture(BaseMixture):
    method __init__ (line 636) | def __init__(
    method _check_parameters (line 672) | def _check_parameters(self, X):
    method _initialize (line 699) | def _initialize(self, X, resp):
    method _m_step (line 737) | def _m_step(self, X, log_resp):
    method _estimate_log_prob (line 757) | def _estimate_log_prob(self, X):
    method _estimate_log_weights (line 762) | def _estimate_log_weights(self):
    method _compute_lower_bound (line 765) | def _compute_lower_bound(self, _, log_prob_norm):
    method _get_parameters (line 768) | def _get_parameters(self):
    method _set_parameters (line 776) | def _set_parameters(self, params):
    method _n_parameters (line 799) | def _n_parameters(self):
    method bic (line 813) | def bic(self, X):
    method aic (line 830) | def aic(self, X):

FILE: sklearn/mixture/tests/test_bayesian_mixture.py
  function test_log_dirichlet_norm (line 30) | def test_log_dirichlet_norm():
  function test_log_wishart_norm (line 42) | def test_log_wishart_norm():
  function test_bayesian_mixture_covariance_type (line 70) | def test_bayesian_mixture_covariance_type():
  function test_bayesian_mixture_weight_concentration_prior_type (line 86) | def test_bayesian_mixture_weight_concentration_prior_type():
  function test_bayesian_mixture_weights_prior_initialisation (line 104) | def test_bayesian_mixture_weights_prior_initialisation():
  function test_bayesian_mixture_mean_prior_initialisation (line 133) | def test_bayesian_mixture_mean_prior_initialisation():
  function test_bayesian_mixture_precisions_prior_initialisation (line 182) | def test_bayesian_mixture_precisions_prior_initialisation():
  function test_bayesian_mixture_check_is_fitted (line 259) | def test_bayesian_mixture_check_is_fitted():
  function test_bayesian_mixture_weights (line 272) | def test_bayesian_mixture_weights():
  function test_monotonic_likelihood (line 310) | def test_monotonic_likelihood():
  function test_compare_covar_type (line 342) | def test_compare_covar_type():
  function test_check_covariance_precision (line 415) | def test_check_covariance_precision():
  function test_invariant_translation (line 451) | def test_invariant_translation():
  function test_bayesian_mixture_fit_predict (line 493) | def test_bayesian_mixture_fit_predict(seed, max_iter, tol):
  function test_bayesian_mixture_fit_predict_n_init (line 515) | def test_bayesian_mixture_fit_predict_n_init():
  function test_bayesian_mixture_predict_predict_proba (line 524) | def test_bayesian_mixture_predict_predict_proba():

FILE: sklearn/mixture/tests/test_gaussian_mixture.py
  function generate_data (line 39) | def generate_data(n_samples, n_features, weights, means, precisions, cov...
  class RandomData (line 70) | class RandomData:
    method __init__ (line 71) | def __init__(self, rng, n_samples=200, n_components=2, n_features=2, s...
  function test_gaussian_mixture_attributes (line 123) | def test_gaussian_mixture_attributes():
  function test_check_weights (line 210) | def test_check_weights():
  function test_check_means (line 258) | def test_check_means():
  function test_check_precisions (line 281) | def test_check_precisions():
  function test_suffstat_sk_full (line 338) | def test_suffstat_sk_full():
  function test_suffstat_sk_tied (line 380) | def test_suffstat_sk_tied():
  function test_suffstat_sk_diag (line 410) | def test_suffstat_sk_diag():
  function test_gaussian_suffstat_sk_spherical (line 435) | def test_gaussian_suffstat_sk_spherical():
  function test_compute_log_det_cholesky (line 457) | def test_compute_log_det_cholesky():
  function _naive_lmvnpdf_diag (line 482) | def _naive_lmvnpdf_diag(X, means, covars):
  function test_gaussian_mixture_log_probabilities (line 490) | def test_gaussian_mixture_log_probabilities():
  function test_gaussian_mixture_estimate_log_prob_resp (line 538) | def test_gaussian_mixture_estimate_log_prob_resp():
  function test_gaussian_mixture_predict_predict_proba (line 567) | def test_gaussian_mixture_predict_predict_proba():
  function test_gaussian_mixture_fit_predict (line 607) | def test_gaussian_mixture_fit_predict(seed, max_iter, tol):
  function test_gaussian_mixture_fit_predict_n_init (line 632) | def test_gaussian_mixture_fit_predict_n_init():
  function test_gaussian_mixture_fit (line 641) | def test_gaussian_mixture_fit():
  function test_gaussian_mixture_fit_best_params (line 694) | def test_gaussian_mixture_fit_best_params():
  function test_gaussian_mixture_fit_convergence_warning (line 724) | def test_gaussian_mixture_fit_convergence_warning():
  function test_multiple_init (line 748) | def test_multiple_init():
  function test_gaussian_mixture_n_parameters (line 774) | def test_gaussian_mixture_n_parameters():
  function test_bic_1d_1component (line 787) | def test_bic_1d_1component():
  function test_gaussian_mixture_aic_bic (line 813) | def test_gaussian_mixture_aic_bic():
  function test_gaussian_mixture_verbose (line 837) | def test_gaussian_mixture_verbose():
  function test_warm_start (line 870) | def test_warm_start(seed):
  function test_convergence_detected_with_warm_start (line 938) | def test_convergence_detected_with_warm_start():
  function test_score (line 960) | def test_score():
  function test_score_samples (line 1002) | def test_score_samples():
  function test_monotonic_likelihood (line 1028) | def test_monotonic_likelihood():
  function test_regularisation (line 1062) | def test_regularisation():
  function test_property (line 1094) | def test_property():
  function test_sample (line 1118) | def test_sample():
  function test_init (line 1176) | def test_init():
  function test_gaussian_mixture_setting_best_params (line 1195) | def test_gaussian_mixture_setting_best_params():

FILE: sklearn/mixture/tests/test_mixture.py
  function test_gaussian_mixture_n_iter (line 12) | def test_gaussian_mixture_n_iter(estimator):
  function test_mixture_n_components_greater_than_n_samples_error (line 23) | def test_mixture_n_components_greater_than_n_samples_error(estimator):

FILE: sklearn/model_selection/_search.py
  class ParameterGrid (line 50) | class ParameterGrid:
    method __init__ (line 94) | def __init__(self, param_grid):
    method __iter__ (line 118) | def __iter__(self):
    method __len__ (line 138) | def __len__(self):
    method __getitem__ (line 146) | def __getitem__(self, ind):
  class ParameterSampler (line 188) | class ParameterSampler:
    method __init__ (line 244) | def __init__(self, param_distributions, n_iter, *, random_state=None):
    method _is_all_lists (line 274) | def _is_all_lists(self):
    method __iter__ (line 280) | def __iter__(self):
    method __len__ (line 315) | def __len__(self):
  function _check_param_grid (line 324) | def _check_param_grid(param_grid):
  function _check_refit (line 348) | def _check_refit(search_cv, attr):
  function _estimator_has (line 358) | def _estimator_has(attr):
  class BaseSearchCV (line 382) | class BaseSearchCV(MetaEstimatorMixin, BaseEstimator, metaclass=ABCMeta):
    method __init__ (line 386) | def __init__(
    method _estimator_type (line 411) | def _estimator_type(self):
    method _more_tags (line 414) | def _more_tags(self):
    method _pairwise (line 430) | def _pairwise(self):
    method score (line 434) | def score(self, X, y=None):
    method score_samples (line 479) | def score_samples(self, X):
    method predict (line 502) | def predict(self, X):
    method predict_proba (line 524) | def predict_proba(self, X):
    method predict_log_proba (line 547) | def predict_log_proba(self, X):
    method decision_function (line 570) | def decision_function(self, X):
    method transform (line 593) | def transform(self, X):
    method inverse_transform (line 615) | def inverse_transform(self, Xt):
    method n_features_in_ (line 637) | def n_features_in_(self):
    method classes_ (line 656) | def classes_(self):
    method _run_search (line 664) | def _run_search(self, evaluate_candidates):
    method _check_refit_for_multimetric (line 724) | def _check_refit_for_multimetric(self, scores):
    method _select_best_index (line 745) | def _select_best_index(refit, refit_metric, results):
    method fit (line 759) | def fit(self, X, y=None, *, groups=None, **fit_params):
    method _format_results (line 943) | def _format_results(self, candidate_params, n_splits, out, more_result...
  class GridSearchCV (line 1037) | class GridSearchCV(BaseSearchCV):
    method __init__ (line 1362) | def __init__(
    method _run_search (line 1390) | def _run_search(self, evaluate_candidates):
  class RandomizedSearchCV (line 1395) | class RandomizedSearchCV(BaseSearchCV):
    method __init__ (line 1733) | def __init__(
    method _run_search (line 1764) | def _run_search(self, evaluate_candidates):

FILE: sklearn/model_selection/_search_successive_halving.py
  class _SubsampleMetaSplitter (line 20) | class _SubsampleMetaSplitter:
    method __init__ (line 23) | def __init__(self, *, base_cv, fraction, subsample_test, random_state):
    method split (line 29) | def split(self, X, y, groups=None):
  function _top_k (line 47) | def _top_k(results, k, itr):
  class BaseSuccessiveHalving (line 58) | class BaseSuccessiveHalving(BaseSearchCV):
    method __init__ (line 66) | def __init__(
    method _check_input_parameters (line 102) | def _check_input_parameters(self, X, y, groups):
    method _select_best_index (line 209) | def _select_best_index(refit, refit_metric, results):
    method fit (line 223) | def fit(self, X, y=None, groups=None, **fit_params):
    method _run_search (line 269) | def _run_search(self, evaluate_candidates):
    method _generate_candidate_params (line 380) | def _generate_candidate_params(self):
    method _more_tags (line 383) | def _more_tags(self):
  class HalvingGridSearchCV (line 396) | class HalvingGridSearchCV(BaseSuccessiveHalving):
    method __init__ (line 681) | def __init__(
    method _generate_candidate_params (line 719) | def _generate_candidate_params(self):
  class HalvingRandomSearchCV (line 723) | class HalvingRandomSearchCV(BaseSuccessiveHalving):
    method __init__ (line 1023) | def __init__(
    method _generate_candidate_params (line 1062) | def _generate_candidate_params(self):

FILE: sklearn/model_selection/_split.py
  class BaseCrossValidator (line 54) | class BaseCrossValidator(metaclass=ABCMeta):
    method split (line 60) | def split(self, X, y=None, groups=None):
    method _iter_test_masks (line 93) | def _iter_test_masks(self, X=None, y=None, groups=None):
    method _iter_test_indices (line 103) | def _iter_test_indices(self, X=None, y=None, groups=None):
    method get_n_splits (line 108) | def get_n_splits(self, X=None, y=None, groups=None):
    method __repr__ (line 111) | def __repr__(self):
  class LeaveOneOut (line 115) | class LeaveOneOut(BaseCrossValidator):
    method _iter_test_indices (line 160) | def _iter_test_indices(self, X, y=None, groups=None):
    method get_n_splits (line 168) | def get_n_splits(self, X, y=None, groups=None):
  class LeavePOut (line 193) | class LeavePOut(BaseCrossValidator):
    method __init__ (line 239) | def __init__(self, p):
    method _iter_test_indices (line 242) | def _iter_test_indices(self, X, y=None, groups=None):
    method get_n_splits (line 253) | def get_n_splits(self, X, y=None, groups=None):
  class _BaseKFold (line 273) | class _BaseKFold(BaseCrossValidator, metaclass=ABCMeta):
    method __init__ (line 277) | def __init__(self, n_splits, *, shuffle, random_state):
    method split (line 306) | def split(self, X, y=None, groups=None):
    method get_n_splits (line 343) | def get_n_splits(self, X=None, y=None, groups=None):
  class KFold (line 365) | class KFold(_BaseKFold):
    method __init__ (line 434) | def __init__(self, n_splits=5, *, shuffle=False, random_state=None):
    method _iter_test_indices (line 437) | def _iter_test_indices(self, X, y=None, groups=None):
  class GroupKFold (line 453) | class GroupKFold(_BaseKFold):
    method __init__ (line 505) | def __init__(self, n_splits=5):
    method _iter_test_indices (line 508) | def _iter_test_indices(self, X, y, groups):
    method split (line 546) | def split(self, X, y=None, groups=None):
  class StratifiedKFold (line 573) | class StratifiedKFold(_BaseKFold):
    method __init__ (line 643) | def __init__(self, n_splits=5, *, shuffle=False, random_state=None):
    method _make_test_folds (line 646) | def _make_test_folds(self, X, y=None):
    method _iter_test_masks (line 708) | def _iter_test_masks(self, X, y=None, groups=None):
    method split (line 713) | def split(self, X, y, groups=None):
  class StratifiedGroupKFold (line 751) | class StratifiedGroupKFold(_BaseKFold):
    method __init__ (line 837) | def __init__(self, n_splits=5, shuffle=False, random_state=None):
    method _iter_test_indices (line 840) | def _iter_test_indices(self, X, y, groups):
    method _find_best_fold (line 921) | def _find_best_fold(self, y_counts_per_fold, y_cnt, group_y_counts):
  class TimeSeriesSplit (line 944) | class TimeSeriesSplit(_BaseKFold):
    method __init__ (line 1034) | def __init__(self, n_splits=5, *, max_train_size=None, test_size=None,...
    method split (line 1040) | def split(self, X, y=None, groups=None):
  class LeaveOneGroupOut (line 1101) | class LeaveOneGroupOut(BaseCrossValidator):
    method _iter_test_masks (line 1143) | def _iter_test_masks(self, X, y, groups):
    method get_n_splits (line 1159) | def get_n_splits(self, X=None, y=None, groups=None):
    method split (line 1186) | def split(self, X, y=None, groups=None):
  class LeavePGroupsOut (line 1213) | class LeavePGroupsOut(BaseCrossValidator):
    method __init__ (line 1269) | def __init__(self, n_groups):
    method _iter_test_masks (line 1272) | def _iter_test_masks(self, X, y, groups):
    method get_n_splits (line 1293) | def get_n_splits(self, X=None, y=None, groups=None):
    method split (line 1320) | def split(self, X, y=None, groups=None):
  class _RepeatedSplits (line 1347) | class _RepeatedSplits(metaclass=ABCMeta):
    method __init__ (line 1371) | def __init__(self, cv, *, n_repeats=10, random_state=None, **cvargs):
    method split (line 1386) | def split(self, X, y=None, groups=None):
    method get_n_splits (line 1418) | def get_n_splits(self, X=None, y=None, groups=None):
    method __repr__ (line 1444) | def __repr__(self):
  class RepeatedKFold (line 1448) | class RepeatedKFold(_RepeatedSplits):
    method __init__ (line 1496) | def __init__(self, *, n_splits=5, n_repeats=10, random_state=None):
  class RepeatedStratifiedKFold (line 1502) | class RepeatedStratifiedKFold(_RepeatedSplits):
    method __init__ (line 1552) | def __init__(self, *, n_splits=5, n_repeats=10, random_state=None):
  class BaseShuffleSplit (line 1561) | class BaseShuffleSplit(metaclass=ABCMeta):
    method __init__ (line 1564) | def __init__(
    method split (line 1573) | def split(self, X, y=None, groups=None):
    method _iter_indices (line 1608) | def _iter_indices(self, X, y=None, groups=None):
    method get_n_splits (line 1611) | def get_n_splits(self, X=None, y=None, groups=None):
    method __repr__ (line 1632) | def __repr__(self):
  class ShuffleSplit (line 1636) | class ShuffleSplit(BaseShuffleSplit):
    method __init__ (line 1699) | def __init__(
    method _iter_indices (line 1710) | def _iter_indices(self, X, y=None, groups=None):
  class GroupShuffleSplit (line 1728) | class GroupShuffleSplit(ShuffleSplit):
    method __init__ (line 1795) | def __init__(
    method _iter_indices (line 1806) | def _iter_indices(self, X, y, groups):
    method split (line 1820) | def split(self, X, y=None, groups=None):
  class StratifiedShuffleSplit (line 1853) | class StratifiedShuffleSplit(BaseShuffleSplit):
    method __init__ (line 1913) | def __init__(
    method _iter_indices (line 1924) | def _iter_indices(self, X, y, groups=None):
    method split (line 1992) | def split(self, X, y, groups=None):
  function _validate_shuffle_split (line 2030) | def _validate_shuffle_split(n_samples, test_size, train_size, default_te...
  class PredefinedSplit (line 2111) | class PredefinedSplit(BaseCrossValidator):
    method __init__ (line 2149) | def __init__(self, test_fold):
    method split (line 2155) | def split(self, X=None, y=None, groups=None):
    method _iter_test_masks (line 2183) | def _iter_test_masks(self):
    method get_n_splits (line 2191) | def get_n_splits(self, X=None, y=None, groups=None):
  class _CVIterableWrapper (line 2213) | class _CVIterableWrapper(BaseCrossValidator):
    method __init__ (line 2216) | def __init__(self, cv):
    method get_n_splits (line 2219) | def get_n_splits(self, X=None, y=None, groups=None):
    method split (line 2240) | def split(self, X=None, y=None, groups=None):
  function check_cv (line 2266) | def check_cv(cv=5, y=None, *, classifier=False):
  function train_test_split (line 2325) | def train_test_split(
  function _build_repr (line 2460) | def _build_repr(self):
  function _yields_constant_splits (line 2500) | def _yields_constant_splits(cv):

FILE: sklearn/model_selection/_validation.py
  function cross_validate (line 48) | def cross_validate(
  function _insert_error_scores (line 316) | def _insert_error_scores(results, error_score):
  function _normalize_score_results (line 338) | def _normalize_score_results(scores, scaler_score_key="score"):
  function _warn_or_raise_about_fit_failures (line 347) | def _warn_or_raise_about_fit_failures(results, error_score):
  function cross_val_score (line 382) | def cross_val_score(
  function _fit_and_score (line 532) | def _fit_and_score(
  function _score (line 754) | def _score(estimator, X_test, y_test, scorer, error_score="raise"):
  function cross_val_predict (line 804) | def cross_val_predict(
  function _fit_and_predict (line 1001) | def _fit_and_predict(estimator, X, y, train, test, verbose, fit_params, ...
  function _enforce_prediction_order (line 1080) | def _enforce_prediction_order(classes, predictions, n_classes, method):
  function _check_is_permutation (line 1146) | def _check_is_permutation(indices, n_samples):
  function permutation_test_score (line 1170) | def permutation_test_score(
  function _permutation_test_score (line 1326) | def _permutation_test_score(estimator, X, y, groups, cv, scorer, fit_par...
  function _shuffle (line 1340) | def _shuffle(y, groups, random_state):
  function learning_curve (line 1352) | def learning_curve(
  function _translate_train_sizes (line 1595) | def _translate_train_sizes(train_sizes, n_max_training_samples):
  function _incremental_fit_estimator (line 1663) | def _incremental_fit_estimator(
  function validation_curve (line 1714) | def validation_curve(
  function _aggregate_score_dicts (line 1864) | def _aggregate_score_dicts(scores):

FILE: sklearn/model_selection/tests/common.py
  class OneTimeSplitter (line 10) | class OneTimeSplitter:
    method __init__ (line 13) | def __init__(self, n_splits=4, n_samples=99):
    method split (line 18) | def split(self, X=None, y=None, groups=None):
    method get_n_splits (line 23) | def get_n_splits(self, X=None, y=None, groups=None):

FILE: sklearn/model_selection/tests/test_search.py
  class MockClassifier (line 77) | class MockClassifier:
    method __init__ (line 80) | def __init__(self, foo_param=0):
    method fit (line 83) | def fit(self, X, Y):
    method predict (line 88) | def predict(self, T):
    method transform (line 91) | def transform(self, X):
    method inverse_transform (line 94) | def inverse_transform(self, X):
    method score (line 101) | def score(self, X=None, Y=None):
    method get_params (line 108) | def get_params(self, deep=False):
    method set_params (line 111) | def set_params(self, **params):
  class LinearSVCNoScore (line 116) | class LinearSVCNoScore(LinearSVC):
    method score (line 120) | def score(self):
  function assert_grid_iter_equals_getitem (line 128) | def assert_grid_iter_equals_getitem(grid):
  function test_validate_parameter_input (line 145) | def test_validate_parameter_input(klass, input, error_type, error_message):
  function test_parameter_grid (line 150) | def test_parameter_grid():
  function test_grid_search (line 187) | def test_grid_search():
  function test_grid_search_pipeline_steps (line 212) | def test_grid_search_pipeline_steps():
  function test_SearchCV_with_fit_params (line 231) | def test_SearchCV_with_fit_params(SearchCV):
  function test_grid_search_no_score (line 250) | def test_grid_search_no_score():
  function test_grid_search_score_method (line 274) | def test_grid_search_score_method():
  function test_grid_search_groups (line 302) | def test_grid_search_groups():
  function test_classes__property (line 333) | def test_classes__property():
  function test_trivial_cv_results_attr (line 358) | def test_trivial_cv_results_attr():
  function test_no_refit (line 370) | def test_no_refit():
  function test_grid_search_error (line 409) | def test_grid_search_error():
  function test_grid_search_one_grid_point (line 419) | def test_grid_search_one_grid_point():
  function test_grid_search_when_param_grid_includes_range (line 433) | def test_grid_search_when_param_grid_includes_range():
  function test_grid_search_bad_param_grid (line 442) | def test_grid_search_bad_param_grid():
  function test_grid_search_sparse (line 479) | def test_grid_search_sparse():
  function test_grid_search_sparse_scoring (line 500) | def test_grid_search_sparse_scoring():
  function test_grid_search_precomputed_kernel (line 536) | def test_grid_search_precomputed_kernel():
  function test_grid_search_precomputed_kernel_error_nonsquare (line 565) | def test_grid_search_precomputed_kernel_error_nonsquare():
  class BrokenClassifier (line 576) | class BrokenClassifier(BaseEstimator):
    method __init__ (line 579) | def __init__(self, parameter=None):
    method fit (line 582) | def fit(self, X, y):
    method predict (line 586) | def predict(self, X):
  function test_refit (line 591) | def test_refit():
  function test_refit_callable (line 604) | def test_refit_callable():
  function test_refit_callable_invalid_type (line 649) | def test_refit_callable_invalid_type():
  function test_refit_callable_out_bound (line 675) | def test_refit_callable_out_bound(out_bound_value, search_cv):
  function test_refit_callable_multi_metric (line 699) | def test_refit_callable_multi_metric():
  function test_gridsearch_nd (line 728) | def test_gridsearch_nd():
  function test_X_as_list (line 749) | def test_X_as_list():
  function test_y_as_list (line 764) | def test_y_as_list():
  function test_pandas_input (line 780) | def test_pandas_input():
  function test_unsupervised_grid_search (line 811) | def test_unsupervised_grid_search():
  function test_gridsearch_no_predict (line 839) | def test_gridsearch_no_predict():
  function test_param_sampler (line 856) | def test_param_sampler():
  function check_cv_results_array_types (line 882) | def check_cv_results_array_types(search, param_keys, score_keys):
  function check_cv_results_keys (line 900) | def check_cv_results_keys(cv_results, param_keys, score_keys, n_cand):
  function test_grid_search_cv_results (line 908) | def test_grid_search_cv_results():
  function test_random_search_cv_results (line 988) | def test_random_search_cv_results():
  function test_search_default_iid (line 1058) | def test_search_default_iid(SearchCV, specialized_params):
  function test_grid_search_cv_results_multimetric (line 1114) | def test_grid_search_cv_results_multimetric():
  function test_random_search_cv_results_multimetric (line 1149) | def test_random_search_cv_results_multimetric():
  function compare_cv_results_multimetric_with_single (line 1185) | def compare_cv_results_multimetric_with_single(search_multi, search_acc,...
  function compare_refit_methods_when_refit_with_acc (line 1223) | def compare_refit_methods_when_refit_with_acc(search_multi, search_acc, ...
  function test_search_cv_score_samples_error (line 1254) | def test_search_cv_score_samples_error(search_cv):
  function test_search_cv_score_samples_method (line 1281) | def test_search_cv_score_samples_method(search_cv):
  function test_search_cv_results_rank_tie_breaking (line 1314) | def test_search_cv_results_rank_tie_breaking():
  function test_search_cv_results_none_param (line 1348) | def test_search_cv_results_none_param():
  function test_search_cv_timing (line 1364) | def test_search_cv_timing():
  function test_grid_search_correct_score_results (line 1404) | def test_grid_search_correct_score_results():
  function test_pickle (line 1441) | def test_pickle():
  function test_grid_search_with_multioutput_data (line 1459) | def test_grid_search_with_multioutput_data():
  function test_predict_proba_disabled (line 1505) | def test_predict_proba_disabled():
  function test_grid_search_allows_nans (line 1514) | def test_grid_search_allows_nans():
  class FailingClassifier (line 1528) | class FailingClassifier(BaseEstimator):
    method __init__ (line 1533) | def __init__(self, parameter=None):
    method fit (line 1536) | def fit(self, X, y=None):
    method predict (line 1540) | def predict(self, X):
    method score (line 1543) | def score(self, X=None, Y=None):
  function test_grid_search_failing_classifier (line 1547) | def test_grid_search_failing_classifier():
  function test_grid_search_classifier_all_fits_fail (line 1630) | def test_grid_search_classifier_all_fits_fail():
  function test_grid_search_failing_classifier_raise (line 1651) | def test_grid_search_failing_classifier_raise():
  function test_parameters_sampler_replacement (line 1672) | def test_parameters_sampler_replacement():
  function test_stochastic_gradient_loss_param (line 1712) | def test_stochastic_gradient_loss_param():
  function test_search_train_scores_set_to_false (line 1744) | def test_search_train_scores_set_to_false():
  function test_grid_search_cv_splits_consistency (line 1753) | def test_grid_search_cv_splits_consistency():
  function test_transform_inverse_transform_round_trip (line 1848) | def test_transform_inverse_transform_round_trip():
  function test_custom_run_search (line 1857) | def test_custom_run_search():
  function test__custom_fit_no_run_search (line 1908) | def test__custom_fit_no_run_search():
  function test_empty_cv_iterator_error (line 1928) | def test_empty_cv_iterator_error():
  function test_random_search_bad_cv (line 1953) | def test_random_search_bad_cv():
  function test_searchcv_raise_warning_with_non_finite_score (line 1989) | def test_searchcv_raise_warning_with_non_finite_score(
  function test_callable_multimetric_confusion_matrix (line 2027) | def test_callable_multimetric_confusion_matrix():
  function test_callable_multimetric_same_as_list_of_strings (line 2050) | def test_callable_multimetric_same_as_list_of_strings():
  function test_callable_single_metric_same_as_single_string (line 2076) | def test_callable_single_metric_same_as_single_string():
  function test_callable_multimetric_error_on_invalid_key (line 2104) | def test_callable_multimetric_error_on_invalid_key():
  function test_callable_multimetric_error_failing_clf (line 2125) | def test_callable_multimetric_error_failing_clf():
  function test_callable_multimetric_clf_all_fits_fail (line 2153) | def test_callable_multimetric_clf_all_fits_fail():
  function test_n_features_in (line 2181) | def test_n_features_in():
  function test_search_cv_pairwise_property_delegated_to_base_estimator (line 2199) | def test_search_cv_pairwise_property_delegated_to_base_estimator(pairwise):
  function test_search_cv__pairwise_property_delegated_to_base_estimator (line 2220) | def test_search_cv__pairwise_property_delegated_to_base_estimator():
  function test_search_cv_pairwise_property_equivalence_of_precomputed (line 2237) | def test_search_cv_pairwise_property_equivalence_of_precomputed():
  function test_scalar_fit_param (line 2271) | def test_scalar_fit_param(SearchCV, param_search):
  function test_scalar_fit_param_compat (line 2298) | def test_scalar_fit_param_compat(SearchCV, param_search):
  function test_search_cv_using_minimal_compatible_estimator (line 2352) | def test_search_cv_using_minimal_compatible_estimator(SearchCV, Predictor):
  function test_search_cv_verbose_3 (line 2381) | def test_search_cv_verbose_3(capsys, return_train_score):

FILE: sklearn/model_selection/tests/test_split.py
  function test_cross_validator_with_default_params (line 66) | def test_cross_validator_with_default_params():
  function test_2d_y (line 151) | def test_2d_y():
  function check_valid_split (line 190) | def check_valid_split(train, test, n_samples=None):
  function check_cv_coverage (line 202) | def check_cv_coverage(cv, X, y, groups, expected_n_splits):
  function test_kfold_valueerrors (line 220) | def test_kfold_valueerrors():
  function test_kfold_indices (line 293) | def test_kfold_indices():
  function test_kfold_no_shuffle (line 309) | def test_kfold_no_shuffle():
  function test_stratified_kfold_no_shuffle (line 332) | def test_stratified_kfold_no_shuffle():
  function test_stratified_kfold_ratios (line 378) | def test_stratified_kfold_ratios(k, shuffle, kfold):
  function test_stratified_kfold_label_invariance (line 405) | def test_stratified_kfold_label_invariance(k, shuffle, kfold):
  function test_kfold_balance (line 433) | def test_kfold_balance():
  function test_stratifiedkfold_balance (line 444) | def test_stratifiedkfold_balance(kfold):
  function test_shuffle_kfold (line 463) | def test_shuffle_kfold():
  function test_shuffle_kfold_stratifiedkfold_reproducibility (line 487) | def test_shuffle_kfold_stratifiedkfold_reproducibility(kfold):
  function test_shuffle_stratifiedkfold (line 518) | def test_shuffle_stratifiedkfold():
  function test_kfold_can_detect_dependent_samples_on_digits (line 541) | def test_kfold_can_detect_dependent_samples_on_digits():  # see #2372
  function test_stratified_group_kfold_trivial (line 585) | def test_stratified_group_kfold_trivial():
  function test_stratified_group_kfold_approximate (line 603) | def test_stratified_group_kfold_approximate():
  function test_stratified_group_kfold_homogeneous_groups (line 636) | def test_stratified_group_kfold_homogeneous_groups(y, groups, expected):
  function test_stratified_group_kfold_against_group_kfold (line 648) | def test_stratified_group_kfold_against_group_kfold(cls_distr, n_groups):
  function test_shuffle_split (line 675) | def test_shuffle_split():
  function test_shuffle_split_default_test_size (line 693) | def test_shuffle_split_default_test_size(split_class, train_size, exp_tr...
  function test_group_shuffle_split_default_test_size (line 708) | def test_group_shuffle_split_default_test_size(train_size, exp_train, ex...
  function test_stratified_shuffle_split_init (line 722) | def test_stratified_shuffle_split_init():
  function test_stratified_shuffle_split_respects_test_size (line 747) | def test_stratified_shuffle_split_respects_test_size():
  function test_stratified_shuffle_split_iter (line 759) | def test_stratified_shuffle_split_iter():
  function test_stratified_shuffle_split_even (line 796) | def test_stratified_shuffle_split_even():
  function test_stratified_shuffle_split_overlap_train_test_bug (line 848) | def test_stratified_shuffle_split_overlap_train_test_bug():
  function test_stratified_shuffle_split_multilabel (line 865) | def test_stratified_shuffle_split_multilabel():
  function test_stratified_shuffle_split_multilabel_many_labels (line 890) | def test_stratified_shuffle_split_multilabel_many_labels():
  function test_predefinedsplit_with_kfold_split (line 913) | def test_predefinedsplit_with_kfold_split():
  function test_group_shuffle_split (line 930) | def test_group_shuffle_split():
  function test_leave_one_p_group_out (line 967) | def test_leave_one_p_group_out():
  function test_leave_group_out_changing_groups (line 1022) | def test_leave_group_out_changing_groups():
  function test_leave_one_p_group_out_error_on_fewer_number_of_groups (line 1044) | def test_leave_one_p_group_out_error_on_fewer_number_of_groups():
  function test_repeated_cv_value_errors (line 1080) | def test_repeated_cv_value_errors():
  function test_repeated_cv_repr (line 1090) | def test_repeated_cv_repr(RepeatedCV):
  function test_repeated_kfold_determinstic_split (line 1099) | def test_repeated_kfold_determinstic_split():
  function test_get_n_splits_for_repeated_kfold (line 1128) | def test_get_n_splits_for_repeated_kfold():
  function test_get_n_splits_for_repeated_stratified_kfold (line 1136) | def test_get_n_splits_for_repeated_stratified_kfold():
  function test_repeated_stratified_kfold_determinstic_split (line 1144) | def test_repeated_stratified_kfold_determinstic_split():
  function test_train_test_split_errors (line 1174) | def test_train_test_split_errors():
  function test_train_test_split_invalid_sizes1 (line 1215) | def test_train_test_split_invalid_sizes1(train_size, test_size):
  function test_train_test_split_invalid_sizes2 (line 1224) | def test_train_test_split_invalid_sizes2(train_size, test_size):
  function test_train_test_split_default_test_size (line 1232) | def test_train_test_split_default_test_size(train_size, exp_train, exp_t...
  function test_train_test_split (line 1241) | def test_train_test_split():
  function test_train_test_split_32bit_overflow (line 1288) | def test_train_test_split_32bit_overflow():
  function test_train_test_split_pandas (line 1312) | def test_train_test_split_pandas():
  function test_train_test_split_sparse (line 1329) | def test_train_test_split_sparse():
  function test_train_test_split_mock_pandas (line 1341) | def test_train_test_split_mock_pandas():
  function test_train_test_split_list_input (line 1350) | def test_train_test_split_list_input():
  function test_shufflesplit_errors (line 1378) | def test_shufflesplit_errors(test_size, train_size):
  function test_shufflesplit_reproducible (line 1383) | def test_shufflesplit_reproducible():
  function test_stratifiedshufflesplit_list_input (line 1390) | def test_stratifiedshufflesplit_list_input():
  function test_train_test_split_allow_nans (line 1402) | def test_train_test_split_allow_nans():
  function test_check_cv (line 1410) | def test_check_cv():
  function test_cv_iterable_wrapper (line 1456) | def test_cv_iterable_wrapper():
  function test_group_kfold (line 1490) | def test_group_kfold(kfold):
  function test_time_series_cv (line 1613) | def test_time_series_cv():
  function _check_time_series_max_train_size (line 1650) | def _check_time_series_max_train_size(splits, check_splits, max_train_si...
  function test_time_series_max_train_size (line 1658) | def test_time_series_max_train_size():
  function test_time_series_test_size (line 1673) | def test_time_series_test_size():
  function test_time_series_gap (line 1708) | def test_time_series_gap():
  function test_nested_cv (line 1765) | def test_nested_cv():
  function test_build_repr (line 1790) | def test_build_repr():
  function test_shuffle_split_empty_trainset (line 1806) | def test_shuffle_split_empty_trainset(CVSplitter):
  function test_train_test_split_empty_trainset (line 1819) | def test_train_test_split_empty_trainset():
  function test_leave_one_out_empty_trainset (line 1841) | def test_leave_one_out_empty_trainset():
  function test_leave_p_out_empty_trainset (line 1849) | def test_leave_p_out_empty_trainset():
  function test_random_state_shuffle_false (line 1860) | def test_random_state_shuffle_false(Klass):
  function test_yields_constant_splits (line 1902) | def test_yields_constant_splits(cv, expected):

FILE: sklearn/model_selection/tests/test_successive_halving.py
  class FastClassifier (line 26) | class FastClassifier(DummyClassifier):
    method __init__ (line 32) | def __init__(
    method get_params (line 39) | def get_params(self, deep=False):
  function test_aggressive_elimination (line 72) | def test_aggressive_elimination(
  function test_min_max_resources (line 145) | def test_min_max_resources(
  function test_n_iterations (line 197) | def test_n_iterations(Est, max_resources, n_iterations, n_possible_itera...
  function test_resource_parameter (line 224) | def test_resource_parameter(Est):
  function test_random_search (line 273) | def test_random_search(max_resources, n_candidates, expected_n_candidates):
  function test_random_search_discrete_distributions (line 305) | def test_random_search_discrete_distributions(
  function test_input_errors (line 355) | def test_input_errors(Est, params, expected_error_message):
  function test_input_errors_randomized (line 377) | def test_input_errors_randomized(params, expected_error_message):
  function test_subsample_splitter_shapes (line 399) | def test_subsample_splitter_shapes(
  function test_subsample_splitter_determinism (line 424) | def test_subsample_splitter_determinism(subsample_test):
  function test_top_k (line 468) | def test_top_k(k, itr, expected):
  function test_cv_results (line 480) | def test_cv_results(Est):
  function test_base_estimator_inputs (line 581) | def test_base_estimator_inputs(Est):
  function test_groups_support (line 648) | def test_groups_support(Est):
  function test_min_resources_null (line 681) | def test_min_resources_null(SearchCV):
  function test_select_best_index (line 695) | def test_select_best_index(SearchCV):

FILE: sklearn/model_selection/tests/test_validation.py
  class MockImprovingEstimator (line 86) | class MockImprovingEstimator(BaseEstimator):
    method __init__ (line 89) | def __init__(self, n_max_train_sizes):
    method fit (line 94) | def fit(self, X_subset, y_subset=None):
    method predict (line 99) | def predict(self, X):
    method score (line 102) | def score(self, X=None, Y=None):
    method _is_training_data (line 109) | def _is_training_data(self, X):
  class MockIncrementalImprovingEstimator (line 113) | class MockIncrementalImprovingEstimator(MockImprovingEstimator):
    method __init__ (line 116) | def __init__(self, n_max_train_sizes, expected_fit_params=None):
    method _is_training_data (line 121) | def _is_training_data(self, X):
    method partial_fit (line 124) | def partial_fit(self, X, y=None, **params):
  class MockEstimatorWithParameter (line 143) | class MockEstimatorWithParameter(BaseEstimator):
    method __init__ (line 146) | def __init__(self, param=0.5):
    method fit (line 150) | def fit(self, X_subset, y_subset):
    method predict (line 155) | def predict(self, X):
    method score (line 158) | def score(self, X=None, y=None):
    method _is_training_data (line 161) | def _is_training_data(self, X):
  class MockEstimatorWithSingleFitCallAllowed (line 165) | class MockEstimatorWithSingleFitCallAllowed(MockEstimatorWithParameter):
    method fit (line 168) | def fit(self, X_subset, y_subset):
    method predict (line 173) | def predict(self, X):
  class MockClassifier (line 177) | class MockClassifier:
    method __init__ (line 180) | def __init__(self, a=0, allow_nd=False):
    method fit (line 184) | def fit(
    method predict (line 247) | def predict(self, T):
    method predict_proba (line 252) | def predict_proba(self, T):
    method score (line 255) | def score(self, X=None, Y=None):
    method get_params (line 258) | def get_params(self, deep=False):
  function test_cross_val_score (line 273) | def test_cross_val_score():
  function test_cross_validate_many_jobs (line 315) | def test_cross_validate_many_jobs():
  function test_cross_validate_invalid_scoring_param (line 325) | def test_cross_validate_invalid_scoring_param():
  function test_cross_validate_nested_estimator (line 389) | def test_cross_validate_nested_estimator():
  function test_cross_validate (line 408) | def test_cross_validate():
  function check_cross_validate_single_metric (line 455) | def check_cross_validate_single_metric(clf, X, y, scores):
  function check_cross_validate_multi_metric (line 503) | def check_cross_validate_multi_metric(clf, X, y, scores):
  function test_cross_val_score_predict_groups (line 576) | def test_cross_val_score_predict_groups():
  function test_cross_val_score_pandas (line 599) | def test_cross_val_score_pandas():
  function test_cross_val_score_mask (line 618) | def test_cross_val_score_mask():
  function test_cross_val_score_precomputed (line 637) | def test_cross_val_score_precomputed():
  function test_cross_val_score_fit_params (line 664) | def test_cross_val_score_fit_params():
  function test_cross_val_score_score_func (line 699) | def test_cross_val_score_score_func():
  function test_cross_val_score_errors (line 715) | def test_cross_val_score_errors():
  function test_cross_val_score_with_score_func_classification (line 723) | def test_cross_val_score_with_score_func_classification():
  function test_cross_val_score_with_score_func_regression (line 742) | def test_cross_val_score_with_score_func_regression():
  function test_permutation_score (line 766) | def test_permutation_score():
  function test_permutation_test_score_allow_nans (line 832) | def test_permutation_test_score_allow_nans():
  function test_permutation_test_score_fit_params (line 846) | def test_permutation_test_score_fit_params():
  function test_cross_val_score_allow_nans (line 861) | def test_cross_val_score_allow_nans():
  function test_cross_val_score_multilabel (line 875) | def test_cross_val_score_multilabel():
  function test_cross_val_predict (line 905) | def test_cross_val_predict():
  function test_cross_val_predict_decision_function_shape (line 961) | def test_cross_val_predict_decision_function_shape():
  function test_cross_val_predict_predict_proba_shape (line 1013) | def test_cross_val_predict_predict_proba_shape():
  function test_cross_val_predict_predict_log_proba_shape (line 1029) | def test_cross_val_predict_predict_log_proba_shape():
  function test_cross_val_predict_input_types (line 1045) | def test_cross_val_predict_input_types():
  function test_cross_val_predict_pandas (line 1100) | def test_cross_val_predict_pandas():
  function test_cross_val_predict_unbalanced (line 1118) | def test_cross_val_predict_unbalanced():
  function test_cross_val_predict_y_none (line 1140) | def test_cross_val_predict_y_none():
  function test_cross_val_score_sparse_fit_params (line 1153) | def test_cross_val_score_sparse_fit_params():
  function test_learning_curve (line 1162) | def test_learning_curve():
  function test_learning_curve_unsupervised (line 1223) | def test_learning_curve_unsupervised():
  function test_learning_curve_verbose (line 1242) | def test_learning_curve_verbose():
  function test_learning_curve_incremental_learning_not_possible (line 1268) | def test_learning_curve_incremental_learning_not_possible():
  function test_learning_curve_incremental_learning (line 1284) | def test_learning_curve_incremental_learning():
  function test_learning_curve_incremental_learning_unsupervised (line 1310) | def test_learning_curve_incremental_learning_unsupervised():
  function test_learning_curve_batch_and_incremental_learning_are_equal (line 1334) | def test_learning_curve_batch_and_incremental_learning_are_equal():
  function test_learning_curve_n_sample_range_out_of_bounds (line 1373) | def test_learning_curve_n_sample_range_out_of_bounds():
  function test_learning_curve_remove_duplicate_sample_sizes (line 1396) | def test_learning_curve_remove_duplicate_sample_sizes():
  function test_learning_curve_with_boolean_indices (line 1418) | def test_learning_curve_with_boolean_indices():
  function test_learning_curve_with_shuffle (line 1438) | def test_learning_curve_with_shuffle():
  function test_learning_curve_fit_params (line 1516) | def test_learning_curve_fit_params():
  function test_learning_curve_incremental_learning_fit_params (line 1535) | def test_learning_curve_incremental_learning_fit_params():
  function test_validation_curve (line 1583) | def test_validation_curve():
  function test_validation_curve_clone_estimator (line 1610) | def test_validation_curve_clone_estimator():
  function test_validation_curve_cv_splits_consistency (line 1632) | def test_validation_curve_cv_splits_consistency():
  function test_validation_curve_fit_params (line 1678) | def test_validation_curve_fit_params():
  function test_check_is_permutation (line 1716) | def test_check_is_permutation():
  function test_cross_val_predict_sparse_prediction (line 1730) | def test_cross_val_predict_sparse_prediction():
  function check_cross_val_predict_binary (line 1748) | def check_cross_val_predict_binary(est, X, y, method):
  function check_cross_val_predict_multiclass (line 1769) | def check_cross_val_predict_multiclass(est, X, y, method):
  function check_cross_val_predict_multilabel (line 1797) | def check_cross_val_predict_multilabel(est, X, y, method):
  function check_cross_val_predict_with_method_binary (line 1849) | def check_cross_val_predict_with_method_binary(est):
  function check_cross_val_predict_with_method_multiclass (line 1857) | def check_cross_val_predict_with_method_multiclass(est):
  function test_cross_val_predict_with_method (line 1865) | def test_cross_val_predict_with_method():
  function test_cross_val_predict_method_checking (line 1872) | def test_cross_val_predict_method_checking():
  function test_gridsearchcv_cross_val_predict_with_method (line 1883) | def test_gridsearchcv_cross_val_predict_with_method():
  function test_cross_val_predict_with_method_multilabel_ovr (line 1894) | def test_cross_val_predict_with_method_multilabel_ovr():
  class RFWithDecisionFunction (line 1908) | class RFWithDecisionFunction(RandomForestClassifier):
    method decision_function (line 1912) | def decision_function(self, X):
  function test_cross_val_predict_with_method_multilabel_rf (line 1920) | def test_cross_val_predict_with_method_multilabel_rf():
  function test_cross_val_predict_with_method_rare_class (line 1937) | def test_cross_val_predict_with_method_rare_class():
  function test_cross_val_predict_with_method_multilabel_rf_rare_class (line 1951) | def test_cross_val_predict_with_method_multilabel_rf_rare_class():
  function get_expected_predictions (line 1968) | def get_expected_predictions(X, y, cv, classes, est, method):
  function test_cross_val_predict_class_subset (line 1989) | def test_cross_val_predict_class_subset():
  function test_score_memmap (line 2030) | def test_score_memmap():
  function test_permutation_test_score_pandas (line 2057) | def test_permutation_test_score_pandas():
  function test_fit_and_score_failing (line 2077) | def test_fit_and_score_failing():
  function test_fit_and_score_working (line 2118) | def test_fit_and_score_working():
  class DataDependentFailingClassifier (line 2133) | class DataDependentFailingClassifier(BaseEstimator):
    method __init__ (line 2134) | def __init__(self, max_x_value=None):
    method fit (line 2137) | def fit(self, X, y=None):
    method score (line 2144) | def score(self, X=None, Y=None):
  function test_cross_validate_some_failing_fits_warning (line 2149) | def test_cross_validate_some_failing_fits_warning(error_score):
  function test_cross_validate_all_failing_fits_error (line 2175) | def test_cross_validate_all_failing_fits_error(error_score):
  function _failing_scorer (line 2196) | def _failing_scorer(estimator, X, y, error_msg):
  function test_cross_val_score_failing_scorer (line 2202) | def test_cross_val_score_failing_scorer(error_score):
  function test_cross_validate_failing_scorer (line 2232) | def test_cross_validate_failing_scorer(
  function three_params_scorer (line 2280) | def three_params_scorer(i, j, k):
  function test_fit_and_score_verbosity (line 2316) | def test_fit_and_score_verbosity(
  function test_score (line 2339) | def test_score():
  function test_callable_multimetric_confusion_matrix_cross_validate (line 2350) | def test_callable_multimetric_confusion_matrix_cross_validate():
  function test_validation_pairwise (line 2367) | def test_validation_pairwise():

FILE: sklearn/multiclass.py
  function _fit_binary (line 70) | def _fit_binary(estimator, X, y, classes=None):
  function _partial_fit_binary (line 89) | def _partial_fit_binary(estimator, X, y):
  function _predict_binary (line 95) | def _predict_binary(estimator, X):
  function _check_estimator (line 107) | def _check_estimator(estimator):
  class _ConstantPredictor (line 117) | class _ConstantPredictor(BaseEstimator):
    method fit (line 118) | def fit(self, X, y):
    method predict (line 128) | def predict(self, X):
    method decision_function (line 141) | def decision_function(self, X):
    method predict_proba (line 154) | def predict_proba(self, X):
  function _estimators_has (line 168) | def _estimators_has(attr):
  class OneVsRestClassifier (line 180) | class OneVsRestClassifier(
    method __init__ (line 304) | def __init__(self, estimator, *, n_jobs=None):
    method fit (line 308) | def fit(self, X, y):
    method partial_fit (line 358) | def partial_fit(self, X, y, classes=None):
    method predict (line 422) | def predict(self, X):
    method predict_proba (line 466) | def predict_proba(self, X):
    method decision_function (line 506) | def decision_function(self, X):
    method multilabel_ (line 536) | def multilabel_(self):
    method n_classes_ (line 541) | def n_classes_(self):
    method coef_ (line 555) | def coef_(self):
    method intercept_ (line 574) | def intercept_(self):
    method _pairwise (line 587) | def _pairwise(self):
    method _more_tags (line 591) | def _more_tags(self):
  function _fit_ovo_binary (line 596) | def _fit_ovo_binary(estimator, X, y, i, j):
  function _partial_fit_ovo_binary (line 615) | def _partial_fit_ovo_binary(estimator, X, y, i, j):
  class OneVsOneClassifier (line 627) | class OneVsOneClassifier(MetaEstimatorMixin, ClassifierMixin, BaseEstima...
    method __init__ (line 707) | def __init__(self, estimator, *, n_jobs=None):
    method fit (line 711) | def fit(self, X, y):
    method partial_fit (line 761) | def partial_fit(self, X, y, classes=None):
    method predict (line 825) | def predict(self, X):
    method decision_function (line 847) | def decision_function(self, X):
    method n_classes_ (line 895) | def n_classes_(self):
    method _pairwise (line 906) | def _pairwise(self):
    method _more_tags (line 910) | def _more_tags(self):
  class OutputCodeClassifier (line 915) | class OutputCodeClassifier(MetaEstimatorMixin, ClassifierMixin, BaseEsti...
    method __init__ (line 1015) | def __init__(self, estimator, *, code_size=1.5, random_state=None, n_j...
    method fit (line 1021) | def fit(self, X, y):
    method predict (line 1084) | def predict(self, X):

FILE: sklearn/multioutput.py
  function _fit_estimator (line 39) | def _fit_estimator(estimator, X, y, sample_weight=None, **fit_params):
  function _partial_fit_estimator (line 48) | def _partial_fit_estimator(
  function _available_if_estimator_has (line 67) | def _available_if_estimator_has(attr):
  class _MultiOutputEstimator (line 81) | class _MultiOutputEstimator(MetaEstimatorMixin, BaseEstimator, metaclass...
    method __init__ (line 83) | def __init__(self, estimator, *, n_jobs=None):
    method partial_fit (line 88) | def partial_fit(self, X, y, classes=None, sample_weight=None):
    method fit (line 153) | def fit(self, X, y, sample_weight=None, **fit_params):
    method predict (line 216) | def predict(self, X):
    method _more_tags (line 240) | def _more_tags(self):
  class MultiOutputRegressor (line 244) | class MultiOutputRegressor(RegressorMixin, _MultiOutputEstimator):
    method __init__ (line 310) | def __init__(self, estimator, *, n_jobs=None):
    method partial_fit (line 314) | def partial_fit(self, X, y, sample_weight=None):
  class MultiOutputClassifier (line 338) | class MultiOutputClassifier(ClassifierMixin, _MultiOutputEstimator):
    method __init__ (line 405) | def __init__(self, estimator, *, n_jobs=None):
    method fit (line 408) | def fit(self, X, Y, sample_weight=None, **fit_params):
    method _check_predict_proba (line 438) | def _check_predict_proba(self):
    method predict_proba (line 450) | def predict_proba(self, X):
    method score (line 477) | def score(self, X, y):
    method _more_tags (line 508) | def _more_tags(self):
  function _available_if_base_estimator_has (line 513) | def _available_if_base_estimator_has(attr):
  class _BaseChain (line 527) | class _BaseChain(BaseEstimator, metaclass=ABCMeta):
    method __init__ (line 528) | def __init__(self, base_estimator, *, order=None, cv=None, random_stat...
    method fit (line 535) | def fit(self, X, Y, **fit_params):
    method predict (line 606) | def predict(self, X):
  class ClassifierChain (line 640) | class ClassifierChain(MetaEstimatorMixin, ClassifierMixin, _BaseChain):
    method fit (line 751) | def fit(self, X, Y):
    method predict_proba (line 774) | def predict_proba(self, X):
    method decision_function (line 805) | def decision_function(self, X):
    method _more_tags (line 837) | def _more_tags(self):
  class RegressorChain (line 841) | class RegressorChain(MetaEstimatorMixin, RegressorMixin, _BaseChain):
    method fit (line 932) | def fit(self, X, Y, **fit_params):
    method _more_tags (line 957) | def _more_tags(self):

FILE: sklearn/naive_bayes.py
  class _BaseNB (line 46) | class _BaseNB(ClassifierMixin, BaseEstimator, metaclass=ABCMeta):
    method _joint_log_likelihood (line 50) | def _joint_log_likelihood(self, X):
    method _check_X (line 61) | def _check_X(self, X):
    method predict (line 67) | def predict(self, X):
    method predict_log_proba (line 86) | def predict_log_proba(self, X):
    method predict_proba (line 109) | def predict_proba(self, X):
  class GaussianNB (line 128) | class GaussianNB(_BaseNB):
    method __init__ (line 217) | def __init__(self, *, priors=None, var_smoothing=1e-9):
    method fit (line 221) | def fit(self, X, y, sample_weight=None):
    method _check_X (line 249) | def _check_X(self, X):
    method _update_mean_variance (line 254) | def _update_mean_variance(n_past, mu, var, X, sample_weight=None):
    method partial_fit (line 325) | def partial_fit(self, X, y, classes=None, sample_weight=None):
    method _partial_fit (line 369) | def _partial_fit(self, X, y, classes=None, _refit=False, sample_weight...
    method _joint_log_likelihood (line 485) | def _joint_log_likelihood(self, X):
    method sigma_ (line 501) | def sigma_(self):
  class _BaseDiscreteNB (line 508) | class _BaseDiscreteNB(_BaseNB):
    method _check_X (line 517) | def _check_X(self, X):
    method _check_X_y (line 521) | def _check_X_y(self, X, y, reset=True):
    method _update_class_log_prior (line 525) | def _update_class_log_prior(self, class_prior=None):
    method _check_alpha (line 543) | def _check_alpha(self):
    method partial_fit (line 562) | def partial_fit(self, X, y, classes=None, sample_weight=None):
    method fit (line 643) | def fit(self, X, y, sample_weight=None):
    method _init_counters (line 696) | def _init_counters(self, n_classes, n_features):
    method coef_ (line 706) | def coef_(self):
    method intercept_ (line 719) | def intercept_(self):
    method _more_tags (line 726) | def _more_tags(self):
    method n_features_ (line 736) | def n_features_(self):
  class MultinomialNB (line 740) | class MultinomialNB(_BaseDiscreteNB):
    method __init__ (line 853) | def __init__(self, *, alpha=1.0, fit_prior=True, class_prior=None):
    method _more_tags (line 858) | def _more_tags(self):
    method _count (line 861) | def _count(self, X, Y):
    method _update_feature_log_prob (line 867) | def _update_feature_log_prob(self, alpha):
    method _joint_log_likelihood (line 876) | def _joint_log_likelihood(self, X):
  class ComplementNB (line 881) | class ComplementNB(_BaseDiscreteNB):
    method __init__ (line 995) | def __init__(self, *, alpha=1.0, fit_prior=True, class_prior=None, nor...
    method _more_tags (line 1001) | def _more_tags(self):
    method _count (line 1004) | def _count(self, X, Y):
    method _update_feature_log_prob (line 1011) | def _update_feature_log_prob(self, alpha):
    method _joint_log_likelihood (line 1023) | def _joint_log_likelihood(self, X):
  class BernoulliNB (line 1031) | class BernoulliNB(_BaseDiscreteNB):
    method __init__ (line 1139) | def __init__(self, *, alpha=1.0, binarize=0.0, fit_prior=True, class_p...
    method _check_X (line 1145) | def _check_X(self, X):
    method _check_X_y (line 1152) | def _check_X_y(self, X, y, reset=True):
    method _count (line 1158) | def _count(self, X, Y):
    method _update_feature_log_prob (line 1163) | def _update_feature_log_prob(self, alpha):
    method _joint_log_likelihood (line 1172) | def _joint_log_likelihood(self, X):
  class CategoricalNB (line 1191) | class CategoricalNB(_BaseDiscreteNB):
    method __init__ (line 1293) | def __init__(
    method fit (line 1301) | def fit(self, X, y, sample_weight=None):
    method partial_fit (line 1328) | def partial_fit(self, X, y, classes=None, sample_weight=None):
    method _more_tags (line 1372) | def _more_tags(self):
    method _check_X (line 1375) | def _check_X(self, X):
    method _check_X_y (line 1383) | def _check_X_y(self, X, y, reset=True):
    method _init_counters (line 1390) | def _init_counters(self, n_classes, n_features):
    method _validate_n_categories (line 1395) | def _validate_n_categories(X, min_categories):
    method _count (line 1416) | def _count(self, X, Y):
    method _update_feature_log_prob (line 1446) | def _update_feature_log_prob(self, alpha):
    method _joint_log_likelihood (line 1456) | def _joint_log_likelihood(self, X):

FILE: sklearn/neighbors/_base.py
  function _check_weights (line 79) | def _check_weights(weights):
  function _get_weights (line 90) | def _get_weights(dist, weights):
  function _is_sorted_by_data (line 137) | def _is_sorted_by_data(graph):
  function _check_precomputed (line 164) | def _check_precomputed(X):
  function _kneighbors_from_graph (line 225) | def _kneighbors_from_graph(graph, n_neighbors, return_distance):
  function _radius_neighbors_from_graph (line 277) | def _radius_neighbors_from_graph(graph, radius, return_distance):
  class NeighborsBase (line 325) | class NeighborsBase(MultiOutputMixin, BaseEstimator, metaclass=ABCMeta):
    method __init__ (line 329) | def __init__(
    method _check_algorithm_metric (line 350) | def _check_algorithm_metric(self):
    method _fit (line 397) | def _fit(self, X, y=None):
    method _more_tags (line 575) | def _more_tags(self):
    method _pairwise (line 586) | def _pairwise(self):
  function _tree_query_parallel_helper (line 591) | def _tree_query_parallel_helper(tree, *args, **kwargs):
  class KNeighborsMixin (line 600) | class KNeighborsMixin:
    method _kneighbors_reduce_func (line 603) | def _kneighbors_reduce_func(self, dist, start, n_neighbors, return_dis...
    method kneighbors (line 644) | def kneighbors(self, X=None, n_neighbors=None, return_distance=True):
    method kneighbors_graph (line 819) | def kneighbors_graph(self, X=None, n_neighbors=None, mode="connectivit...
  function _tree_query_radius_parallel_helper (line 904) | def _tree_query_radius_parallel_helper(tree, *args, **kwargs):
  class RadiusNeighborsMixin (line 913) | class RadiusNeighborsMixin:
    method _radius_neighbors_reduce_func (line 916) | def _radius_neighbors_reduce_func(self, dist, start, radius, return_di...
    method radius_neighbors (line 955) | def radius_neighbors(
    method radius_neighbors_graph (line 1147) | def radius_neighbors_graph(

FILE: sklearn/neighbors/_classification.py
  class KNeighborsClassifier (line 22) | class KNeighborsClassifier(KNeighborsMixin, ClassifierMixin, NeighborsBa...
    method __init__ (line 155) | def __init__(
    method fit (line 178) | def fit(self, X, y):
    method predict (line 200) | def predict(self, X):
    method predict_proba (line 240) | def predict_proba(self, X):
    method _more_tags (line 292) | def _more_tags(self):
  class RadiusNeighborsClassifier (line 296) | class RadiusNeighborsClassifier(RadiusNeighborsMixin, ClassifierMixin, N...
    method __init__ (line 446) | def __init__(
    method fit (line 481) | def fit(self, X, y):
    method predict (line 554) | def predict(self, X):
    method predict_proba (line 596) | def predict_proba(self, X):
    method _more_tags (line 684) | def _more_tags(self):

FILE: sklearn/neighbors/_distance_metric.py
  class DistanceMetric (line 7) | class DistanceMetric(_DistanceMetric):
    method _warn (line 9) | def _warn(cls):
    method get_metric (line 18) | def get_metric(cls, metric, **kwargs):

FILE: sklearn/neighbors/_graph.py
  function _check_params (line 14) | def _check_params(X, metric, p, metric_params):
  function _query_include_self (line 26) | def _query_include_self(X, include_self, mode):
  function kneighbors_graph (line 38) | def kneighbors_graph(
  function radius_neighbors_graph (line 128) | def radius_neighbors_graph(
  class KNeighborsTransformer (line 222) | class KNeighborsTransformer(KNeighborsMixin, TransformerMixin, Neighbors...
    method __init__ (line 348) | def __init__(
    method fit (line 372) | def fit(self, X, y=None):
    method transform (line 390) | def transform(self, X):
    method fit_transform (line 412) | def fit_transform(self, X, y=None):
    method _more_tags (line 436) | def _more_tags(self):
  class RadiusNeighborsTransformer (line 444) | class RadiusNeighborsTransformer(RadiusNeighborsMixin, TransformerMixin,...
    method __init__ (line 572) | def __init__(
    method fit (line 596) | def fit(self, X, y=None):
    method transform (line 615) | def transform(self, X):
    method fit_transform (line 634) | def fit_transform(self, X, y=None):
    method _more_tags (line 658) | def _more_tags(self):

FILE: sklearn/neighbors/_kde.py
  class KernelDensity (line 32) | class KernelDensity(BaseEstimator):
    method __init__ (line 115) | def __init__(
    method _choose_algorithm (line 138) | def _choose_algorithm(self, algorithm, metric):
    method fit (line 158) | def fit(self, X, y=None, sample_weight=None):
    method score_samples (line 208) | def score_samples(self, X):
    method score (line 246) | def score(self, X, y=None):
    method sample (line 268) | def sample(self, n_samples=1, random_state=None):
    method _more_tags (line 321) | def _more_tags(self):

FILE: sklearn/neighbors/_lof.py
  class LocalOutlierFactor (line 19) | class LocalOutlierFactor(KNeighborsMixin, OutlierMixin, NeighborsBase):
    method __init__ (line 195) | def __init__(
    method _check_novelty_fit_predict (line 220) | def _check_novelty_fit_predict(self):
    method fit_predict (line 230) | def fit_predict(self, X, y=None):
    method fit (line 257) | def fit(self, X, y=None):
    method _check_novelty_predict (line 317) | def _check_novelty_predict(self):
    method predict (line 329) | def predict(self, X=None):
    method _predict (line 349) | def _predict(self, X=None):
    method _check_novelty_decision_function (line 378) | def _check_novelty_decision_function(self):
    method decision_function (line 392) | def decision_function(self, X):
    method _check_novelty_score_samples (line 419) | def _check_novelty_score_samples(self):
    method score_samples (line 432) | def score_samples(self, X):
    method _local_reachability_density (line 471) | def _local_reachability_density(self, distances_X, neighbors_indices):

FILE: sklearn/neighbors/_nca.py
  class NeighborhoodComponentsAnalysis (line 27) | class NeighborhoodComponentsAnalysis(TransformerMixin, BaseEstimator):
    method __init__ (line 178) | def __init__(
    method fit (line 199) | def fit(self, X, y):
    method transform (line 271) | def transform(self, X):
    method _validate_params (line 295) | def _validate_params(self, X, y):
    method _initialize (line 411) | def _initialize(self, X, y, init):
    method _callback (line 476) | def _callback(self, transformation):
    method _loss_grad_lbfgs (line 489) | def _loss_grad_lbfgs(self, transformation, X, same_class_mask, sign=1.0):
    method _more_tags (line 563) | def _more_tags(self):

FILE: sklearn/neighbors/_nearest_centroid.py
  class NearestCentroid (line 23) | class NearestCentroid(ClassifierMixin, BaseEstimator):
    method __init__ (line 98) | def __init__(self, metric="euclidean", *, shrink_threshold=None):
    method fit (line 102) | def fit(self, X, y):
    method predict (line 197) | def predict(self, X):

FILE: sklearn/neighbors/_regression.py
  class KNeighborsRegressor (line 23) | class KNeighborsRegressor(KNeighborsMixin, RegressorMixin, NeighborsBase):
    method __init__ (line 155) | def __init__(
    method _more_tags (line 178) | def _more_tags(self):
    method _pairwise (line 189) | def _pairwise(self):
    method fit (line 193) | def fit(self, X, y):
    method predict (line 215) | def predict(self, X):
  class RadiusNeighborsRegressor (line 253) | class RadiusNeighborsRegressor(RadiusNeighborsMixin, RegressorMixin, Nei...
    method __init__ (line 377) | def __init__(
    method fit (line 400) | def fit(self, X, y):
    method predict (line 422) | def predict(self, X):

FILE: sklearn/neighbors/_unsupervised.py
  class NearestNeighbors (line 7) | class NearestNeighbors(KNeighborsMixin, RadiusNeighborsMixin, NeighborsB...
    method __init__ (line 126) | def __init__(
    method fit (line 149) | def fit(self, X, y=None):

FILE: sklearn/neighbors/setup.py
  function configuration (line 4) | def configuration(parent_package="", top_path=None):

FILE: sklearn/neighbors/tests/test_ball_tree.py
  function brute_force_neighbors (line 41) | def brute_force_neighbors(X, Y, k, metric, **kwargs):
  function test_ball_tree_query_metrics (line 53) | def test_ball_tree_query_metrics(metric, array_type):
  function test_query_haversine (line 72) | def test_query_haversine():
  function test_array_object_type (line 83) | def test_array_object_type():

FILE: sklearn/neighbors/tests/test_graph.py
  function test_transformer_result (line 8) | def test_transformer_result():
  function _has_explicit_diagonal (line 53) | def _has_explicit_diagonal(X):
  function test_explicit_diagonal (line 60) | def test_explicit_diagonal():

FILE: sklearn/neighbors/tests/test_kd_tree.py
  function test_array_object_type (line 11) | def test_array_object_type():

FILE: sklearn/neighbors/tests/test_kde.py
  function compute_kernel_slow (line 17) | def compute_kernel_slow(Y, X, kernel, h):
  function check_results (line 37) | def check_results(kernel, bandwidth, atol, rtol, X, Y, dens_true):
  function test_kernel_density (line 50) | def test_kernel_density(kernel, bandwidth):
  function test_kernel_density_sampling (line 65) | def test_kernel_density_sampling(n_samples=100, n_features=3):
  function test_kde_algorithm_metric_choice (line 104) | def test_kde_algorithm_metric_choice(algorithm, metric):
  function test_kde_score (line 121) | def test_kde_score(n_samples=100, n_features=3):
  function test_kde_badargs (line 129) | def test_kde_badargs():
  function test_kde_pipeline_gridsearch (line 148) | def test_kde_pipeline_gridsearch():
  function test_kde_sample_weights (line 161) | def test_kde_sample_weights():
  function test_sample_weight_invalid (line 208) | def test_sample_weight_invalid():
  function test_pickling (line 220) | def test_pickling(tmpdir, sample_weight):
  function test_check_is_fitted (line 241) | def test_check_is_fitted(method):

FILE: sklearn/neighbors/tests/test_lof.py
  function test_lof (line 33) | def test_lof():
  function test_lof_performance (line 51) | def test_lof_performance():
  function test_lof_values (line 72) | def test_lof_values():
  function test_lof_precomputed (line 92) | def test_lof_precomputed(random_state=42):
  function test_n_neighbors_attribute (line 118) | def test_n_neighbors_attribute():
  function test_score_samples (line 130) | def test_score_samples():
  function test_contamination (line 149) | def test_contamination():
  function test_novelty_errors (line 156) | def test_novelty_errors():
  function test_novelty_training_scores (line 175) | def test_novelty_training_scores():
  function test_hasattr_prediction (line 193) | def test_hasattr_prediction():
  function test_novelty_true_common_tests (line 215) | def test_novelty_true_common_tests(estimator, check):
  function test_predicted_outlier_number (line 222) | def test_predicted_outlier_number(expected_outliers):

FILE: sklearn/neighbors/tests/test_nca.py
  function test_simple_example (line 32) | def test_simple_example():
  function test_toy_example_collapse_points (line 50) | def test_toy_example_collapse_points():
  function test_finite_differences (line 91) | def test_finite_differences():
  function test_params_validation (line 116) | def test_params_validation():
  function test_transformation_dimensions (line 162) | def test_transformation_dimensions():
  function test_n_components (line 183) | def test_n_components():
  function test_init_transformation (line 218) | def test_init_transformation():
  function test_auto_init (line 286) | def test_auto_init(n_samples, n_features, n_classes, n_components):
  function test_warm_start_validation (line 317) | def test_warm_start_validation():
  function test_warm_start_effectiveness (line 347) | def test_warm_start_effectiveness():
  function test_verbose (line 382) | def test_verbose(init_name, capsys):
  function test_no_verbose (line 426) | def test_no_verbose(capsys):
  function test_singleton_class (line 435) | def test_singleton_class():
  function test_one_class (line 471) | def test_one_class():
  function test_callback (line 482) | def test_callback(capsys):
  function test_expected_transformation_shape (line 506) | def test_expected_transformation_shape():
  function test_convergence_warning (line 532) | def test_convergence_warning():
  function test_parameters_valid_types (line 548) | def test_parameters_valid_types(param, value):

FILE: sklearn/neighbors/tests/test_nearest_centroid.py
  function test_classification_toy (line 29) | def test_classification_toy():
  function test_precomputed (line 56) | def test_precomputed():
  function test_iris (line 62) | def test_iris():
  function test_iris_shrinkage (line 70) | def test_iris_shrinkage():
  function test_pickle (line 80) | def test_pickle():
  function test_shrinkage_correct (line 99) | def test_shrinkage_correct():
  function test_shrinkage_threshold_decoded_y (line 113) | def test_shrinkage_threshold_decoded_y():
  function test_predict_translated_data (line 123) | def test_predict_translated_data():
  function test_manhattan_metric (line 140) | def test_manhattan_metric():
  function test_features_zero_var (line 151) | def test_features_zero_var():

FILE: sklearn/neighbors/tests/test_neighbors.py
  function _weight_func (line 61) | def _weight_func(dist):
  function test_unsupervised_kneighbors (line 73) | def test_unsupervised_kneighbors(
  function test_unsupervised_inputs (line 108) | def test_unsupervised_inputs(NearestNeighbors):
  function test_n_neighbors_datatype (line 129) | def test_n_neighbors_datatype():
  function test_not_fitted_error_gets_raised (line 144) | def test_not_fitted_error_gets_raised():
  function check_precomputed (line 154) | def check_precomputed(make_train_test, estimators):
  function test_precomputed_dense (line 209) | def test_precomputed_dense():
  function test_precomputed_sparse_knn (line 226) | def test_precomputed_sparse_knn(fmt):
  function test_precomputed_sparse_radius (line 244) | def test_precomputed_sparse_radius(fmt):
  function test_is_sorted_by_data (line 261) | def test_is_sorted_by_data():
  function test_check_precomputed (line 286) | def test_check_precomputed():
  function test_precomputed_sparse_invalid (line 304) | def test_precomputed_sparse_invalid():
  function test_precomputed_cross_validation (line 328) | def test_precomputed_cross_validation():
  function test_unsupervised_radius_neighbors (line 345) | def test_unsupervised_radius_neighbors(
  function test_kneighbors_classifier (line 389) | def test_kneighbors_classifier(
  function test_kneighbors_classifier_float_labels (line 415) | def test_kneighbors_classifier_float_labels(
  function test_kneighbors_classifier_predict_proba (line 430) | def test_kneighbors_classifier_predict_proba():
  function test_radius_neighbors_classifier (line 460) | def test_radius_neighbors_classifier(
  function test_radius_neighbors_classifier_kwargs_is_deprecated (line 486) | def test_radius_neighbors_classifier_kwargs_is_deprecated():
  function test_radius_neighbors_classifier_when_no_neighbors (line 500) | def test_radius_neighbors_classifier_when_no_neighbors():
  function test_radius_neighbors_classifier_outlier_labeling (line 530) | def test_radius_neighbors_classifier_outlier_labeling():
  function test_radius_neighbors_classifier_zero_distance (line 650) | def test_radius_neighbors_classifier_zero_distance():
  function test_neighbors_regressors_zero_distance (line 674) | def test_neighbors_regressors_zero_distance():
  function test_radius_neighbors_boundary_handling (line 707) | def test_radius_neighbors_boundary_handling():
  function test_radius_neighbors_returns_array_of_objects (line 725) | def test_radius_neighbors_returns_array_of_objects():
  function test_query_equidistant_kth_nn (line 748) | def test_query_equidistant_kth_nn(algorithm):
  function test_radius_neighbors_sort_results (line 771) | def test_radius_neighbors_sort_results(algorithm, metric):
  function test_RadiusNeighborsClassifier_multioutput (line 801) | def test_RadiusNeighborsClassifier_multioutput():
  function test_kneighbors_classifier_sparse (line 839) | def test_kneighbors_classifier_sparse(
  function test_KNeighborsClassifier_multioutput (line 859) | def test_KNeighborsClassifier_multioutput():
  function test_kneighbors_regressor (line 903) | def test_kneighbors_regressor(
  function test_KNeighborsRegressor_multioutput_uniform_weight (line 927) | def test_KNeighborsRegressor_multioutput_uniform_weight():
  function test_kneighbors_regressor_multioutput (line 952) | def test_kneighbors_regressor_multioutput(
  function test_radius_neighbors_regressor (line 977) | def test_radius_neighbors_regressor(
  function test_RadiusNeighborsRegressor_multioutput_with_uniform_weight (line 1016) | def test_RadiusNeighborsRegressor_multioutput_with_uniform_weight():
  function test_RadiusNeighborsRegressor_multioutput (line 1044) | def test_RadiusNeighborsRegressor_multioutput(
  function test_kneighbors_regressor_sparse (line 1068) | def test_kneighbors_regressor_sparse(
  function test_neighbors_iris (line 1099) | def test_neighbors_iris():
  function test_neighbors_digits (line 1118) | def test_neighbors_digits():
  function test_kneighbors_graph (line 1139) | def test_kneighbors_graph():
  function test_kneighbors_graph_sparse (line 1171) | def test_kneighbors_graph_sparse(seed=36):
  function test_radius_neighbors_graph (line 1186) | def test_radius_neighbors_graph():
  function test_radius_neighbors_graph_sparse (line 1199) | def test_radius_neighbors_graph_sparse(seed=36):
  function test_neighbors_badargs (line 1216) | def test_neighbors_badargs():
  function test_neighbors_metrics (line 1278) | def test_neighbors_metrics(n_samples=20, n_features=3, n_query_pts=2, n_...
  function test_callable_metric (line 1351) | def test_callable_metric():
  function test_valid_brute_metric_for_auto_algorithm (line 1372) | def test_valid_brute_metric_for_auto_algorithm():
  function test_metric_params_interface (line 1426) | def test_metric_params_interface():
  function test_predict_sparse_ball_kd_tree (line 1434) | def test_predict_sparse_ball_kd_tree():
  function test_non_euclidean_kneighbors (line 1446) | def test_non_euclidean_kneighbors():
  function check_object_arrays (line 1482) | def check_object_arrays(nparray, list_check):
  function test_k_and_radius_neighbors_train_is_not_query (line 1487) | def test_k_and_radius_neighbors_train_is_not_query():
  function test_k_and_radius_neighbors_X_None (line 1516) | def test_k_and_radius_neighbors_X_None():
  function test_k_and_radius_neighbors_duplicates (line 1549) | def test_k_and_radius_neighbors_duplicates():
  function test_include_self_neighbors_graph (line 1594) | def test_include_self_neighbors_graph():
  function test_same_knn_parallel (line 1609) | def test_same_knn_parallel(algorithm):
  function test_same_radius_neighbors_parallel (line 1634) | def test_same_radius_neighbors_parallel(algorithm):
  function test_knn_forcing_backend (line 1661) | def test_knn_forcing_backend(backend, algorithm):
  function test_dtype_convert (line 1679) | def test_dtype_convert():
  function test_sparse_metric_callable (line 1689) | def test_sparse_metric_callable():
  function test_pairwise_boolean_distance (line 1713) | def test_pairwise_boolean_distance():
  function test_radius_neighbors_predict_proba (line 1726) | def test_radius_neighbors_predict_proba():
  function test_pipeline_with_nearest_neighbors_transformer (line 1747) | def test_pipeline_with_nearest_neighbors_transformer():
  function test_auto_algorithm (line 1804) | def test_auto_algorithm(X, metric, metric_params, expected_algo):
  function test_pairwise_deprecated (line 1821) | def test_pairwise_deprecated(NearestNeighbors):
  function test_neighbors_distance_metric_deprecation (line 1829) | def test_neighbors_distance_metric_deprecation():

FILE: sklearn/neighbors/tests/test_neighbors_pipeline.py
  function test_spectral_clustering (line 30) | def test_spectral_clustering():
  function test_spectral_embedding (line 50) | def test_spectral_embedding():
  function test_dbscan (line 81) | def test_dbscan():
  function test_isomap (line 99) | def test_isomap():
  function test_tsne (line 128) | def test_tsne():
  function test_lof_novelty_false (line 167) | def test_lof_novelty_false():
  function test_lof_novelty_true (line 193) | def test_lof_novelty_true():
  function test_kneighbors_regressor (line 220) | def test_kneighbors_regressor():

FILE: sklearn/neighbors/tests/test_neighbors_tree.py
  function dist_func (line 49) | def dist_func(x1, x2, p):
  function compute_kernel_slow (line 53) | def compute_kernel_slow(Y, X, kernel, h):
  function brute_force_neighbors (line 73) | def brute_force_neighbors(X, Y, k, metric, **kwargs):
  function test_kernel_density (line 88) | def test_kernel_density(
  function test_neighbor_tree_query_radius (line 104) | def test_neighbor_tree_query_radius(Cls, n_samples=100, n_features=10):
  function test_neighbor_tree_query_radius_distance (line 124) | def test_neighbor_tree_query_radius_distance(Cls, n_samples=100, n_featu...
  function test_neighbor_tree_two_point (line 146) | def test_neighbor_tree_two_point(Cls, dualtree, n_samples=100, n_feature...
  function test_neighbors_heap (line 161) | def test_neighbors_heap(NeighborsHeap, n_pts=5, n_nbrs=10):
  function test_node_heap (line 182) | def test_node_heap(nodeheap_sort, n_nodes=50):
  function test_simultaneous_sort (line 196) | def test_simultaneous_sort(simultaneous_sort, n_rows=10, n_pts=201):
  function test_gaussian_kde (line 218) | def test_gaussian_kde(Cls, n_samples=1000):
  function test_nn_tree_query (line 246) | def test_nn_tree_query(Cls, metric, k, dualtree, breadth_first):
  function test_pickle (line 267) | def test_pickle(Cls, metric, protocol):

FILE: sklearn/neighbors/tests/test_quad_tree.py
  function test_quadtree_boundary_computation (line 10) | def test_quadtree_boundary_computation():
  function test_quadtree_similar_point (line 29) | def test_quadtree_similar_point():
  function test_quad_tree_pickle (line 65) | def test_quad_tree_pickle(n_dimensions, protocol):
  function test_qt_insert_duplicate (line 83) | def test_qt_insert_duplicate(n_dimensions):
  function test_summarize (line 102) | def test_summarize():

FILE: sklearn/neural_network/_base.py
  function inplace_identity (line 13) | def inplace_identity(X):
  function inplace_logistic (line 25) | def inplace_logistic(X):
  function inplace_tanh (line 36) | def inplace_tanh(X):
  function inplace_relu (line 47) | def inplace_relu(X):
  function inplace_softmax (line 58) | def inplace_softmax(X):
  function inplace_identity_derivative (line 80) | def inplace_identity_derivative(Z, delta):
  function inplace_logistic_derivative (line 95) | def inplace_logistic_derivative(Z, delta):
  function inplace_tanh_derivative (line 114) | def inplace_tanh_derivative(Z, delta):
  function inplace_relu_derivative (line 132) | def inplace_relu_derivative(Z, delta):
  function squared_loss (line 158) | def squared_loss(y_true, y_pred):
  function log_loss (line 177) | def log_loss(y_true, y_prob):
  function binary_log_loss (line 205) | def binary_log_loss(y_true, y_prob):

FILE: sklearn/neural_network/_multilayer_perceptron.py
  function _pack (line 42) | def _pack(coefs_, intercepts_):
  class BaseMultilayerPerceptron (line 47) | class BaseMultilayerPerceptron(BaseEstimator, metaclass=ABCMeta):
    method __init__ (line 57) | def __init__(
    method _unpack (line 109) | def _unpack(self, packed_parameters):
    method _forward_pass (line 118) | def _forward_pass(self, activations):
    method _forward_pass_fast (line 143) | def _forward_pass_fast(self, X):
    method _compute_loss_grad (line 176) | def _compute_loss_grad(
    method _loss_grad_lbfgs (line 190) | def _loss_grad_lbfgs(
    method _backprop (line 240) | def _backprop(self, X, y, activations, deltas, coef_grads, intercept_g...
    method _initialize (line 319) | def _initialize(self, y, layer_units, dtype):
    method _init_coef (line 359) | def _init_coef(self, fan_in, fan_out, dtype):
    method _fit (line 376) | def _fit(self, X, y, incremental=False):
    method _validate_hyperparameters (line 445) | def _validate_hyperparameters(self):
    method _fit_lbfgs (line 506) | def _fit_lbfgs(
    method _fit_stochastic (line 553) | def _fit_stochastic(
    method _update_no_improvement_count (line 706) | def _update_no_improvement_count(self, early_stopping, X_val, y_val):
    method fit (line 735) | def fit(self, X, y):
    method _check_solver (line 754) | def _check_solver(self):
    method partial_fit (line 764) | def partial_fit(self, X, y):
  class MLPClassifier (line 783) | class MLPClassifier(ClassifierMixin, BaseMultilayerPerceptron):
    method __init__ (line 1045) | def __init__(
    method _validate_input (line 1099) | def _validate_input(self, X, y, incremental, reset):
    method predict (line 1153) | def predict(self, X):
    method partial_fit (line 1175) | def partial_fit(self, X, y, classes=None):
    method predict_log_proba (line 1210) | def predict_log_proba(self, X):
    method predict_proba (line 1228) | def predict_proba(self, X):
    method _more_tags (line 1253) | def _more_tags(self):
  class MLPRegressor (line 1257) | class MLPRegressor(RegressorMixin, BaseMultilayerPerceptron):
    method __init__ (line 1515) | def __init__(
    method predict (line 1569) | def predict(self, X):
    method _validate_input (line 1588) | def _validate_input(self, X, y, incremental, reset):

FILE: sklearn/neural_network/_rbm.py
  class BernoulliRBM (line 25) | class BernoulliRBM(TransformerMixin, BaseEstimator):
    method __init__ (line 128) | def __init__(
    method transform (line 145) | def transform(self, X):
    method _mean_hiddens (line 165) | def _mean_hiddens(self, v):
    method _sample_hiddens (line 182) | def _sample_hiddens(self, v, rng):
    method _sample_visibles (line 201) | def _sample_visibles(self, h, rng):
    method _free_energy (line 222) | def _free_energy(self, v):
    method gibbs (line 239) | def gibbs(self, v):
    method partial_fit (line 260) | def partial_fit(self, X, y=None):
    method _fit (line 300) | def _fit(self, v_pos, rng):
    method score_samples (line 330) | def score_samples(self, X):
    method fit (line 367) | def fit(self, X, y=None):
    method _more_tags (line 421) | def _more_tags(self):

FILE: sklearn/neural_network/_stochastic_optimizers.py
  class BaseOptimizer (line 10) | class BaseOptimizer:
    method __init__ (line 25) | def __init__(self, learning_rate_init=0.1):
    method update_params (line 29) | def update_params(self, params, grads):
    method iteration_ends (line 46) | def iteration_ends(self, time_step):
    method trigger_stopping (line 52) | def trigger_stopping(self, msg, verbose):
  class SGDOptimizer (line 73) | class SGDOptimizer(BaseOptimizer):
    method __init__ (line 121) | def __init__(
    method iteration_ends (line 138) | def iteration_ends(self, time_step):
    method trigger_stopping (line 153) | def trigger_stopping(self, msg, verbose):
    method _get_updates (line 169) | def _get_updates(self, grads):
  class AdamOptimizer (line 198) | class AdamOptimizer(BaseOptimizer):
    method __init__ (line 245) | def __init__(
    method _get_updates (line 257) | def _get_updates(self, grads):

FILE: sklearn/neural_network/tests/test_base.py
  function test_binary_log_loss_1_prob_finite (line 8) | def test_binary_log_loss_1_prob_finite():
  function test_log_loss_1_prob_finite (line 27) | def test_log_loss_1_prob_finite(y_true, y_prob):

FILE: sklearn/neural_network/tests/test_mlp.py
  function test_alpha (line 64) | def test_alpha():
  function test_fit (line 85) | def test_fit():
  function test_gradient (line 182) | def test_gradient():
  function test_lbfgs_classification (line 248) | def test_lbfgs_classification(X, y):
  function test_lbfgs_regression (line 273) | def test_lbfgs_regression(X, y):
  function test_lbfgs_classification_maxfun (line 293) | def test_lbfgs_classification_maxfun(X, y):
  function test_lbfgs_regression_maxfun (line 314) | def test_lbfgs_regression_maxfun(X, y):
  function test_learning_rate_warmstart (line 339) | def test_learning_rate_warmstart():
  function test_multilabel_classification (line 364) | def test_multilabel_classification():
  function test_multioutput_regression (line 402) | def test_multioutput_regression():
  function test_partial_fit_classes_error (line 412) | def test_partial_fit_classes_error():
  function test_partial_fit_classification (line 422) | def test_partial_fit_classification():
  function test_partial_fit_unseen_classes (line 449) | def test_partial_fit_unseen_classes():
  function test_partial_fit_regression (line 459) | def test_partial_fit_regression():
  function test_partial_fit_errors (line 496) | def test_partial_fit_errors():
  function test_params_errors (line 534) | def test_params_errors(args):
  function test_predict_proba_binary (line 544) | def test_predict_proba_binary():
  function test_predict_proba_multiclass (line 567) | def test_predict_proba_multiclass():
  function test_predict_proba_multilabel (line 588) | def test_predict_proba_multilabel():
  function test_shuffle (line 612) | def test_shuffle():
  function test_sparse_matrices (line 650) | def test_sparse_matrices():
  function test_tolerance (line 666) | def test_tolerance():
  function test_verbose_sgd (line 676) | def test_verbose_sgd():
  function test_early_stopping (line 692) | def test_early_stopping():
  function test_adaptive_learning_rate (line 707) | def test_adaptive_learning_rate():
  function test_warm_start (line 717) | def test_warm_start():
  function test_warm_start_full_iteration (line 747) | def test_warm_start_full_iteration(MLPEstimator):
  function test_n_iter_no_change (line 763) | def test_n_iter_no_change():
  function test_n_iter_no_change_inf (line 784) | def test_n_iter_no_change_inf():
  function test_early_stopping_stratified (line 809) | def test_early_stopping_stratified():
  function test_mlp_classifier_dtypes_casting (line 821) | def test_mlp_classifier_dtypes_casting():
  function test_mlp_regressor_dtypes_casting (line 841) | def test_mlp_regressor_dtypes_casting():
  function test_mlp_param_dtypes (line 859) | def test_mlp_param_dtypes(dtype, Estimator):
  function test_mlp_loading_from_joblib_partial_fit (line 875) | def test_mlp_loading_from_joblib_partial_fit(tmp_path):

FILE: sklearn/neural_network/tests/test_rbm.py
  function test_fit (line 23) | def test_fit():
  function test_partial_fit (line 37) | def test_partial_fit():
  function test_transform (line 54) | def test_transform():
  function test_small_sparse (line 65) | def test_small_sparse():
  function test_small_sparse_partial_fit (line 71) | def test_small_sparse_partial_fit():
  function test_sample_hiddens (line 91) | def test_sample_hiddens():
  function test_fit_gibbs (line 103) | def test_fit_gibbs():
  function test_fit_gibbs_sparse (line 118) | def test_fit_gibbs_sparse():
  function test_gibbs_smoke (line 135) | def test_gibbs_smoke():
  function test_score_samples (line 147) | def test_score_samples():
  function test_rbm_verbose (line 171) | def test_rbm_verbose():
  function test_sparse_and_verbose (line 181) | def test_sparse_and_verbose():
  function test_transformer_dtypes_casting (line 209) | def test_transformer_dtypes_casting(dtype_in, dtype_out):
  function test_convergence_dtype_consistency (line 220) | def test_convergence_dtype_consistency():

FILE: sklearn/neural_network/tests/test_stochastic_optimizers.py
  function test_base_optimizer (line 14) | def test_base_optimizer():
  function test_sgd_optimizer_no_momentum (line 20) | def test_sgd_optimizer_no_momentum():
  function test_sgd_optimizer_momentum (line 34) | def test_sgd_optimizer_momentum():
  function test_sgd_optimizer_trigger_stopping (line 54) | def test_sgd_optimizer_trigger_stopping():
  function test_sgd_optimizer_nesterovs_momentum (line 63) | def test_sgd_optimizer_nesterovs_momentum():
  function test_adam_optimizer (line 86) | def test_adam_optimizer():

FILE: sklearn/pipeline.py
  function _final_estimator_has (line 39) | def _final_estimator_has(attr):
  class Pipeline (line 52) | class Pipeline(_BaseComposition):
    method __init__ (line 145) | def __init__(self, steps, *, memory=None, verbose=False):
    method get_params (line 151) | def get_params(self, deep=True):
    method set_params (line 170) | def set_params(self, **kwargs):
    method _validate_steps (line 192) | def _validate_steps(self):
    method _iter (line 227) | def _iter(self, with_final=True, filter_passthrough=True):
    method __len__ (line 244) | def __len__(self):
    method __getitem__ (line 250) | def __getitem__(self, ind):
    method _estimator_type (line 273) | def _estimator_type(self):
    method named_steps (line 277) | def named_steps(self):
    method _final_estimator (line 286) | def _final_estimator(self):
    method _log_message (line 290) | def _log_message(self, step_idx):
    method _check_fit_params (line 297) | def _check_fit_params(self, **fit_params):
    method _fit (line 314) | def _fit(self, X, y=None, **fit_params_steps):
    method fit (line 364) | def fit(self, X, y=None, **fit_params):
    method fit_transform (line 399) | def fit_transform(self, X, y=None, **fit_params):
    method predict (line 440) | def predict(self, X, **predict_params):
    method fit_predict (line 474) | def fit_predict(self, X, y=None, **fit_params):
    method predict_proba (line 511) | def predict_proba(self, X, **predict_proba_params):
    method decision_function (line 540) | def decision_function(self, X):
    method score_samples (line 565) | def score_samples(self, X):
    method predict_log_proba (line 590) | def predict_log_proba(self, X, **predict_log_proba_params):
    method _can_transform (line 618) | def _can_transform(self):
    method transform (line 624) | def transform(self, X):
    method _can_inverse_transform (line 651) | def _can_inverse_transform(self):
    method inverse_transform (line 655) | def inverse_transform(self, Xt):
    method score (line 680) | def score(self, X, y=None, sample_weight=None):
    method classes_ (line 715) | def classes_(self):
    method _more_tags (line 719) | def _more_tags(self):
    method _pairwise (line 730) | def _pairwise(self):
    method get_feature_names_out (line 734) | def get_feature_names_out(self, input_features=None):
    method n_features_in_ (line 761) | def n_features_in_(self):
    method feature_names_in_ (line 767) | def feature_names_in_(self):
    method __sklearn_is_fitted__ (line 772) | def __sklearn_is_fitted__(self):
    method _sk_visual_block_ (line 784) | def _sk_visual_block_(self):
  function _name_estimators (line 804) | def _name_estimators(estimators):
  function make_pipeline (line 828) | def make_pipeline(*steps, memory=None, verbose=False):
  function _transform_one (line 876) | def _transform_one(transformer, X, y, weight, **fit_params):
  function _fit_transform_one (line 884) | def _fit_transform_one(
  function _fit_one (line 903) | def _fit_one(transformer, X, y, weight, message_clsname="", message=None...
  class FeatureUnion (line 911) | class FeatureUnion(TransformerMixin, _BaseComposition):
    method __init__ (line 988) | def __init__(
    method get_params (line 997) | def get_params(self, deep=True):
    method set_params (line 1017) | def set_params(self, **kwargs):
    method _validate_transformers (line 1039) | def _validate_transformers(self):
    method _validate_transformer_weights (line 1057) | def _validate_transformer_weights(self):
    method _iter (line 1069) | def _iter(self):
    method get_feature_names (line 1088) | def get_feature_names(self):
    method get_feature_names_out (line 1106) | def get_feature_names_out(self, input_features=None):
    method fit (line 1131) | def fit(self, X, y=None, **fit_params):
    method fit_transform (line 1158) | def fit_transform(self, X, y=None, **fit_params):
    method _log_message (line 1189) | def _log_message(self, name, idx, total):
    method _parallel_func (line 1194) | def _parallel_func(self, X, y, fit_params, func):
    method transform (line 1214) | def transform(self, X):
    method _hstack (line 1239) | def _hstack(self, Xs):
    method _update_transformer_list (line 1246) | def _update_transformer_list(self, transformers):
    method n_features_in_ (line 1254) | def n_features_in_(self):
    method _sk_visual_block_ (line 1260) | def _sk_visual_block_(self):
  function make_union (line 1265) | def make_union(*transformers, n_jobs=None, verbose=False):

FILE: sklearn/preprocessing/_data.py
  function _is_constant_feature (line 68) | def _is_constant_feature(var, mean, n_samples):
  function _handle_zeros_in_scale (line 84) | def _handle_zeros_in_scale(scale, copy=True, constant_mask=None):
  function scale (line 117) | def scale(X, *, axis=0, with_mean=True, with_std=True, copy=True):
  class MinMaxScaler (line 265) | class MinMaxScaler(_OneToOneFeatureMixin, TransformerMixin, BaseEstimator):
    method __init__ (line 377) | def __init__(self, feature_range=(0, 1), *, copy=True, clip=False):
    method _reset (line 382) | def _reset(self):
    method fit (line 397) | def fit(self, X, y=None):
    method partial_fit (line 418) | def partial_fit(self, X, y=None):
    method transform (line 480) | def transform(self, X):
    method inverse_transform (line 509) | def inverse_transform(self, X):
    method _more_tags (line 532) | def _more_tags(self):
  function minmax_scale (line 536) | def minmax_scale(X, feature_range=(0, 1), *, axis=0, copy=True):
  class StandardScaler (line 631) | class StandardScaler(_OneToOneFeatureMixin, TransformerMixin, BaseEstima...
    method __init__ (line 762) | def __init__(self, *, copy=True, with_mean=True, with_std=True):
    method _reset (line 767) | def _reset(self):
    method fit (line 780) | def fit(self, X, y=None, sample_weight=None):
    method partial_fit (line 807) | def partial_fit(self, X, y=None, sample_weight=None):
    method transform (line 953) | def transform(self, X, copy=None):
    method inverse_transform (line 995) | def inverse_transform(self, X, copy=None):
    method _more_tags (line 1036) | def _more_tags(self):
  class MaxAbsScaler (line 1040) | class MaxAbsScaler(_OneToOneFeatureMixin, TransformerMixin, BaseEstimator):
    method __init__ (line 1112) | def __init__(self, *, copy=True):
    method _reset (line 1115) | def _reset(self):
    method fit (line 1127) | def fit(self, X, y=None):
    method partial_fit (line 1148) | def partial_fit(self, X, y=None):
    method transform (line 1194) | def transform(self, X):
    method inverse_transform (line 1223) | def inverse_transform(self, X):
    method _more_tags (line 1251) | def _more_tags(self):
  function maxabs_scale (line 1255) | def maxabs_scale(X, *, axis=0, copy=True):
  class RobustScaler (line 1337) | class RobustScaler(_OneToOneFeatureMixin, TransformerMixin, BaseEstimator):
    method __init__ (line 1447) | def __init__(
    method fit (line 1462) | def fit(self, X, y=None):
    method transform (line 1528) | def transform(self, X):
    method inverse_transform (line 1561) | def inverse_transform(self, X):
    method _more_tags (line 1593) | def _more_tags(self):
  function robust_scale (line 1597) | def robust_scale(
  function normalize (line 1723) | def normalize(X, norm="l2", *, axis=1, copy=True, return_norm=False):
  class Normalizer (line 1828) | class Normalizer(TransformerMixin, BaseEstimator):
    method __init__ (line 1900) | def __init__(self, norm="l2", *, copy=True):
    method fit (line 1904) | def fit(self, X, y=None):
    method transform (line 1926) | def transform(self, X, copy=None):
    method _more_tags (line 1947) | def _more_tags(self):
  function binarize (line 1951) | def binarize(X, *, threshold=0.0, copy=True):
  class Binarizer (line 1999) | class Binarizer(TransformerMixin, BaseEstimator):
    method __init__ (line 2068) | def __init__(self, *, threshold=0.0, copy=True):
    method fit (line 2072) | def fit(self, X, y=None):
    method transform (line 2094) | def transform(self, X, copy=None):
    method _more_tags (line 2118) | def _more_tags(self):
  class KernelCenterer (line 2122) | class KernelCenterer(TransformerMixin, BaseEstimator):
    method __init__ (line 2200) | def __init__(self):
    method fit (line 2204) | def fit(self, K, y=None):
    method transform (line 2233) | def transform(self, K, copy=True):
    method _more_tags (line 2261) | def _more_tags(self):
    method _pairwise (line 2271) | def _pairwise(self):
  function add_dummy_feature (line 2275) | def add_dummy_feature(X, value=1.0):
  class QuantileTransformer (line 2332) | class QuantileTransformer(_OneToOneFeatureMixin, TransformerMixin, BaseE...
    method __init__ (line 2442) | def __init__(
    method _dense_fit (line 2459) | def _dense_fit(self, X, random_state):
    method _sparse_fit (line 2491) | def _sparse_fit(self, X, random_state):
    method fit (line 2536) | def fit(self, X, y=None):
    method _transform_col (line 2598) | def _transform_col(self, X_col, quantiles, inverse):
    method _check_inputs (line 2663) | def _check_inputs(self, X, in_fit, accept_sparse_negative=False, copy=...
    method _transform (line 2694) | def _transform(self, X, inverse=False):
    method transform (line 2725) | def transform(self, X):
    method inverse_transform (line 2746) | def inverse_transform(self, X):
    method _more_tags (line 2769) | def _more_tags(self):
  function quantile_transform (line 2773) | def quantile_transform(
  class PowerTransformer (line 2916) | class PowerTransformer(_OneToOneFeatureMixin, TransformerMixin, BaseEsti...
    method __init__ (line 3011) | def __init__(self, method="yeo-johnson", *, standardize=True, copy=True):
    method fit (line 3016) | def fit(self, X, y=None):
    method fit_transform (line 3038) | def fit_transform(self, X, y=None):
    method _fit (line 3057) | def _fit(self, X, y=None, force_transform=False):
    method transform (line 3088) | def transform(self, X):
    method inverse_transform (line 3117) | def inverse_transform(self, X):
    method _box_cox_inverse_tranform (line 3164) | def _box_cox_inverse_tranform(self, x, lmbda):
    method _yeo_johnson_inverse_transform (line 3175) | def _yeo_johnson_inverse_transform(self, x, lmbda):
    method _yeo_johnson_transform (line 3196) | def _yeo_johnson_transform(self, x, lmbda):
    method _box_cox_optimize (line 3218) | def _box_cox_optimize(self, x):
    method _yeo_johnson_optimize (line 3230) | def _yeo_johnson_optimize(self, x):
    method _check_input (line 3254) | def _check_input(
    method _more_tags (line 3312) | def _more_tags(self):
  function power_transform (line 3316) | def power_transform(X, method="yeo-johnson", *, standardize=True, copy=T...

FILE: sklearn/preprocessing/_discretization.py
  class KBinsDiscretizer (line 24) | class KBinsDiscretizer(TransformerMixin, BaseEstimator):
    method __init__ (line 163) | def __init__(
    method fit (line 180) | def fit(self, X, y=None):
    method _validate_n_bins (line 323) | def _validate_n_bins(self, n_features):
    method transform (line 362) | def transform(self, X):
    method inverse_transform (line 409) | def inverse_transform(self, Xt):
    method get_feature_names_out (line 447) | def get_feature_names_out(self, input_features=None):

FILE: sklearn/preprocessing/_encoders.py
  class _BaseEncoder (line 23) | class _BaseEncoder(TransformerMixin, BaseEstimator):
    method _check_X (line 30) | def _check_X(self, X, force_all_finite=True):
    method _get_feature (line 67) | def _get_feature(self, X, feature_idx):
    method _fit (line 74) | def _fit(self, X, handle_unknown="error", force_all_finite=True):
    method _transform (line 119) | def _transform(
    method _more_tags (line 179) | def _more_tags(self):
  class OneHotEncoder (line 183) | class OneHotEncoder(_BaseEncoder):
    method __init__ (line 347) | def __init__(
    method _validate_keywords (line 362) | def _validate_keywords(self):
    method _compute_drop_idx (line 371) | def _compute_drop_idx(self):
    method fit (line 442) | def fit(self, X, y=None):
    method fit_transform (line 465) | def fit_transform(self, X, y=None):
    method transform (line 490) | def transform(self, X):
    method inverse_transform (line 561) | def inverse_transform(self, X):
    method get_feature_names (line 667) | def get_feature_names(self, input_features=None):
    method get_feature_names_out (line 702) | def get_feature_names_out(self, input_features=None):
  class OrdinalEncoder (line 734) | class OrdinalEncoder(_BaseEncoder):
    method __init__ (line 825) | def __init__(
    method fit (line 838) | def fit(self, X, y=None):
    method transform (line 916) | def transform(self, X):
    method inverse_transform (line 944) | def inverse_transform(self, X):

FILE: sklearn/preprocessing/_function_transformer.py
  function _identity (line 7) | def _identity(X):
  class FunctionTransformer (line 12) | class FunctionTransformer(TransformerMixin, BaseEstimator):
    method __init__ (line 108) | def __init__(
    method _check_input (line 127) | def _check_input(self, X, *, reset):
    method _check_inverse_transform (line 132) | def _check_inverse_transform(self, X):
    method fit (line 145) | def fit(self, X, y=None):
    method transform (line 168) | def transform(self, X):
    method inverse_transform (line 184) | def inverse_transform(self, X):
    method _transform (line 201) | def _transform(self, X, func=None, kw_args=None):
    method __sklearn_is_fitted__ (line 207) | def __sklearn_is_fitted__(self):
    method _more_tags (line 211) | def _more_tags(self):

FILE: sklearn/preprocessing/_label.py
  class LabelEncoder (line 35) | class LabelEncoder(TransformerMixin, BaseEstimator):
    method fit (line 85) | def fit(self, y):
    method fit_transform (line 102) | def fit_transform(self, y):
    method transform (line 119) | def transform(self, y):
    method inverse_transform (line 140) | def inverse_transform(self, y):
    method _more_tags (line 165) | def _more_tags(self):
  class LabelBinarizer (line 169) | class LabelBinarizer(TransformerMixin, BaseEstimator):
    method __init__ (line 258) | def __init__(self, *, neg_label=0, pos_label=1, sparse_output=False):
    method fit (line 264) | def fit(self, y):
    method fit_transform (line 305) | def fit_transform(self, y):
    method transform (line 327) | def transform(self, y):
    method inverse_transform (line 361) | def inverse_transform(self, Y, threshold=None):
    method _more_tags (line 412) | def _more_tags(self):
  function label_binarize (line 416) | def label_binarize(y, *, classes, neg_label=0, pos_label=1, sparse_outpu...
  function _inverse_binarize_multiclass (line 587) | def _inverse_binarize_multiclass(y, classes):
  function _inverse_binarize_thresholding (line 630) | def _inverse_binarize_thresholding(y, output_type, classes, threshold):
  class MultiLabelBinarizer (line 674) | class MultiLabelBinarizer(TransformerMixin, BaseEstimator):
    method __init__ (line 737) | def __init__(self, *, classes=None, sparse_output=False):
    method fit (line 741) | def fit(self, y):
    method fit_transform (line 772) | def fit_transform(self, y):
    method transform (line 815) | def transform(self, y):
    method _build_cache (line 841) | def _build_cache(self):
    method _transform (line 847) | def _transform(self, y, class_mapping):
    method inverse_transform (line 887) | def inverse_transform(self, yt):
    method _more_tags (line 928) | def _more_tags(self):

FILE: sklearn/preprocessing/_polynomial.py
  class PolynomialFeatures (line 31) | class PolynomialFeatures(TransformerMixin, BaseEstimator):
    method __init__ (line 133) | def __init__(
    method _combinations (line 142) | def _combinations(
    method _num_combinations (line 155) | def _num_combinations(
    method powers_ (line 183) | def powers_(self):
    method get_feature_names (line 202) | def get_feature_names(self, input_features=None):
    method get_feature_names_out (line 234) | def get_feature_names_out(self, input_features=None):
    method fit (line 270) | def fit(self, X, y=None):
    method transform (line 338) | def transform(self, X):
    method n_input_features_ (line 496) | def n_input_features_(self):
  class SplineTransformer (line 502) | class SplineTransformer(TransformerMixin, BaseEstimator):
    method __init__ (line 616) | def __init__(
    method _get_base_knot_positions (line 634) | def _get_base_knot_positions(X, n_knots=10, knots="uniform", sample_we...
    method get_feature_names (line 684) | def get_feature_names(self, input_features=None):
    method get_feature_names_out (line 707) | def get_feature_names_out(self, input_features=None):
    method fit (line 734) | def fit(self, X, y=None, sample_weight=None):
    method transform (line 889) | def transform(self, X):

FILE: sklearn/preprocessing/setup.py
  function configuration (line 4) | def configuration(parent_package="", top_path=None):

FILE: sklearn/preprocessing/tests/test_common.py
  function _get_valid_samples_by_column (line 33) | def _get_valid_samples_by_column(X, col):
  function test_missing_value_handling (line 52) | def test_missing_value_handling(
  function test_missing_value_pandas_na_support (line 161) | def test_missing_value_pandas_na_support(est, func):

FILE: sklearn/preprocessing/tests/test_data.py
  function toarray (line 75) | def toarray(a):
  function _check_dim_1axis (line 81) | def _check_dim_1axis(a):
  function assert_correct_incr (line 85) | def assert_correct_incr(i, batch_start, batch_stop, n, chunk_size, n_sam...
  function test_raises_value_error_if_sample_weights_greater_than_1d (line 92) | def test_raises_value_error_if_sample_weights_greater_than_1d():
  function test_standard_scaler_sample_weight (line 133) | def test_standard_scaler_sample_weight(Xw, X, sample_weight, array_const...
  function test_standard_scaler_1d (line 155) | def test_standard_scaler_1d():
  function test_standard_scaler_dtype (line 196) | def test_standard_scaler_dtype(add_sample_weight, sparse_constructor):
  function test_standard_scaler_constant_features (line 232) | def test_standard_scaler_constant_features(
  function test_standard_scaler_near_constant_features (line 277) | def test_standard_scaler_near_constant_features(
  function test_scale_1d (line 327) | def test_scale_1d():
  function test_standard_scaler_numerical_stability (line 340) | def test_standard_scaler_numerical_stability():
  function test_scaler_2d_arrays (line 378) | def test_scaler_2d_arrays():
  function test_scaler_float16_overflow (line 430) | def test_scaler_float16_overflow():
  function test_handle_zeros_in_scale (line 455) | def test_handle_zeros_in_scale():
  function test_minmax_scaler_partial_fit (line 463) | def test_minmax_scaler_partial_fit():
  function test_standard_scaler_partial_fit (line 511) | def test_standard_scaler_partial_fit():
  function test_standard_scaler_partial_fit_numerical_stability (line 562) | def test_standard_scaler_partial_fit_numerical_stability():
  function test_partial_fit_sparse_input (line 609) | def test_partial_fit_sparse_input(sample_weight):
  function test_standard_scaler_trasform_with_partial_fit (line 629) | def test_standard_scaler_trasform_with_partial_fit(sample_weight):
  function test_standard_check_array_of_inverse_transform (line 671) | def test_standard_check_array_of_inverse_transform():
  function test_min_max_scaler_iris (line 695) | def test_min_max_scaler_iris():
  function test_min_max_scaler_zero_variance_features (line 727) | def test_min_max_scaler_zero_variance_features():
  function test_minmax_scale_axis1 (line 758) | def test_minmax_scale_axis1():
  function test_min_max_scaler_1d (line 765) | def test_min_max_scaler_1d():
  function test_scaler_without_centering (line 805) | def test_scaler_without_centering(sample_weight):
  function test_scaler_n_samples_seen_with_nan (line 883) | def test_scaler_n_samples_seen_with_nan(with_mean, with_std, array_const...
  function _check_identity_scalers_attributes (line 898) | def _check_identity_scalers_attributes(scaler_1, scaler_2):
  function test_scaler_return_identity (line 905) | def test_scaler_return_identity():
  function test_scaler_int (line 949) | def test_scaler_int():
  function test_scaler_without_copy (line 1019) | def test_scaler_without_copy():
  function test_scale_sparse_with_mean_raise_exception (line 1040) | def test_scale_sparse_with_mean_raise_exception():
  function test_scale_input_finiteness_validation (line 1073) | def test_scale_input_finiteness_validation():
  function test_robust_scaler_error_sparse (line 1082) | def test_robust_scaler_error_sparse():
  function test_robust_scaler_attributes (line 1093) | def test_robust_scaler_attributes(X, with_centering, with_scaling):
  function test_robust_scaler_col_zero_sparse (line 1111) | def test_robust_scaler_col_zero_sparse():
  function test_robust_scaler_2d_arrays (line 1126) | def test_robust_scaler_2d_arrays():
  function test_robust_scaler_equivalence_dense_sparse (line 1141) | def test_robust_scaler_equivalence_dense_sparse(density, strictly_signed):
  function test_robust_scaler_transform_one_row_csr (line 1161) | def test_robust_scaler_transform_one_row_csr():
  function test_robust_scaler_iris (line 1175) | def test_robust_scaler_iris():
  function test_robust_scaler_iris_quantiles (line 1187) | def test_robust_scaler_iris_quantiles():
  function test_quantile_transform_iris (line 1199) | def test_quantile_transform_iris():
  function test_quantile_transform_check_error (line 1219) | def test_quantile_transform_check_error():
  function test_quantile_transform_sparse_ignore_zeros (line 1307) | def test_quantile_transform_sparse_ignore_zeros():
  function test_quantile_transform_dense_toy (line 1368) | def test_quantile_transform_dense_toy():
  function test_quantile_transform_subsampling (line 1400) | def test_quantile_transform_subsampling():
  function test_quantile_transform_sparse_toy (line 1447) | def test_quantile_transform_sparse_toy():
  function test_quantile_transform_axis1 (line 1485) | def test_quantile_transform_axis1():
  function test_quantile_transform_bounds (line 1493) | def test_quantile_transform_bounds():
  function test_quantile_transform_and_inverse (line 1530) | def test_quantile_transform_and_inverse():
  function test_quantile_transform_nan (line 1540) | def test_quantile_transform_nan():
  function test_quantile_transformer_sorted_quantiles (line 1553) | def test_quantile_transformer_sorted_quantiles(array_type):
  function test_robust_scaler_invalid_range (line 1572) | def test_robust_scaler_invalid_range():
  function test_scale_function_without_centering (line 1586) | def test_scale_function_without_centering():
  function test_robust_scale_axis1 (line 1622) | def test_robust_scale_axis1():
  function test_robust_scale_1d_array (line 1631) | def test_robust_scale_1d_array():
  function test_robust_scaler_zero_variance_features (line 1640) | def test_robust_scaler_zero_variance_features():
  function test_robust_scaler_unit_variance (line 1665) | def test_robust_scaler_unit_variance():
  function test_maxabs_scaler_zero_variance_features (line 1683) | def test_maxabs_scaler_zero_variance_features():
  function test_maxabs_scaler_large_negative_value (line 1729) | def test_maxabs_scaler_large_negative_value():
  function test_maxabs_scaler_transform_one_row_csr (line 1749) | def test_maxabs_scaler_transform_one_row_csr():
  function test_maxabs_scaler_1d (line 1761) | def test_maxabs_scaler_1d():
  function test_maxabs_scaler_partial_fit (line 1794) | def test_maxabs_scaler_partial_fit():
  function test_normalizer_l1 (line 1850) | def test_normalizer_l1():
  function test_normalizer_l2 (line 1899) | def test_normalizer_l2():
  function test_normalizer_max (line 1947) | def test_normalizer_max():
  function test_normalizer_max_sign (line 1996) | def test_normalizer_max_sign():
  function test_normalize (line 2016) | def test_normalize():
  function test_binarizer (line 2065) | def test_binarizer():
  function test_center_kernel (line 2121) | def test_center_kernel():
  function test_kernelcenterer_non_linear_kernel (line 2165) | def test_kernelcenterer_non_linear_kernel():
  function test_cv_pipeline_precomputed (line 2219) | def test_cv_pipeline_precomputed():
  function test_pairwise_deprecated (line 2245) | def test_pairwise_deprecated():
  function test_fit_transform (line 2252) | def test_fit_transform():
  function test_add_dummy_feature (line 2261) | def test_add_dummy_feature():
  function test_add_dummy_feature_coo (line 2267) | def test_add_dummy_feature_coo():
  function test_add_dummy_feature_csc (line 2274) | def test_add_dummy_feature_csc():
  function test_add_dummy_feature_csr (line 2281) | def test_add_dummy_feature_csr():
  function test_fit_cold_start (line 2288) | def test_fit_cold_start():
  function test_quantile_transform_valid_axis (line 2306) | def test_quantile_transform_valid_axis():
  function test_power_transformer_notfitted (line 2316) | def test_power_transformer_notfitted(method):
  function test_power_transformer_inverse (line 2328) | def test_power_transformer_inverse(method, standardize, X):
  function test_power_transformer_1d (line 2337) | def test_power_transformer_1d():
  function test_power_transformer_2d (line 2361) | def test_power_transformer_2d():
  function test_power_transformer_boxcox_strictly_positive_exception (line 2388) | def test_power_transformer_boxcox_strictly_positive_exception():
  function test_power_transformer_yeojohnson_any_input (line 2417) | def test_power_transformer_yeojohnson_any_input(X):
  function test_power_transformer_shape_exception (line 2423) | def test_power_transformer_shape_exception(method):
  function test_power_transformer_method_exception (line 2441) | def test_power_transformer_method_exception():
  function test_power_transformer_lambda_zero (line 2451) | def test_power_transformer_lambda_zero():
  function test_power_transformer_lambda_one (line 2461) | def test_power_transformer_lambda_one():
  function test_optimization_power_transformer (line 2481) | def test_optimization_power_transformer(method, lmbda):
  function test_yeo_johnson_darwin_example (line 2504) | def test_yeo_johnson_darwin_example():
  function test_power_transformer_nans (line 2514) | def test_power_transformer_nans(method):
  function test_power_transformer_fit_transform (line 2538) | def test_power_transformer_fit_transform(method, standardize):
  function test_power_transformer_copy_True (line 2550) | def test_power_transformer_copy_True(method, standardize):
  function test_power_transformer_copy_False (line 2578) | def test_power_transformer_copy_False(method, standardize):
  function test_standard_scaler_sparse_partial_fit_finite_variance (line 2613) | def test_standard_scaler_sparse_partial_fit_finite_variance(X_2):
  function test_minmax_scaler_clip (line 2623) | def test_minmax_scaler_clip(feature_range):
  function test_standard_scaler_raise_error_for_1d_input (line 2636) | def test_standard_scaler_raise_error_for_1d_input():
  function test_one_to_one_features (line 2659) | def test_one_to_one_features(Transformer):
  function test_one_to_one_features_pandas (line 2677) | def test_one_to_one_features_pandas(Transformer):

FILE: sklearn/preprocessing/tests/test_discretization.py
  function test_fit_transform (line 26) | def test_fit_transform(strategy, expected):
  function test_valid_n_bins (line 32) | def test_valid_n_bins():
  function test_invalid_n_bins (line 38) | def test_invalid_n_bins():
  function test_invalid_n_bins_array (line 56) | def test_invalid_n_bins_array():
  function test_fit_transform_n_bins_array (line 102) | def test_fit_transform_n_bins_array(strategy, expected):
  function test_same_min_max (line 116) | def test_same_min_max(strategy):
  function test_transform_1d_behavior (line 129) | def test_transform_1d_behavior():
  function test_numeric_stability (line 142) | def test_numeric_stability(i):
  function test_invalid_encode_option (line 152) | def test_invalid_encode_option():
  function test_encode_options (line 163) | def test_encode_options():
  function test_invalid_strategy_option (line 186) | def test_invalid_strategy_option():
  function test_nonuniform_strategies (line 205) | def test_nonuniform_strategies(
  function test_inverse_transform (line 259) | def test_inverse_transform(strategy, encode, expected_inv):
  function test_transform_outside_fit_range (line 267) | def test_transform_outside_fit_range(strategy):
  function test_overwrite (line 278) | def test_overwrite():
  function test_redundant_bins (line 295) | def test_redundant_bins(strategy, expected_bin_edges):
  function test_percentile_numeric_stability (line 304) | def test_percentile_numeric_stability():
  function test_consistent_dtype (line 320) | def test_consistent_dtype(in_dtype, out_dtype, encode):
  function test_32_equal_64 (line 345) | def test_32_equal_64(input_dtype, encode):
  function test_kbinsdiscretizer_subsample_default (line 366) | def test_kbinsdiscretizer_subsample_default(subsample):
  function test_kbinsdiscretizer_subsample_invalid_strategy (line 383) | def test_kbinsdiscretizer_subsample_invalid_strategy():
  function test_kbinsdiscretizer_subsample_invalid_type (line 392) | def test_kbinsdiscretizer_subsample_invalid_type():
  function test_kbinsdiscretizer_subsample_warn (line 407) | def test_kbinsdiscretizer_subsample_warn():
  function test_kbinsdiscretizer_subsample_values (line 417) | def test_kbinsdiscretizer_subsample_values(subsample):

FILE: sklearn/preprocessing/tests/test_encoders.py
  function test_one_hot_encoder_sparse_dense (line 19) | def test_one_hot_encoder_sparse_dense():
  function test_one_hot_encoder_handle_unknown (line 42) | def test_one_hot_encoder_handle_unknown():
  function test_one_hot_encoder_not_fitted (line 70) | def test_one_hot_encoder_not_fitted():
  function test_one_hot_encoder_handle_unknown_strings (line 82) | def test_one_hot_encoder_handle_unknown_strings():
  function test_one_hot_encoder_dtype (line 102) | def test_one_hot_encoder_dtype(input_dtype, output_dtype):
  function test_one_hot_encoder_dtype_pandas (line 116) | def test_one_hot_encoder_dtype_pandas(output_dtype):
  function test_one_hot_encoder_feature_names (line 134) | def test_one_hot_encoder_feature_names(get_names):
  function test_one_hot_encoder_feature_names_unicode (line 201) | def test_one_hot_encoder_feature_names_unicode(get_names):
  function test_one_hot_encoder_set_params (line 211) | def test_one_hot_encoder_set_params():
  function check_categorical_onehot (line 223) | def check_categorical_onehot(X):
  function test_one_hot_encoder (line 259) | def test_one_hot_encoder(X):
  function test_one_hot_encoder_inverse (line 272) | def test_one_hot_encoder_inverse(sparse_, drop):
  function test_one_hot_encoder_inverse_transform_raise_error_with_unknown (line 328) | def test_one_hot_encoder_inverse_transform_raise_error_with_unknown(
  function test_one_hot_encoder_inverse_if_binary (line 349) | def test_one_hot_encoder_inverse_if_binary():
  function test_one_hot_encoder_drop_reset (line 362) | def test_one_hot_encoder_drop_reset(get_names, drop, reset_drop):
  function test_X_is_not_1D (line 376) | def test_X_is_not_1D(X, method):
  function test_X_is_not_1D_pandas (line 385) | def test_X_is_not_1D_pandas(method):
  function test_one_hot_encoder_categories (line 428) | def test_one_hot_encoder_categories(X, cat_exp, cat_dtype):
  function test_one_hot_encoder_specified_categories (line 501) | def test_one_hot_encoder_specified_categories(X, X2, cats, cat_dtype):
  function test_one_hot_encoder_unsorted_categories (line 521) | def test_one_hot_encoder_unsorted_categories():
  function test_one_hot_encoder_specified_categories_mixed_columns (line 545) | def test_one_hot_encoder_specified_categories_mixed_columns():
  function test_one_hot_encoder_pandas (line 558) | def test_one_hot_encoder_pandas():
  function test_one_hot_encoder_feature_names_drop (line 579) | def test_one_hot_encoder_feature_names_drop(get_names, drop, expected_na...
  function test_one_hot_encoder_drop_equals_if_binary (line 590) | def test_one_hot_encoder_drop_equals_if_binary():
  function test_ordinal_encoder (line 623) | def test_ordinal_encoder(X):
  function test_ordinal_encoder_specified_categories (line 655) | def test_ordinal_encoder_specified_categories(X, X2, cats, cat_dtype):
  function test_ordinal_encoder_inverse (line 672) | def test_ordinal_encoder_inverse():
  function test_ordinal_encoder_handle_unknowns_string (line 686) | def test_ordinal_encoder_handle_unknowns_string():
  function test_ordinal_encoder_handle_unknowns_numeric (line 702) | def test_ordinal_encoder_handle_unknowns_numeric(dtype):
  function test_ordinal_encoder_handle_unknowns_raise (line 752) | def test_ordinal_encoder_handle_unknowns_raise(params, err_type, err_msg):
  function test_ordinal_encoder_handle_unknowns_nan (line 761) | def test_ordinal_encoder_handle_unknowns_nan():
  function test_ordinal_encoder_handle_unknowns_nan_non_float_dtype (line 772) | def test_ordinal_encoder_handle_unknowns_nan_non_float_dtype():
  function test_ordinal_encoder_raise_categories_shape (line 784) | def test_ordinal_encoder_raise_categories_shape():
  function test_encoder_dtypes (line 795) | def test_encoder_dtypes():
  function test_encoder_dtypes_pandas (line 822) | def test_encoder_dtypes_pandas():
  function test_one_hot_encoder_warning (line 844) | def test_one_hot_encoder_warning():
  function test_one_hot_encoder_drop_manual (line 851) | def test_one_hot_encoder_drop_manual(missing_value):
  function test_one_hot_encoder_invalid_params (line 907) | def test_one_hot_encoder_invalid_params(X_fit, params, err_msg):
  function test_invalid_drop_length (line 914) | def test_invalid_drop_length(drop):
  function test_categories (line 923) | def test_categories(density, drop):
  function test_encoders_has_categorical_tags (line 942) | def test_encoders_has_categorical_tags(Encoder):
  function test_one_hot_encoder_get_feature_names_deprecated (line 947) | def test_one_hot_encoder_get_feature_names_deprecated():
  function test_encoders_string_categories (line 961) | def test_encoders_string_categories(input_dtype, category_dtype, array_t...
  function test_ohe_missing_values_get_feature_names (line 992) | def test_ohe_missing_values_get_feature_names(get_names, missing_value):
  function test_ohe_missing_value_support_pandas (line 1000) | def test_ohe_missing_value_support_pandas():
  function test_ohe_missing_value_support_pandas_categorical (line 1024) | def test_ohe_missing_value_support_pandas_categorical(pd_nan_type):
  function test_ohe_drop_first_handle_unknown_ignore_warns (line 1058) | def test_ohe_drop_first_handle_unknown_ignore_warns():
  function test_ohe_drop_if_binary_handle_unknown_ignore_warns (line 1092) | def test_ohe_drop_if_binary_handle_unknown_ignore_warns():
  function test_ohe_drop_first_explicit_categories (line 1126) | def test_ohe_drop_first_explicit_categories():
  function test_ordinal_encoder_passthrough_missing_values_float_errors_dtype (line 1152) | def test_ordinal_encoder_passthrough_missing_values_float_errors_dtype():
  function test_ordinal_encoder_passthrough_missing_values_float (line 1167) | def test_ordinal_encoder_passthrough_missing_values_float():
  function test_ordinal_encoder_missing_value_support_pandas_categorical (line 1184) | def test_ordinal_encoder_missing_value_support_pandas_categorical(pd_nan...
  function test_ordinal_encoder_specified_categories_missing_passthrough (line 1251) | def test_ordinal_encoder_specified_categories_missing_passthrough(
  function test_ordinal_encoder_handle_missing_and_unknown (line 1294) | def test_ordinal_encoder_handle_missing_and_unknown(X, expected_X_trans,...
  function test_ordinal_encoder_sparse (line 1305) | def test_ordinal_encoder_sparse():
  function test_ordinal_encoder_fit_with_unseen_category (line 1327) | def test_ordinal_encoder_fit_with_unseen_category():
  function test_ordinal_encoder_handle_unknown_string_dtypes (line 1360) | def test_ordinal_encoder_handle_unknown_string_dtypes(X_train, X_test):
  function test_ordinal_encoder_python_integer (line 1372) | def test_ordinal_encoder_python_integer():

FILE: sklearn/preprocessing/tests/test_function_transformer.py
  function _make_func (line 9) | def _make_func(args_store, kwargs_store, func=lambda X, *a, **k: X):
  function test_delegate_to_func (line 19) | def test_delegate_to_func():
  function test_np_log (line 61) | def test_np_log():
  function test_kw_arg (line 71) | def test_kw_arg():
  function test_kw_arg_update (line 80) | def test_kw_arg_update():
  function test_kw_arg_reset (line 91) | def test_kw_arg_reset():
  function test_inverse_transform (line 102) | def test_inverse_transform():
  function test_check_inverse (line 117) | def test_check_inverse():
  function test_function_transformer_frame (line 171) | def test_function_transformer_frame():
  function test_function_transformer_validate_inverse (line 179) | def test_function_transformer_validate_inverse():

FILE: sklearn/preprocessing/tests/test_label.py
  function toarray (line 31) | def toarray(a):
  function test_label_binarizer (line 37) | def test_label_binarizer():
  function test_label_binarizer_unseen_labels (line 78) | def test_label_binarizer_unseen_labels():
  function test_label_binarizer_set_label_encoding (line 92) | def test_label_binarizer_set_label_encoding():
  function test_label_binarizer_errors (line 121) | def test_label_binarizer_errors():
  function test_label_encoder (line 220) | def test_label_encoder(values, classes, unknown):
  function test_label_encoder_negative_ints (line 236) | def test_label_encoder_negative_ints():
  function test_label_encoder_str_bad_shape (line 249) | def test_label_encoder_str_bad_shape(dtype):
  function test_label_encoder_errors (line 257) | def test_label_encoder_errors():
  function test_label_encoder_empty_array (line 289) | def test_label_encoder_empty_array(values):
  function test_sparse_output_multilabel_binarizer (line 300) | def test_sparse_output_multilabel_binarizer():
  function test_multilabel_binarizer (line 340) | def test_multilabel_binarizer():
  function test_multilabel_binarizer_empty_sample (line 365) | def test_multilabel_binarizer_empty_sample():
  function test_multilabel_binarizer_unknown_class (line 372) | def test_multilabel_binarizer_unknown_class():
  function test_multilabel_binarizer_given_classes (line 387) | def test_multilabel_binarizer_given_classes():
  function test_multilabel_binarizer_multiple_calls (line 422) | def test_multilabel_binarizer_multiple_calls():
  function test_multilabel_binarizer_same_length_sequence (line 436) | def test_multilabel_binarizer_same_length_sequence():
  function test_multilabel_binarizer_non_integer_labels (line 451) | def test_multilabel_binarizer_non_integer_labels():
  function test_multilabel_binarizer_non_unique (line 480) | def test_multilabel_binarizer_non_unique():
  function test_multilabel_binarizer_inverse_validation (line 487) | def test_multilabel_binarizer_inverse_validation():
  function test_label_binarize_with_class_order (line 506) | def test_label_binarize_with_class_order():
  function check_binarized_results (line 521) | def check_binarized_results(y, classes, pos_label, neg_label, expected):
  function test_label_binarize_binary (line 572) | def test_label_binarize_binary():
  function test_label_binarize_multiclass (line 591) | def test_label_binarize_multiclass():
  function test_label_binarize_multilabel (line 606) | def test_label_binarize_multilabel():
  function test_invalid_input_label_binarize (line 632) | def test_invalid_input_label_binarize():
  function test_inverse_binarize_multiclass (line 641) | def test_inverse_binarize_multiclass():

FILE: sklearn/preprocessing/tests/test_polynomial.py
  function test_polynomial_and_spline_array_order (line 20) | def test_polynomial_and_spline_array_order(est):
  function test_spline_transformer_input_validation (line 85) | def test_spline_transformer_input_validation(params, err_msg):
  function test_spline_transformer_manual_knot_input (line 93) | def test_spline_transformer_manual_knot_input():
  function test_spline_transformer_integer_knots (line 107) | def test_spline_transformer_integer_knots(extrapolation):
  function test_spline_transformer_feature_names (line 119) | def test_spline_transformer_feature_names(get_names):
  function test_spline_transformer_unity_decomposition (line 161) | def test_spline_transformer_unity_decomposition(degree, n_knots, knots, ...
  function test_spline_transformer_linear_regression (line 188) | def test_spline_transformer_linear_regression(bias, intercept):
  function test_spline_transformer_get_base_knot_positions (line 230) | def test_spline_transformer_get_base_knot_positions(
  function test_spline_transformer_periodicity_of_extrapolation (line 254) | def test_spline_transformer_periodicity_of_extrapolation(knots, n_knots,...
  function test_spline_transformer_periodic_linear_regression (line 268) | def test_spline_transformer_periodic_linear_regression(bias, intercept):
  function test_spline_transformer_periodic_spline_backport (line 302) | def test_spline_transformer_periodic_spline_backport():
  function test_spline_transformer_periodic_splines_periodicity (line 320) | def test_spline_transformer_periodic_splines_periodicity():
  function test_spline_transformer_periodic_splines_smoothness (line 345) | def test_spline_transformer_periodic_splines_smoothness(degree):
  function test_spline_transformer_extrapolation (line 385) | def test_spline_transformer_extrapolation(bias, intercept, degree):
  function test_spline_transformer_kbindiscretizer (line 438) | def test_spline_transformer_kbindiscretizer():
  function test_spline_transformer_n_features_out (line 461) | def test_spline_transformer_n_features_out(n_knots, include_bias, degree):
  function test_polynomial_features_input_validation (line 482) | def test_polynomial_features_input_validation(params, err_msg):
  function single_feature_degree3 (line 491) | def single_feature_degree3():
  function test_polynomial_features_one_feature (line 514) | def test_polynomial_features_one_feature(
  function two_features_degree3 (line 538) | def two_features_degree3():
  function test_polynomial_features_two_features (line 588) | def test_polynomial_features_two_features(
  function test_polynomial_feature_names (line 614) | def test_polynomial_feature_names(get_names):
  function test_polynomial_features_csc_X (line 703) | def test_polynomial_features_csc_X(deg, include_bias, interaction_only, ...
  function test_polynomial_features_csr_X (line 730) | def test_polynomial_features_csr_X(deg, include_bias, interaction_only, ...
  function test_num_combinations (line 752) | def test_num_combinations(
  function test_polynomial_features_csr_X_floats (line 790) | def test_polynomial_features_csr_X_floats(deg, include_bias, interaction...
  function test_polynomial_features_csr_X_zero_row (line 822) | def test_polynomial_features_csr_X_zero_row(zero_row_index, deg, interac...
  function test_polynomial_features_csr_X_degree_4 (line 842) | def test_polynomial_features_csr_X_degree_4(include_bias, interaction_on...
  function test_polynomial_features_csr_X_dim_edges (line 872) | def test_polynomial_features_csr_X_dim_edges(deg, dim, interaction_only):
  function test_polynomial_features_deprecated_n_input_features (line 885) | def test_polynomial_features_deprecated_n_input_features():
  function test_get_feature_names_deprecated (line 900) | def test_get_feature_names_deprecated(Transformer):

FILE: sklearn/random_projection.py
  function johnson_lindenstrauss_min_dim (line 53) | def johnson_lindenstrauss_min_dim(n_samples, *, eps=0.1):
  function _check_density (line 136) | def _check_density(density, n_features):
  function _check_input_size (line 146) | def _check_input_size(n_components, n_features):
  function _gaussian_random_matrix (line 156) | def _gaussian_random_matrix(n_components, n_features, random_state=None):
  function _sparse_random_matrix (line 196) | def _sparse_random_matrix(n_components, n_features, density="auto", rand...
  class BaseRandomProjection (line 294) | class BaseRandomProjection(
    method __init__ (line 304) | def __init__(
    method _make_random_matrix (line 313) | def _make_random_matrix(self, n_components, n_features):
    method fit (line 332) | def fit(self, X, y=None):
    method transform (line 400) | def transform(self, X):
    method _n_features_out (line 427) | def _n_features_out(self):
  class GaussianRandomProjection (line 435) | class GaussianRandomProjection(BaseRandomProjection):
    method __init__ (line 508) | def __init__(self, n_components="auto", *, eps=0.1, random_state=None):
    method _make_random_matrix (line 516) | def _make_random_matrix(self, n_components, n_features):
  class SparseRandomProjection (line 540) | class SparseRandomProjection(BaseRandomProjection):
    method __init__ (line 661) | def __init__(
    method _make_random_matrix (line 679) | def _make_random_matrix(self, n_components, n_features):

FILE: sklearn/semi_supervised/_label_propagation.py
  class BaseLabelPropagation (line 74) | class BaseLabelPropagation(ClassifierMixin, BaseEstimator, metaclass=ABC...
    method __init__ (line 108) | def __init__(
    method _get_kernel (line 133) | def _get_kernel(self, X, y=None):
    method _build_graph (line 164) | def _build_graph(self):
    method predict (line 169) | def predict(self, X):
    method predict_proba (line 185) | def predict_proba(self, X):
    method fit (line 225) | def fit(self, X, y):
  class LabelPropagation (line 332) | class LabelPropagation(BaseLabelPropagation):
    method __init__ (line 420) | def __init__(
    method _build_graph (line 440) | def _build_graph(self):
    method fit (line 456) | def fit(self, X, y):
  class LabelSpreading (line 478) | class LabelSpreading(BaseLabelPropagation):
    method __init__ (line 576) | def __init__(
    method _build_graph (line 599) | def _build_graph(self):

FILE: sklearn/semi_supervised/_self_training.py
  function _validate_estimator (line 17) | def _validate_estimator(estimator):
  class SelfTrainingClassifier (line 24) | class SelfTrainingClassifier(MetaEstimatorMixin, BaseEstimator):
    method __init__ (line 143) | def __init__(
    method fit (line 159) | def fit(self, X, y):
    method predict (line 288) | def predict(self, X):
    method predict_proba (line 310) | def predict_proba(self, X):
    method decision_function (line 333) | def decision_function(self, X):
    method predict_log_proba (line 356) | def predict_log_proba(self, X):
    method score (line 379) | def score(self, X, y):

FILE: sklearn/semi_supervised/tests/test_label_propagation.py
  function test_fit_transduction (line 32) | def test_fit_transduction():
  function test_distribution (line 40) | def test_distribution():
  function test_predict (line 56) | def test_predict():
  function test_predict_proba (line 64) | def test_predict_proba():
  function test_label_spreading_closed_form (line 74) | def test_label_spreading_closed_form():
  function test_label_propagation_closed_form (line 92) | def test_label_propagation_closed_form():
  function test_valid_alpha (line 118) | def test_valid_alpha():
  function test_convergence_speed (line 126) | def test_convergence_speed():
  function test_convergence_warning (line 138) | def test_convergence_warning():
  function test_label_propagation_non_zero_normalizer (line 168) | def test_label_propagation_non_zero_normalizer(LabelPropagationCls):
  function test_predict_sparse_callable_kernel (line 181) | def test_predict_sparse_callable_kernel():

FILE: sklearn/semi_supervised/tests/test_self_training.py
  function test_missing_predict_proba (line 37) | def test_missing_predict_proba():
  function test_none_classifier (line 46) | def test_none_classifier():
  function test_invalid_params (line 53) | def test_invalid_params(max_iter, threshold):
  function test_invalid_params_selection_crit (line 66) | def test_invalid_params_selection_crit():
  function test_warns_k_best (line 73) | def test_warns_k_best():
  function test_classification (line 86) | def test_classification(base_estimator, selection_crit):
  function test_k_best (line 127) | def test_k_best():
  function test_sanity_classification (line 150) | def test_sanity_classification():
  function test_none_iter (line 165) | def test_none_iter():
  function test_zero_iterations (line 180) | def test_zero_iterations(base_estimator, y):
  function test_prefitted_throws_error (line 196) | def test_prefitted_throws_error():
  function test_labeled_iter (line 210) | def test_labeled_iter(max_iter):
  function test_no_unlabeled (line 223) | def test_no_unlabeled():
  function test_early_stopping (line 238) | def test_early_stopping():
  function test_strings_dtype (line 250) | def test_strings_dtype():
  function test_verbose (line 262) | def test_verbose(capsys, verbose):
  function test_verbose_k_best (line 274) | def test_verbose_k_best(capsys):
  function test_k_best_selects_best (line 299) | def test_k_best_selects_best():
  function test_base_estimator_meta_estimator (line 319) | def test_base_estimator_meta_estimator():

FILE: sklearn/setup.py
  function configuration (line 7) | def configuration(parent_package="", top_path=None):

FILE: sklearn/svm/_base.py
  function _one_vs_one_coef (line 33) | def _one_vs_one_coef(dual_coef, n_support, support_vectors):
  class BaseLibSVM (line 65) | class BaseLibSVM(BaseEstimator, metaclass=ABCMeta):
    method __init__ (line 79) | def __init__(
    method _more_tags (line 119) | def _more_tags(self):
    method _pairwise (line 130) | def _pairwise(self):
    method fit (line 134) | def fit(self, X, y, sample_weight=None):
    method _validate_targets (line 279) | def _validate_targets(self, y):
    method _warn_from_fit_status (line 289) | def _warn_from_fit_status(self):
    method _dense_fit (line 300) | def _dense_fit(self, X, y, sample_weight, solver_type, kernel, random_...
    method _sparse_fit (line 346) | def _sparse_fit(self, X, y, sample_weight, solver_type, kernel, random...
    method predict (line 406) | def predict(self, X):
    method _dense_predict (line 426) | def _dense_predict(self, X):
    method _sparse_predict (line 460) | def _sparse_predict(self, X):
    method _compute_kernel (line 496) | def _compute_kernel(self, X):
    method _decision_function (line 507) | def _decision_function(self, X):
    method _dense_decision_function (line 537) | def _dense_decision_function(self, X):
    method _sparse_decision_function (line 561) | def _sparse_decision_function(self, X):
    method _validate_for_predict (line 596) | def _validate_for_predict(self, X):
    method coef_ (line 637) | def coef_(self):
    method _get_coef (line 659) | def _get_coef(self):
    method n_support_ (line 663) | def n_support_(self):
  class BaseSVC (line 679) | class BaseSVC(ClassifierMixin, BaseLibSVM, metaclass=ABCMeta):
    method __init__ (line 683) | def __init__(
    method _validate_targets (line 722) | def _validate_targets(self, y):
    method decision_function (line 737) | def decision_function(self, X):
    method predict (line 769) | def predict(self, X):
    method _check_proba (line 806) | def _check_proba(self):
    method predict_proba (line 816) | def predict_proba(self, X):
    method predict_log_proba (line 853) | def predict_log_proba(self, X):
    method _dense_predict_proba (line 882) | def _dense_predict_proba(self, X):
    method _sparse_predict_proba (line 909) | def _sparse_predict_proba(self, X):
    method _get_coef (line 944) | def _get_coef(self):
    method probA_ (line 961) | def probA_(self):
    method probB_ (line 971) | def probB_(self):
  function _get_liblinear_solver_type (line 981) | def _get_liblinear_solver_type(multi_class, penalty, loss, dual):
  function _fit_liblinear (line 1038) | def _fit_liblinear(

FILE: sklearn/svm/_bounds.py
  function l1_min_c (line 12) | def l1_min_c(X, y, *, loss="squared_hinge", fit_intercept=True, intercep...

FILE: sklearn/svm/_classes.py
  class LinearSVC (line 11) | class LinearSVC(LinearClassifierMixin, SparseCoefMixin, BaseEstimator):
    method __init__ (line 190) | def __init__(
    method fit (line 219) | def fit(self, X, y, sample_weight=None):
    method _more_tags (line 283) | def _more_tags(self):
  class LinearSVR (line 293) | class LinearSVR(RegressorMixin, LinearModel):
    method __init__ (line 423) | def __init__(
    method fit (line 448) | def fit(self, X, y, sample_weight=None):
    method _more_tags (line 505) | def _more_tags(self):
  class SVC (line 515) | class SVC(BaseSVC):
    method __init__ (line 732) | def __init__(
    method _more_tags (line 771) | def _more_tags(self):
  class NuSVC (line 781) | class NuSVC(BaseSVC):
    method __init__ (line 987) | def __init__(
    method _more_tags (line 1026) | def _more_tags(self):
  class SVR (line 1040) | class SVR(RegressorMixin, BaseLibSVM):
    method __init__ (line 1190) | def __init__(
    method _more_tags (line 1224) | def _more_tags(self):
  class NuSVR (line 1234) | class NuSVR(RegressorMixin, BaseLibSVM):
    method __init__ (line 1378) | def __init__(
    method _more_tags (line 1412) | def _more_tags(self):
  class OneClassSVM (line 1422) | class OneClassSVM(OutlierMixin, BaseLibSVM):
    method __init__ (line 1556) | def __init__(
    method fit (line 1589) | def fit(self, X, y=None, sample_weight=None, **params):
    method decision_function (line 1635) | def decision_function(self, X):
    method score_samples (line 1653) | def score_samples(self, X):
    method predict (line 1668) | def predict(self, X):
    method _more_tags (line 1688) | def _more_tags(self):

FILE: sklearn/svm/setup.py
  function configuration (line 6) | def configuration(parent_package="", top_path=None):

FILE: sklearn/svm/src/liblinear/_cython_blas_helpers.h
  type BlasFunctions (line 9) | typedef struct BlasFunctions{

FILE: sklearn/svm/src/liblinear/liblinear_helper.c
  type feature_node (line 18) | struct feature_node
  type feature_node (line 23) | struct feature_node
  type feature_node (line 25) | struct feature_node
  type feature_node (line 28) | struct feature_node
  type feature_node (line 33) | struct feature_node
  type feature_node (line 79) | struct feature_node
  type feature_node (line 85) | struct feature_node
  type feature_node (line 87) | struct feature_node
  type feature_node (line 90) | struct feature_node
  type feature_node (line 95) | struct feature_node
  type problem (line 127) | struct problem
  type problem (line 131) | struct problem
  type problem (line 133) | struct problem
  type problem (line 151) | struct problem
  type problem (line 155) | struct problem
  type problem (line 156) | struct problem
  type parameter (line 176) | struct parameter
  type parameter (line 181) | struct parameter
  type parameter (line 181) | struct parameter
  function copy_w (line 197) | void copy_w(void *data, struct model *model, int len)
  function get_bias (line 202) | double get_bias(struct model *model)
  function free_problem (line 207) | void free_problem(struct problem *problem)
  function free_parameter (line 214) | void free_parameter(struct parameter *param)
  function print_null (line 220) | static void print_null(const char *s) {}
  function print_string_stdout (line 222) | static void print_string_stdout(const char *s)
  function set_verbosity (line 229) | void set_verbosity(int verbosity_flag){

FILE: sklearn/svm/src/liblinear/linear.cpp
  function swap (line 47) | static inline void swap(T& x, T& y) { T t=x; x=y; y=t; }
  function T (line 49) | static inline T min(T x,T y) { return (x<y)?x:y; }
  function T (line 52) | static inline T max(T x,T y) { return (x>y)?x:y; }
  function clone (line 54) | static inline void clone(T*& dst, S* src, int n)
  function print_string_stdout (line 62) | static void print_string_stdout(const char *s)
  function info (line 71) | static void info(const char *fmt,...)
  function info (line 81) | static void info(const char *fmt,...) {}
  class l2r_lr_fun (line 84) | class l2r_lr_fun: public function
  class l2r_l2_svc_fun (line 228) | class l2r_l2_svc_fun: public function
  class l2r_l2_svr_fun (line 392) | class l2r_l2_svr_fun: public l2r_l2_svc_fun
  class Solver_MCSVM_CS (line 493) | class Solver_MCSVM_CS
  function compare_double (line 532) | int compare_double(const void *a, const void *b)
  function solve_l2r_l1l2_svc (line 819) | static int solve_l2r_l1l2_svc(
  function solve_l2r_l1l2_svr (line 1051) | static int solve_l2r_l1l2_svr(
  function solve_l2r_lr_dual (line 1289) | int solve_l2r_lr_dual(const problem *prob, double *w, double eps, double...
  function solve_l1r_l2_svc (line 1467) | static int solve_l1r_l2_svc(
  function solve_l1r_lr (line 1761) | static int solve_l1r_lr(
  function transpose (line 2133) | static void transpose(const problem *prob, feature_node **x_space_ret, p...
  function group_classes (line 2194) | static void group_classes(const problem *prob, int *nr_class_ret, int **...
  function train_one (line 2303) | static int train_one(const problem *prob, const parameter *param, double...
  function remove_zero_weight (line 2421) | static void remove_zero_weight(problem *newprob, const problem *prob)
  function model (line 2447) | model* train(const problem *prob, const parameter *param, BlasFunctions ...
  function cross_validation (line 2593) | void cross_validation(const problem *prob, const parameter *param, int n...
  function predict_values (line 2651) | double predict_values(const struct model *model_, const struct feature_n...
  function predict (line 2698) | double predict(const model *model_, const feature_node *x)
  function predict_probability (line 2706) | double predict_probability(const struct model *model_, const struct feat...
  function save_model (line 2748) | int save_model(const char *model_file_name, const struct model *model_)
  type model (line 2803) | struct model
  function get_nr_feature (line 2915) | int get_nr_feature(const model *model_)
  function get_nr_class (line 2920) | int get_nr_class(const model *model_)
  function get_labels (line 2925) | void get_labels(const model *model_, int* label)
  function get_n_iter (line 2932) | void get_n_iter(const model *model_, int* n_iter)
  function get_w_value (line 2946) | static inline double get_w_value(const struct model *model_, int idx, in...
  function get_decfun_coef (line 2975) | double get_decfun_coef(const struct model *model_, int feat_idx, int lab...
  function get_decfun_bias (line 2982) | double get_decfun_bias(const struct model *model_, int label_idx)
  function free_model_content (line 2993) | void free_model_content(struct model *model_ptr)
  function free_and_destroy_model (line 3003) | void free_and_destroy_model(struct model **model_ptr_ptr)
  function destroy_param (line 3013) | void destroy_param(parameter* param)
  function check_probability_model (line 3049) | int check_probability_model(const struct model *model_)
  function check_regression_model (line 3057) | int check_regression_model(const struct model *model_)
  function set_print_string_function (line 3064) | void set_print_string_function(void (*print_func)(const char*))

FILE: sklearn/svm/src/liblinear/linear.h
  type feature_node (line 10) | struct feature_node
  type problem (line 16) | struct problem
  type parameter (line 27) | struct parameter
  type model (line 41) | struct model
  type model (line 54) | struct model
  type problem (line 54) | struct problem
  type parameter (line 54) | struct parameter
  type problem (line 55) | struct problem
  type parameter (line 55) | struct parameter
  type model (line 57) | struct model
  type feature_node (line 57) | struct feature_node
  type model (line 58) | struct model
  type feature_node (line 58) | struct feature_node
  type model (line 59) | struct model
  type feature_node (line 59) | struct feature_node
  type model (line 61) | struct model
  type model (line 62) | struct model
  type model (line 64) | struct model
  type model (line 65) | struct model
  type model (line 66) | struct model
  type model (line 67) | struct model
  type model (line 69) | struct model
  type model (line 70) | struct model
  type model (line 73) | struct model
  type model (line 74) | struct model
  type parameter (line 75) | struct parameter
  type problem (line 77) | struct problem
  type parameter (line 77) | struct parameter
  type model (line 78) | struct model
  type model (line 79) | struct model

FILE: sklearn/svm/src/liblinear/tron.cpp
  function T (line 8) | static inline T min(T x,T y) { return (x<y)?x:y; }
  function T (line 12) | static inline T max(T x,T y) { return (x>y)?x:y; }
  function default_print (line 15) | static void default_print(const char *buf)

FILE: sklearn/svm/src/liblinear/tron.h
  function class (line 6) | class function
  function class (line 17) | class TRON

FILE: sklearn/svm/src/libsvm/_svm_cython_blas_helpers.h
  type BlasFunctions (line 5) | typedef struct BlasFunctions{

FILE: sklearn/svm/src/libsvm/libsvm_helper.c
  type svm_node (line 33) | struct svm_node
  type svm_node (line 35) | struct svm_node
  type svm_node (line 40) | struct svm_node
  function set_parameter (line 58) | void set_parameter(struct svm_parameter *param, int svm_type, int kernel...
  function set_problem (line 85) | void set_problem(struct svm_problem *problem, char *X, char *Y, char *sa...
  type svm_model (line 107) | struct svm_model
  type svm_parameter (line 107) | struct svm_parameter
  type svm_model (line 114) | struct svm_model
  type svm_model (line 120) | struct svm_model
  type svm_node (line 136) | struct svm_node
  function npy_intp (line 207) | npy_intp get_l(struct svm_model *model)
  function npy_intp (line 216) | npy_intp get_nr(struct svm_model *model)
  function copy_sv_coef (line 226) | void copy_sv_coef(char *data, struct svm_model *model)
  function copy_intercept (line 236) | void copy_intercept(char *data, struct svm_model *model, npy_intp *dims)
  function copy_SV (line 254) | void copy_SV(char *data, struct svm_model *model, npy_intp *dims)
  function copy_support (line 265) | void copy_support (char *data, struct svm_model *model)
  function copy_nSV (line 274) | void copy_nSV(char *data, struct svm_model *model)
  function copy_probA (line 280) | void copy_probA(char *data, struct svm_model *model, npy_intp * dims)
  function copy_probB (line 285) | void copy_probB(char *data, struct svm_model *model, npy_intp * dims)
  function copy_predict (line 295) | int copy_predict(char *predict, struct svm_model *model, npy_intp *predi...
  function copy_predict_values (line 314) | int copy_predict_values(char *predict, struct svm_model *model,
  function copy_predict_proba (line 334) | int copy_predict_proba(char *predict, struct svm_model *model, npy_intp ...
  function free_model (line 360) | int free_model(struct svm_model *model)
  function free_param (line 380) | int free_param(struct svm_parameter *param)
  function print_null (line 389) | static void print_null(const char *s) {}
  function print_string_stdout (line 391) | static void print_string_stdout(const char *s)
  function set_verbosity (line 398) | void set_verbosity(int verbosity_flag){

FILE: sklearn/svm/src/libsvm/libsvm_sparse_helper.c
  type svm_csr_node (line 9) | struct svm_csr_node
  type svm_csr_node (line 11) | struct svm_csr_node
  type svm_csr_node (line 13) | struct svm_csr_node
  type svm_csr_node (line 20) | struct svm_csr_node
  type svm_parameter (line 44) | struct svm_parameter
  type svm_parameter (line 49) | struct svm_parameter
  type svm_parameter (line 50) | struct svm_parameter
  type svm_csr_problem (line 79) | struct svm_csr_problem
  type svm_csr_problem (line 83) | struct svm_csr_problem
  type svm_csr_problem (line 84) | struct svm_csr_problem
  type svm_csr_model (line 101) | struct svm_csr_model
  type svm_parameter (line 101) | struct svm_parameter
  type svm_csr_model (line 108) | struct svm_csr_model
  type svm_csr_model (line 114) | struct svm_csr_model
  function csr_copy_SV (line 206) | int csr_copy_SV (char *data, npy_intp *n_indices,
  function npy_intp (line 230) | npy_intp get_nonzero_SV (struct svm_csr_model *model) {
  function csr_copy_predict (line 247) | int csr_copy_predict (npy_intp *data_size, char *data, npy_intp *index_s...
  function csr_copy_predict_values (line 268) | int csr_copy_predict_values (npy_intp *data_size, char *data, npy_intp *...
  function csr_copy_predict_proba (line 290) | int csr_copy_predict_proba (npy_intp *data_size, char *data, npy_intp *i...
  function npy_intp (line 313) | npy_intp get_nr(struct svm_csr_model *model)
  function copy_intercept (line 318) | void copy_intercept(char *data, struct svm_csr_model *model, npy_intp *d...
  function copy_support (line 331) | void copy_support (char *data, struct svm_csr_model *model)
  function copy_sv_coef (line 341) | void copy_sv_coef(char *data, struct svm_csr_model *model)
  function npy_intp (line 354) | npy_intp get_l(struct svm_csr_model *model)
  function copy_nSV (line 359) | void copy_nSV(char *data, struct svm_csr_model *model)
  function copy_label (line 369) | void copy_label(char *data, struct svm_csr_model *model)
  function copy_probA (line 375) | void copy_probA(char *data, struct svm_csr_model *model, npy_intp * dims)
  function copy_probB (line 380) | void copy_probB(char *data, struct svm_csr_model *model, npy_intp * dims)
  function free_problem (line 391) | int free_problem(struct svm_csr_problem *problem)
  function free_model (line 402) | int free_model(struct svm_csr_model *model)
  function free_param (line 418) | int free_param(struct svm_parameter *param)
  function free_model_SV (line 426) | int free_model_SV(struct svm_csr_model *model)
  function print_null (line 438) | static void print_null(const char *s) {}
  function print_string_stdout (line 440) | static void print_string_stdout(const char *s)
  function set_verbosity (line 447) | void set_verbosity(int verbosity_flag){

FILE: sklearn/svm/src/libsvm/svm.cpp
  function T (line 78) | static inline T min(T x,T y) { return (x<y)?x:y; }
  function T (line 81) | static inline T max(T x,T y) { return (x>y)?x:y; }
  function swap (line 83) | static inline void swap(T& x, T& y) { T t=x; x=y; y=t; }
  function clone (line 84) | static inline void clone(T*& dst, S* src, int n)
  function powi (line 89) | static inline double powi(double base, int times)
  function print_string_stdout (line 104) | static void print_string_stdout(const char *s)
  function info (line 111) | static void info(const char *fmt,...)
  type svm_csr (line 146) | namespace svm_csr {
    class Cache (line 156) | class Cache
      type head_t (line 170) | struct head_t
    class QMatrix (line 283) | class QMatrix {
    class Kernel (line 291) | class Kernel: public QMatrix {
      method swap_index (line 304) | virtual void swap_index(int i, int j) const	// no so const...
      method kernel_linear (line 334) | double kernel_linear(int i, int j) const
      method kernel_poly (line 338) | double kernel_poly(int i, int j) const
      method kernel_rbf (line 342) | double kernel_rbf(int i, int j) const
      method kernel_sigmoid (line 346) | double kernel_sigmoid(int i, int j) const
      method kernel_precomputed (line 350) | double kernel_precomputed(int i, int j) const
    class Solver (line 545) | class Solver {
      method Solver (line 547) | Solver() {}
      type SolutionInfo (line 550) | struct SolutionInfo {
      method get_C (line 579) | double get_C(int i)
      method update_alpha_status (line 583) | void update_alpha_status(int i)
      method is_upper_bound (line 591) | bool is_upper_bound(int i) { return alpha_status[i] == UPPER_BOUND; }
      method is_lower_bound (line 592) | bool is_lower_bound(int i) { return alpha_status[i] == LOWER_BOUND; }
      method is_free (line 593) | bool is_free(int i) { return alpha_status[i] == FREE; }
    class Solver_NU (line 1158) | class Solver_NU : public Solver
      method Solver_NU (line 1161) | Solver_NU() {}
      method Solve (line 1162) | void Solve(int l, const QMatrix& Q, const double *p, const schar *y,
    class SVC_Q (line 1415) | class SVC_Q: public Kernel
      method SVC_Q (line 1418) | SVC_Q(const PREFIX(problem)& prob, const svm_parameter& param, const...
      method Qfloat (line 1428) | Qfloat *get_Q(int i, int len) const
      method swap_index (line 1445) | void swap_index(int i, int j) const
    class ONE_CLASS_Q (line 1465) | class ONE_CLASS_Q: public Kernel
      method ONE_CLASS_Q (line 1468) | ONE_CLASS_Q(const PREFIX(problem)& prob, const svm_parameter& param,...
      method Qfloat (line 1477) | Qfloat *get_Q(int i, int len) const
      method swap_index (line 1494) | void swap_index(int i, int j) const
    class SVR_Q (line 1511) | class SVR_Q: public Kernel
      method SVR_Q (line 1514) | SVR_Q(const PREFIX(problem)& prob, const svm_parameter& param, BlasF...
      method swap_index (line 1536) | void swap_index(int i, int j) const
      method Qfloat (line 1543) | Qfloat *get_Q(int i, int len) const
    function solve_c_svc (line 1589) | static void solve_c_svc(
    function solve_nu_svc (line 1638) | static void solve_nu_svc(
    function solve_one_class (line 1702) | static void solve_one_class(
    function solve_epsilon_svr (line 1745) | static void solve_epsilon_svr(
    function solve_nu_svr (line 1787) | static void solve_nu_svr(
    type decision_function (line 1836) | struct decision_function
    function decision_function (line 1842) | static decision_function svm_train_one(
    function sigmoid_train (line 1909) | static void sigmoid_train(
    function sigmoid_predict (line 2022) | static double sigmoid_predict(double decision_value, double A, double B)
    function multiclass_probability (line 2033) | static void multiclass_probability(int k, double **r, double *p)
    function svm_binary_svc_probability (line 2097) | static void svm_binary_svc_probability(
    function svm_svr_probability (line 2196) | static double svm_svr_probability(
    function svm_group_classes (line 2233) | static void svm_group_classes(const PREFIX(problem) *prob, int *nr_cla...
  type PREFIX (line 2716) | struct PREFIX
  type PREFIX (line 2743) | struct PREFIX

FILE: sklearn/svm/src/libsvm/svm.h
  type svm_node (line 11) | struct svm_node
  type svm_problem (line 19) | struct svm_problem
  type svm_csr_node (line 28) | struct svm_csr_node
  type svm_csr_problem (line 34) | struct svm_csr_problem
  type svm_parameter (line 46) | struct svm_parameter
  type svm_model (line 72) | struct svm_model
  type svm_csr_model (line 97) | struct svm_csr_model
  type svm_model (line 122) | struct svm_model
  type svm_problem (line 122) | struct svm_problem
  type svm_parameter (line 122) | struct svm_parameter
  type svm_problem (line 123) | struct svm_problem
  type svm_parameter (line 123) | struct svm_parameter
  type svm_model (line 125) | struct svm_model
  type svm_model (line 126) | struct svm_model
  type svm_model (line 128) | struct svm_model
  type svm_model (line 129) | struct svm_model
  type svm_model (line 130) | struct svm_model
  type svm_model (line 131) | struct svm_model
  type svm_model (line 133) | struct svm_model
  type svm_node (line 133) | struct svm_node
  type svm_model (line 134) | struct svm_model
  type svm_node (line 134) | struct svm_node
  type svm_model (line 135) | struct svm_model
  type svm_node (line 135) | struct svm_node
  type svm_model (line 137) | struct svm_model
  type svm_model (line 138) | struct svm_model
  type svm_parameter (line 139) | struct svm_parameter
  type svm_problem (line 141) | struct svm_problem
  type svm_parameter (line 141) | struct svm_parameter
  type svm_csr_model (line 149) | struct svm_csr_model
  type svm_csr_problem (line 149) | struct svm_csr_problem
  type svm_parameter (line 149) | struct svm_parameter
  type svm_csr_problem (line 150) | struct svm_csr_problem
  type svm_parameter (line 150) | struct svm_parameter
  type svm_csr_model (line 152) | struct svm_csr_model
  type svm_csr_model (line 153) | struct svm_csr_model
  type svm_csr_model (line 154) | struct svm_csr_model
  type svm_csr_model (line 155) | struct svm_csr_model
  type svm_csr_model (line 157) | struct svm_csr_model
  type svm_csr_node (line 157) | struct svm_csr_node
  type svm_csr_model (line 158) | struct svm_csr_model
  type svm_csr_node (line 158) | struct svm_csr_node
  type svm_csr_model (line 159) | struct svm_csr_model
  type svm_csr_node (line 159) | struct svm_csr_node
  type svm_csr_model (line 161) | struct svm_csr_model
  type svm_csr_model (line 162) | struct svm_csr_model
  type svm_parameter (line 163) | struct svm_parameter
  type svm_csr_problem (line 165) | struct svm_csr_problem
  type svm_parameter (line 165) | struct svm_parameter

FILE: sklearn/svm/src/newrand/newrand.h
  function set_seed (line 24) | void set_seed(unsigned custom_seed) {
  function bounded_rand_int (line 29) | inline uint32_t bounded_rand_int(uint32_t range) {

FILE: sklearn/svm/tests/test_bounds.py
  function test_l1_min_c (line 24) | def test_l1_min_c(loss, X_label, Y_label, intercept_label):
  function test_l1_min_c_l2_loss (line 38) | def test_l1_min_c_l2_loss():
  function check_l1_min_c (line 45) | def check_l1_min_c(X, y, loss, fit_intercept=True, intercept_scaling=None):
  function test_ill_posed_min_c (line 72) | def test_ill_posed_min_c():
  function test_unsupported_loss (line 79) | def test_unsupported_loss():
  function test_newrand_set_seed (line 88) | def test_newrand_set_seed(seed, val):
  function test_newrand_set_seed_overflow (line 97) | def test_newrand_set_seed_overflow(seed):
  function test_newrand_bounded_rand_int (line 104) | def test_newrand_bounded_rand_int(range_, n_pts):
  function test_newrand_bounded_rand_int_limits (line 141) | def test_newrand_bounded_rand_int_limits(range_):

FILE: sklearn/svm/tests/test_sparse.py
  function check_svm_model_equal (line 48) | def check_svm_model_equal(dense_svm, sparse_svm, X_train, y_train, X_test):
  function test_svc (line 88) | def test_svc():
  function test_unsorted_indices (line 120) | def test_unsorted_indices():
  function test_svc_with_custom_kernel (line 166) | def test_svc_with_custom_kernel():
  function test_svc_iris (line 175) | def test_svc_iris():
  function test_sparse_decision_function (line 192) | def test_sparse_decision_function():
  function test_error (line 218) | def test_error():
  function test_linearsvc (line 238) | def test_linearsvc():
  function test_linearsvc_iris (line 257) | def test_linearsvc_iris():
  function test_weight (line 283) | def test_weight():
  function test_sample_weights (line 301) | def test_sample_weights():
  function test_sparse_liblinear_intercept_handling (line 312) | def test_sparse_liblinear_intercept_handling():
  function test_sparse_oneclasssvm (line 320) | def test_sparse_oneclasssvm(datasets_index, kernel):
  function test_sparse_realdata (line 337) | def test_sparse_realdata():
  function test_sparse_svc_clone_with_callable_kernel (line 522) | def test_sparse_svc_clone_with_callable_kernel():
  function test_timeout (line 540) | def test_timeout():
  function test_consistent_proba (line 552) | def test_consistent_proba():

FILE: sklearn/svm/tests/test_svm.py
  function test_libsvm_parameters (line 47) | def test_libsvm_parameters():
  function test_libsvm_iris (line 57) | def test_libsvm_iris():
  function test_precomputed (line 91) | def test_precomputed():
  function test_svr (line 164) | def test_svr():
  function test_linearsvr (line 184) | def test_linearsvr():
  function test_linearsvr_fit_sampleweight (line 198) | def test_linearsvr_fit_sampleweight():
  function test_svr_errors (line 239) | def test_svr_errors():
  function test_oneclass (line 250) | def test_oneclass():
  function test_oneclass_decision_function (line 264) | def test_oneclass_decision_function():
  function test_oneclass_score_samples (line 294) | def test_oneclass_score_samples():
  function test_oneclass_fit_params_is_deprecated (line 304) | def test_oneclass_fit_params_is_deprecated():
  function test_tweak_params (line 319) | def test_tweak_params():
  function test_probability (line 334) | def test_probability():
  function test_decision_function (line 353) | def test_decision_function():
  function test_decision_function_shape (line 387) | def test_decision_function_shape(SVM):
  function test_svr_predict (line 416) | def test_svr_predict():
  function test_weight (line 438) | def test_weight():
  function test_svm_classifier_sided_sample_weight (line 462) | def test_svm_classifier_sided_sample_weight(estimator):
  function test_svm_regressor_sided_sample_weight (line 488) | def test_svm_regressor_sided_sample_weight(estimator):
  function test_svm_equivalence_sample_weight_C (line 513) | def test_svm_equivalence_sample_weight_C():
  function test_negative_sample_weights_mask_all_samples (line 539) | def test_negative_sample_weights_mask_all_samples(Estimator, err_msg, sa...
  function test_negative_weights_svc_leave_just_one_label (line 561) | def test_negative_weights_svc_leave_just_one_label(Classifier, err_msg, ...
  function test_negative_weights_svc_leave_two_labels (line 580) | def test_negative_weights_svc_leave_two_labels(
  function test_negative_weight_equal_coeffs (line 596) | def test_negative_weight_equal_coeffs(Estimator, sample_weight):
  function test_auto_weight (line 605) | def test_auto_weight():
  function test_bad_input (line 641) | def test_bad_input():
  function test_svm_gamma_error (line 735) | def test_svm_gamma_error(Estimator, data, gamma, err_msg):
  function test_unicode_kernel (line 742) | def test_unicode_kernel():
  function test_sparse_precomputed (line 752) | def test_sparse_precomputed():
  function test_sparse_fit_support_vectors_empty (line 759) | def test_sparse_fit_support_vectors_empty():
  function test_linearsvc_parameters (line 771) | def test_linearsvc_parameters():
  function test_linear_svx_uppercase_loss_penality_raises_error (line 803) | def test_linear_svx_uppercase_loss_penality_raises_error():
  function test_linearsvc (line 818) | def test_linearsvc():
  function test_linearsvc_crammer_singer (line 849) | def test_linearsvc_crammer_singer():
  function test_linearsvc_fit_sampleweight (line 870) | def test_linearsvc_fit_sampleweight():
  function test_crammer_singer_binary (line 904) | def test_crammer_singer_binary():
  function test_linearsvc_iris (line 921) | def test_linearsvc_iris():
  function test_dense_liblinear_intercept_handling (line 934) | def test_dense_liblinear_intercept_handling(classifier=svm.LinearSVC):
  function test_liblinear_set_coef (line 971) | def test_liblinear_set_coef():
  function test_immutable_coef_property (line 992) | def test_immutable_coef_property():
  function test_linearsvc_verbose (line 1008) | def test_linearsvc_verbose():
  function test_svc_clone_with_callable_kernel (line 1023) | def test_svc_clone_with_callable_kernel():
  function test_svc_bad_kernel (line 1056) | def test_svc_bad_kernel():
  function test_timeout (line 1062) | def test_timeout():
  function test_unfitted (line 1074) | def test_unfitted():
  function test_consistent_proba (line 1088) | def test_consistent_proba():
  function test_linear_svm_convergence_warnings (line 1096) | def test_linear_svm_convergence_warnings():
  function test_svr_coef_sign (line 1111) | def test_svr_coef_sign():
  function test_linear_svc_intercept_scaling (line 1124) | def test_linear_svc_intercept_scaling():
  function test_lsvc_intercept_scaling_zero (line 1140) | def test_lsvc_intercept_scaling_zero():
  function test_hasattr_predict_proba (line 1148) | def test_hasattr_predict_proba():
  function test_decision_function_shape_two_class (line 1172) | def test_decision_function_shape_two_class():
  function test_ovr_decision_function (line 1182) | def test_ovr_decision_function():
  function test_svc_invalid_break_ties_param (line 1227) | def test_svc_invalid_break_ties_param(SVCClass):
  function test_svc_ovr_tie_breaking (line 1239) | def test_svc_ovr_tie_breaking(SVCClass):
  function test_gamma_auto (line 1269) | def test_gamma_auto():
  function test_gamma_scale (line 1281) | def test_gamma_scale():
  function test_linearsvm_liblinear_sample_weight (line 1310) | def test_linearsvm_liblinear_sample_weight(SVM, params):
  function test_n_support_oneclass_svr (line 1357) | def test_n_support_oneclass_svr():
  function test_custom_kernel_not_array_input (line 1377) | def test_custom_kernel_not_array_input(Estimator):
  function test_svc_raises_error_internal_representation (line 1414) | def test_svc_raises_error_internal_representation():

FILE: sklearn/tests/test_base.py
  class MyEstimator (line 32) | class MyEstimator(BaseEstimator):
    method __init__ (line 33) | def __init__(self, l1=0, empty=None):
  class K (line 38) | class K(BaseEstimator):
    method __init__ (line 39) | def __init__(self, c=None, d=None):
  class T (line 44) | class T(BaseEstimator):
    method __init__ (line 45) | def __init__(self, a=None, b=None):
  class NaNTag (line 50) | class NaNTag(BaseEstimator):
    method _more_tags (line 51) | def _more_tags(self):
  class NoNaNTag (line 55) | class NoNaNTag(BaseEstimator):
    method _more_tags (line 56) | def _more_tags(self):
  class OverrideTag (line 60) | class OverrideTag(NaNTag):
    method _more_tags (line 61) | def _more_tags(self):
  class DiamondOverwriteTag (line 65) | class DiamondOverwriteTag(NaNTag, NoNaNTag):
    method _more_tags (line 66) | def _more_tags(self):
  class InheritDiamondOverwriteTag (line 70) | class InheritDiamondOverwriteTag(DiamondOverwriteTag):
  class ModifyInitParams (line 74) | class ModifyInitParams(BaseEstimator):
    method __init__ (line 80) | def __init__(self, a=np.array([0])):
  class Buggy (line 84) | class Buggy(BaseEstimator):
    method __init__ (line 87) | def __init__(self, a=None):
  class NoEstimator (line 91) | class NoEstimator:
    method __init__ (line 92) | def __init__(self):
    method fit (line 95) | def fit(self, X=None, y=None):
    method predict (line 98) | def predict(self, X=None):
  class VargEstimator (line 102) | class VargEstimator(BaseEstimator):
    method __init__ (line 105) | def __init__(self, *vargs):
  function test_clone (line 113) | def test_clone():
  function test_clone_2 (line 131) | def test_clone_2():
  function test_clone_buggy (line 145) | def test_clone_buggy():
  function test_clone_empty_array (line 165) | def test_clone_empty_array():
  function test_clone_nan (line 176) | def test_clone_nan():
  function test_clone_sparse_matrices (line 184) | def test_clone_sparse_matrices():
  function test_clone_estimator_types (line 197) | def test_clone_estimator_types():
  function test_clone_class_rather_than_instance (line 206) | def test_clone_class_rather_than_instance():
  function test_repr (line 214) | def test_repr():
  function test_str (line 225) | def test_str():
  function test_get_params (line 231) | def test_get_params():
  function test_is_classifier (line 244) | def test_is_classifier():
  function test_set_params (line 252) | def test_set_params():
  function test_set_params_passes_all_parameters (line 270) | def test_set_params_passes_all_parameters():
  function test_set_params_updates_valid_params (line 289) | def test_set_params_updates_valid_params():
  function test_score_sample_weight (line 310) | def test_score_sample_weight(tree, dataset):
  function test_clone_pandas_dataframe (line 324) | def test_clone_pandas_dataframe():
  function test_pickle_version_warning_is_not_raised_with_matching_version (line 362) | def test_pickle_version_warning_is_not_raised_with_matching_version():
  class TreeBadVersion (line 375) | class TreeBadVersion(DecisionTreeClassifier):
    method __getstate__ (line 376) | def __getstate__(self):
  function test_pickle_version_warning_is_issued_upon_different_version (line 389) | def test_pickle_version_warning_is_issued_upon_different_version():
  class TreeNoVersion (line 402) | class TreeNoVersion(DecisionTreeClassifier):
    method __getstate__ (line 403) | def __getstate__(self):
  function test_pickle_version_warning_is_issued_when_no_version_info_in_pickle (line 407) | def test_pickle_version_warning_is_issued_when_no_version_info_in_pickle():
  function test_pickle_version_no_warning_is_issued_with_non_sklearn_estimator (line 424) | def test_pickle_version_no_warning_is_issued_with_non_sklearn_estimator():
  class DontPickleAttributeMixin (line 436) | class DontPickleAttributeMixin:
    method __getstate__ (line 437) | def __getstate__(self):
    method __setstate__ (line 442) | def __setstate__(self, state):
  class MultiInheritanceEstimator (line 447) | class MultiInheritanceEstimator(DontPickleAttributeMixin, BaseEstimator):
    method __init__ (line 448) | def __init__(self, attribute_pickled=5):
  function test_pickling_when_getstate_is_overwritten_by_mixin (line 453) | def test_pickling_when_getstate_is_overwritten_by_mixin():
  function test_pickling_when_getstate_is_overwritten_by_mixin_outside_of_sklearn (line 464) | def test_pickling_when_getstate_is_overwritten_by_mixin_outside_of_sklea...
  class SingleInheritanceEstimator (line 483) | class SingleInheritanceEstimator(BaseEstimator):
    method __init__ (line 484) | def __init__(self, attribute_pickled=5):
    method __getstate__ (line 488) | def __getstate__(self):
  function test_pickling_works_when_getstate_is_overwritten_in_the_child_class (line 495) | def test_pickling_works_when_getstate_is_overwritten_in_the_child_class():
  function test_tag_inheritance (line 505) | def test_tag_inheritance():
  function test_raises_on_get_params_non_attribute (line 523) | def test_raises_on_get_params_non_attribute():
  function test_repr_mimebundle_ (line 538) | def test_repr_mimebundle_():
  function test_repr_html_wraps (line 551) | def test_repr_html_wraps():
  function test_is_pairwise (line 564) | def test_is_pairwise():
  function test_n_features_in_validation (line 596) | def test_n_features_in_validation():
  function test_n_features_in_no_validation (line 609) | def test_n_features_in_no_validation():
  function test_feature_names_in (line 621) | def test_feature_names_in():

FILE: sklearn/tests/test_build.py
  function test_openmp_parallelism_enabled (line 9) | def test_openmp_parallelism_enabled():

FILE: sklearn/tests/test_calibration.py
  function data (line 45) | def data():
  function test_calibration (line 52) | def test_calibration(data, method, ensemble):
  function test_calibration_bad_method (line 112) | def test_calibration_bad_method(data, ensemble):
  function test_calibration_regressor (line 122) | def test_calibration_regressor(data, ensemble):
  function test_calibration_default_estimator (line 133) | def test_calibration_default_estimator(data):
  function test_calibration_cv_splitter (line 144) | def test_calibration_cv_splitter(data, ensemble):
  function test_sample_weight (line 161) | def test_sample_weight(data, method, ensemble):
  function test_parallel_execution (line 187) | def test_parallel_execution(data, method, ensemble):
  function test_calibration_multiclass (line 214) | def test_calibration_multiclass(method, ensemble, seed):
  function test_calibration_zero_probability (line 275) | def test_calibration_zero_probability():
  function test_calibration_prefit (line 300) | def test_calibration_prefit():
  function test_calibration_ensemble_false (line 348) | def test_calibration_ensemble_false(data, method):
  function test_sigmoid_calibration (line 372) | def test_sigmoid_calibration():
  function test_calibration_curve (line 389) | def test_calibration_curve():
  function test_calibration_nan_imputer (line 427) | def test_calibration_nan_imputer(ensemble):
  function test_calibration_prob_sum (line 442) | def test_calibration_prob_sum(ensemble):
  function test_calibration_less_classes (line 458) | def test_calibration_less_classes(ensemble):
  function test_calibration_accepts_ndarray (line 492) | def test_calibration_accepts_ndarray(X):
  function dict_data (line 513) | def dict_data():
  function dict_data_pipeline (line 524) | def dict_data_pipeline(dict_data):
  function test_calibration_dict_pipeline (line 532) | def test_calibration_dict_pipeline(dict_data, dict_data_pipeline):
  function test_calibration_attributes (line 565) | def test_calibration_attributes(clf, cv):
  function test_calibration_inconsistent_prefit_n_features_in (line 582) | def test_calibration_inconsistent_prefit_n_features_in():
  function test_calibration_votingclassifier (line 594) | def test_calibration_votingclassifier():
  function iris_data (line 611) | def iris_data():
  function iris_data_binary (line 616) | def iris_data_binary(iris_data):
  function test_calibration_display_validation (line 621) | def test_calibration_display_validation(pyplot, iris_data, iris_data_bin...
  function test_calibration_display_non_binary (line 641) | def test_calibration_display_non_binary(pyplot, iris_data, constructor_n...
  function test_calibration_display_compute (line 659) | def test_calibration_display_compute(pyplot, iris_data_binary, n_bins, s...
  function test_plot_calibration_curve_pipeline (line 700) | def test_plot_calibration_curve_pipeline(pyplot, iris_data_binary):
  function test_calibration_display_default_labels (line 717) | def test_calibration_display_default_labels(pyplot, name, expected_label):
  function test_calibration_display_label_class_plot (line 733) | def test_calibration_display_label_class_plot(pyplot):
  function test_calibration_display_name_multiple_calls (line 754) | def test_calibration_display_name_multiple_calls(
  function test_calibration_display_ref_line (line 788) | def test_calibration_display_ref_line(pyplot, iris_data_binary):
  function test_calibration_curve_pos_label_error_str (line 802) | def test_calibration_curve_pos_label_error_str(dtype_y_str):
  function test_calibration_curve_pos_label (line 818) | def test_calibration_curve_pos_label(dtype_y_str):
  function test_calibration_display_pos_label (line 839) | def test_calibration_display_pos_label(
  function test_calibrated_classifier_cv_double_sample_weights_equivalence (line 873) | def test_calibrated_classifier_cv_double_sample_weights_equivalence(meth...
  function test_calibrated_classifier_cv_zeros_sample_weights_equivalence (line 923) | def test_calibrated_classifier_cv_zeros_sample_weights_equivalence(metho...

FILE: sklearn/tests/test_check_build.py
  function test_raise_build_error (line 13) | def test_raise_build_error():

FILE: sklearn/tests/test_common.py
  function test_all_estimator_no_base_class (line 59) | def test_all_estimator_no_base_class():
  function _sample_func (line 68) | def _sample_func(x, y=1):
  function test_get_check_estimator_ids (line 91) | def test_get_check_estimator_ids(val, expected):
  function _tested_estimators (line 95) | def _tested_estimators(type_filter=None):
  function test_estimators (line 106) | def test_estimators(estimator, check, request):
  function test_check_estimator_generate_only (line 113) | def test_check_estimator_generate_only():
  function test_configure (line 120) | def test_configure():
  function _tested_linear_classifiers (line 149) | def _tested_linear_classifiers():
  function test_class_weight_balanced_linear_classifiers (line 166) | def test_class_weight_balanced_linear_classifiers(name, Classifier):
  function test_import_all_consistency (line 171) | def test_import_all_consistency():
  function test_root_import_all_completeness (line 193) | def test_root_import_all_completeness():
  function test_all_tests_are_importable (line 203) | def test_all_tests_are_importable():
  function test_class_support_removed (line 240) | def test_class_support_removed():
  function _generate_search_cv_instances (line 252) | def _generate_search_cv_instances():
  function test_search_cv (line 297) | def test_search_cv(estimator, check, request):
  function test_valid_tag_types (line 315) | def test_valid_tag_types(estimator):
  function test_check_n_features_in_after_fitting (line 330) | def test_check_n_features_in_after_fitting(estimator):
  function test_pandas_column_name_consistency (line 350) | def test_pandas_column_name_consistency(estimator):
  function _include_in_get_feature_names_out_check (line 377) | def _include_in_get_feature_names_out_check(transformer):
  function test_transformers_get_feature_names_out (line 394) | def test_transformers_get_feature_names_out(transformer):
  function test_estimators_do_not_raise_errors_in_init_or_set_params (line 425) | def test_estimators_do_not_raise_errors_in_init_or_set_params(Estimator):

FILE: sklearn/tests/test_config.py
  function test_config_context (line 13) | def test_config_context():
  function test_config_context_exception (line 71) | def test_config_context_exception():
  function test_set_config (line 82) | def test_set_config():
  function set_assume_finite (line 98) | def set_assume_finite(assume_finite, sleep_duration):
  function test_config_threadsafe_joblib (line 106) | def test_config_threadsafe_joblib(backend):
  function test_config_threadsafe (line 128) | def test_config_threadsafe():

FILE: sklearn/tests/test_discriminant_analysis.py
  function test_lda_predict (line 71) | def test_lda_predict():
  function test_lda_predict_proba (line 156) | def test_lda_predict_proba(solver, n_classes):
  function test_lda_priors (line 250) | def test_lda_priors():
  function test_lda_coefs (line 275) | def test_lda_coefs():
  function test_lda_transform (line 297) | def test_lda_transform():
  function test_lda_explained_variance_ratio (line 314) | def test_lda_explained_variance_ratio():
  function test_lda_orthogonality (line 343) | def test_lda_orthogonality():
  function test_lda_scaling (line 384) | def test_lda_scaling():
  function test_lda_store_covariance (line 401) | def test_lda_store_covariance():
  function test_lda_shrinkage (line 432) | def test_lda_shrinkage(seed):
  function test_lda_ledoitwolf (line 450) | def test_lda_ledoitwolf():
  function test_lda_dimension_warning (line 482) | def test_lda_dimension_warning(n_classes, n_features):
  function test_lda_dtype_match (line 517) | def test_lda_dtype_match(data_type, expected_type):
  function test_lda_numeric_consistency_float32_float64 (line 524) | def test_lda_numeric_consistency_float32_float64():
  function test_qda (line 536) | def test_qda():
  function test_qda_priors (line 563) | def test_qda_priors():
  function test_qda_store_covariance (line 576) | def test_qda_store_covariance():
  function test_qda_regularization (line 593) | def test_qda_regularization():
  function test_covariance (line 629) | def test_covariance():
  function test_raises_value_error_on_same_number_of_classes_and_samples (line 643) | def test_raises_value_error_on_same_number_of_classes_and_samples(solver):

FILE: sklearn/tests/test_docstring_parameters.py
  function test_docstring_parameters (line 70) | def test_docstring_parameters():
  function test_tabs (line 151) | def test_tabs():
  function _construct_searchcv_instance (line 174) | def _construct_searchcv_instance(SearchCV):
  function _construct_compose_pipeline_instance (line 178) | def _construct_compose_pipeline_instance(Estimator):
  function _construct_sparse_coder (line 188) | def _construct_sparse_coder(Estimator):
  function test_fit_docstring_attributes (line 198) | def test_fit_docstring_attributes(name, Estimator):
  function _get_all_fitted_attributes (line 318) | def _get_all_fitted_attributes(estimator):

FILE: sklearn/tests/test_dummy.py
  function _check_predict_proba (line 18) | def _check_predict_proba(clf, X, y):
  function _check_behavior_2d (line 42) | def _check_behavior_2d(clf):
  function _check_behavior_2d_for_constant (line 59) | def _check_behavior_2d_for_constant(clf):
  function _check_equality_regressor (line 69) | def _check_equality_regressor(statistic, y_learn, y_pred_learn, y_test, ...
  function test_most_frequent_and_prior_strategy (line 74) | def test_most_frequent_and_prior_strategy():
  function test_most_frequent_and_prior_strategy_with_2d_column_y (line 94) | def test_most_frequent_and_prior_strategy_with_2d_column_y():
  function test_most_frequent_and_prior_strategy_multioutput (line 110) | def test_most_frequent_and_prior_strategy_multioutput():
  function test_stratified_strategy (line 127) | def test_stratified_strategy():
  function test_stratified_strategy_multioutput (line 141) | def test_stratified_strategy_multioutput():
  function test_uniform_strategy (line 160) | def test_uniform_strategy():
  function test_uniform_strategy_multioutput (line 174) | def test_uniform_strategy_multioutput():
  function test_string_labels (line 192) | def test_string_labels():
  function test_classifier_score_with_None (line 210) | def test_classifier_score_with_None(y, y_test):
  function test_classifier_prediction_independent_of_X (line 219) | def test_classifier_prediction_independent_of_X(strategy):
  function test_classifier_exceptions (line 234) | def test_classifier_exceptions():
  function test_mean_strategy_regressor (line 245) | def test_mean_strategy_regressor():
  function test_mean_strategy_multioutput_regressor (line 257) | def test_mean_strategy_multioutput_regressor():
  function test_regressor_exceptions (line 279) | def test_regressor_exceptions():
  function test_median_strategy_regressor (line 285) | def test_median_strategy_regressor():
  function test_median_strategy_multioutput_regressor (line 297) | def test_median_strategy_multioutput_regressor():
  function test_quantile_strategy_regressor (line 319) | def test_quantile_strategy_regressor():
  function test_quantile_strategy_multioutput_regressor (line 343) | def test_quantile_strategy_multioutput_regressor():
  function test_quantile_invalid (line 377) | def test_quantile_invalid():
  function test_quantile_strategy_empty_train (line 407) | def test_quantile_strategy_empty_train():
  function test_constant_strategy_regressor (line 413) | def test_constant_strategy_regressor():
  function test_constant_strategy_multioutput_regressor (line 429) | def test_constant_strategy_multioutput_regressor():
  function test_y_mean_attribute_regressor (line 452) | def test_y_mean_attribute_regressor():
  function test_unknown_strategey_regressor (line 462) | def test_unknown_strategey_regressor():
  function test_constants_not_specified_regressor (line 471) | def test_constants_not_specified_regressor():
  function test_constant_size_multioutput_regressor (line 480) | def test_constant_size_multioutput_regressor():
  function test_constant_strategy (line 490) | def test_constant_strategy():
  function test_constant_strategy_multioutput (line 507) | def test_constant_strategy_multioutput():
  function test_constant_strategy_exceptions (line 550) | def test_constant_strategy_exceptions(y, params, err_msg):
  function test_classification_sample_weight (line 559) | def test_classification_sample_weight():
  function test_constant_strategy_sparse_target (line 568) | def test_constant_strategy_sparse_target():
  function test_uniform_strategy_sparse_target_warning (line 583) | def test_uniform_strategy_sparse_target_warning():
  function test_stratified_strategy_sparse_target (line 601) | def test_stratified_strategy_sparse_target():
  function test_most_frequent_and_prior_strategy_sparse_target (line 620) | def test_most_frequent_and_prior_strategy_sparse_target():
  function test_dummy_regressor_sample_weight (line 635) | def test_dummy_regressor_sample_weight(n_samples=10):
  function test_dummy_regressor_on_3D_array (line 652) | def test_dummy_regressor_on_3D_array():
  function test_dummy_classifier_on_3D_array (line 662) | def test_dummy_classifier_on_3D_array():
  function test_dummy_regressor_return_std (line 675) | def test_dummy_regressor_return_std():
  function test_regressor_score_with_None (line 695) | def test_regressor_score_with_None(y, y_test):
  function test_regressor_prediction_independent_of_X (line 702) | def test_regressor_prediction_independent_of_X(strategy):
  function test_dtype_of_classifier_probas (line 720) | def test_dtype_of_classifier_probas(strategy):
  function test_n_features_in_ (line 732) | def test_n_features_in_(Dummy):

FILE: sklearn/tests/test_init.py
  function test_import_skl (line 16) | def test_import_skl():

FILE: sklearn/tests/test_isotonic.py
  function test_permutation_invariance (line 27) | def test_permutation_invariance():
  function test_check_increasing_small_number_of_samples (line 41) | def test_check_increasing_small_number_of_samples():
  function test_check_increasing_up (line 52) | def test_check_increasing_up():
  function test_check_increasing_up_extreme (line 64) | def test_check_increasing_up_extreme():
  function test_check_increasing_down (line 76) | def test_check_increasing_down():
  function test_check_increasing_down_extreme (line 88) | def test_check_increasing_down_extreme():
  function test_check_ci_warn (line 100) | def test_check_ci_warn():
  function test_isotonic_regression (line 112) | def test_isotonic_regression():
  function test_isotonic_regression_ties_min (line 138) | def test_isotonic_regression_ties_min():
  function test_isotonic_regression_ties_max (line 151) | def test_isotonic_regression_ties_max():
  function test_isotonic_regression_ties_secondary_ (line 164) | def test_isotonic_regression_ties_secondary_():
  function test_isotonic_regression_with_ties_in_differently_sized_groups (line 205) | def test_isotonic_regression_with_ties_in_differently_sized_groups():
  function test_isotonic_regression_reversed (line 229) | def test_isotonic_regression_reversed():
  function test_isotonic_regression_auto_decreasing (line 235) | def test_isotonic_regression_auto_decreasing():
  function test_isotonic_regression_auto_increasing (line 253) | def test_isotonic_regression_auto_increasing():
  function test_assert_raises_exceptions (line 271) | def test_assert_raises_exceptions():
  function test_isotonic_sample_weight_parameter_default_value (line 291) | def test_isotonic_sample_weight_parameter_default_value():
  function test_isotonic_min_max_boundaries (line 307) | def test_isotonic_min_max_boundaries():
  function test_isotonic_sample_weight (line 318) | def test_isotonic_sample_weight():
  function test_isotonic_regression_oob_raise (line 329) | def test_isotonic_regression_oob_raise():
  function test_isotonic_regression_oob_clip (line 344) | def test_isotonic_regression_oob_clip():
  function test_isotonic_regression_oob_nan (line 360) | def test_isotonic_regression_oob_nan():
  function test_isotonic_regression_oob_bad (line 374) | def test_isotonic_regression_oob_bad():
  function test_isotonic_regression_oob_bad_after (line 388) | def test_isotonic_regression_oob_bad_after():
  function test_isotonic_regression_pickle (line 404) | def test_isotonic_regression_pickle():
  function test_isotonic_duplicate_min_entry (line 417) | def test_isotonic_duplicate_min_entry():
  function test_isotonic_ymin_ymax (line 427) | def test_isotonic_ymin_ymax():
  function test_isotonic_zero_weight_loop (line 471) | def test_isotonic_zero_weight_loop():
  function test_fast_predict (line 493) | def test_fast_predict():
  function test_isotonic_copy_before_fit (line 530) | def test_isotonic_copy_before_fit():
  function test_isotonic_dtype (line 536) | def test_isotonic_dtype():
  function test_isotonic_mismatched_dtype (line 558) | def test_isotonic_mismatched_dtype(y_dtype):
  function test_make_unique_dtype (line 568) | def test_make_unique_dtype():
  function test_make_unique_tolerance (line 579) | def test_make_unique_tolerance(dtype):
  function test_isotonic_make_unique_tolerance (line 592) | def test_isotonic_make_unique_tolerance():
  function test_isotonic_non_regression_inf_slope (line 605) | def test_isotonic_non_regression_inf_slope():
  function test_isotonic_thresholds (line 616) | def test_isotonic_thresholds(increasing):
  function test_input_shape_validation (line 642) | def test_input_shape_validation():
  function test_isotonic_2darray_more_than_1_feature (line 664) | def test_isotonic_2darray_more_than_1_feature():
  function test_isotonic_regression_sample_weight_not_overwritten (line 682) | def test_isotonic_regression_sample_weight_not_overwritten():

FILE: sklearn/tests/test_kernel_approximation.py
  function test_polynomial_count_sketch_raises_if_degree_lower_than_one (line 28) | def test_polynomial_count_sketch_raises_if_degree_lower_than_one(degree):
  function test_polynomial_count_sketch (line 39) | def test_polynomial_count_sketch(X, Y, gamma, degree, coef0):
  function _linear_kernel (line 61) | def _linear_kernel(X, Y):
  function test_additive_chi2_sampler (line 65) | def test_additive_chi2_sampler():
  function test_skewed_chi2_sampler (line 128) | def test_skewed_chi2_sampler():
  function test_additive_chi2_sampler_exceptions (line 168) | def test_additive_chi2_sampler_exceptions():
  function test_rbf_sampler (line 180) | def test_rbf_sampler():
  function test_input_validation (line 199) | def test_input_validation():
  function test_nystroem_approximation (line 211) | def test_nystroem_approximation():
  function test_nystroem_default_parameters (line 238) | def test_nystroem_default_parameters():
  function test_nystroem_singular_kernel (line 258) | def test_nystroem_singular_kernel():
  function test_nystroem_poly_kernel_params (line 274) | def test_nystroem_poly_kernel_params():
  function test_nystroem_callable (line 287) | def test_nystroem_callable():
  function test_nystroem_precomputed_kernel (line 316) | def test_nystroem_precomputed_kernel():
  function test_nystroem_component_indices (line 336) | def test_nystroem_component_indices():

FILE: sklearn/tests/test_kernel_ridge.py
  function test_kernel_ridge (line 21) | def test_kernel_ridge():
  function test_kernel_ridge_csr (line 27) | def test_kernel_ridge_csr():
  function test_kernel_ridge_csc (line 37) | def test_kernel_ridge_csc():
  function test_kernel_ridge_singular_kernel (line 47) | def test_kernel_ridge_singular_kernel():
  function test_kernel_ridge_precomputed (line 57) | def test_kernel_ridge_precomputed():
  function test_kernel_ridge_precomputed_kernel_unchanged (line 65) | def test_kernel_ridge_precomputed_kernel_unchanged():
  function test_kernel_ridge_sample_weights (line 72) | def test_kernel_ridge_sample_weights():
  function test_kernel_ridge_multi_output (line 87) | def test_kernel_ridge_multi_output():
  function test_kernel_ridge_pairwise_is_deprecated (line 98) | def test_kernel_ridge_pairwise_is_deprecated():

FILE: sklearn/tests/test_metaestimators.py
  class DelegatorData (line 27) | class DelegatorData:
    method __init__ (line 28) | def __init__(
  function test_metaestimator_delegation (line 73) | def test_metaestimator_delegation():
  function _generate_meta_estimator_instances_with_pipeline (line 188) | def _generate_meta_estimator_instances_with_pipeline():
  function _get_meta_estimator_id (line 270) | def _get_meta_estimator_id(estimator):
  function test_meta_estimators_delegate_data_validation (line 277) | def test_meta_estimators_delegate_data_validation(estimator):

FILE: sklearn/tests/test_min_dependencies_readme.py
  function test_min_dependencies_readme (line 15) | def test_min_dependencies_readme():

FILE: sklearn/tests/test_multiclass.py
  function test_ovr_exceptions (line 50) | def test_ovr_exceptions():
  function test_check_classification_targets (line 70) | def test_check_classification_targets():
  function test_ovr_fit_predict (line 78) | def test_ovr_fit_predict():
  function test_ovr_partial_fit (line 94) | def test_ovr_partial_fit():
  function test_ovr_partial_fit_exceptions (line 130) | def test_ovr_partial_fit_exceptions():
  function test_ovr_ovo_regressor (line 143) | def test_ovr_ovo_regressor():
  function test_ovr_fit_predict_sparse (line 161) | def test_ovr_fit_predict_sparse():
  function test_ovr_always_present (line 209) | def test_ovr_always_present():
  function test_ovr_multiclass (line 245) | def test_ovr_multiclass():
  function test_ovr_binary (line 271) | def test_ovr_binary():
  function test_ovr_multilabel (line 311) | def test_ovr_multilabel():
  function test_ovr_fit_predict_svc (line 330) | def test_ovr_fit_predict_svc():
  function test_ovr_multilabel_dataset (line 337) | def test_ovr_multilabel_dataset():
  function test_ovr_multilabel_predict_proba (line 363) | def test_ovr_multilabel_predict_proba():
  function test_ovr_single_label_predict_proba (line 408) | def test_ovr_single_label_predict_proba():
  function test_ovr_multilabel_decision_function (line 429) | def test_ovr_multilabel_decision_function():
  function test_ovr_single_label_decision_function (line 447) | def test_ovr_single_label_decision_function():
  function test_ovr_gridsearch (line 455) | def test_ovr_gridsearch():
  function test_ovr_pipeline (line 464) | def test_ovr_pipeline():
  function test_ovr_coef_ (line 479) | def test_ovr_coef_():
  function test_ovr_coef_exceptions (line 500) | def test_ovr_coef_exceptions():
  function test_ovr_deprecated_coef_intercept (line 517) | def test_ovr_deprecated_coef_intercept():
  function test_ovo_exceptions (line 533) | def test_ovo_exceptions():
  function test_ovo_fit_on_list (line 539) | def test_ovo_fit_on_list():
  function test_ovo_fit_predict (line 551) | def test_ovo_fit_predict():
  function test_ovo_partial_fit_predict (line 563) | def test_ovo_partial_fit_predict():
  function test_ovo_decision_function (line 616) | def test_ovo_decision_function():
  function test_ovo_gridsearch (line 663) | def test_ovo_gridsearch():
  function test_ovo_ties (line 672) | def test_ovo_ties():
  function test_ovo_ties2 (line 696) | def test_ovo_ties2():
  function test_ovo_string_y (line 709) | def test_ovo_string_y():
  function test_ovo_one_class (line 719) | def test_ovo_one_class():
  function test_ovo_float_y (line 730) | def test_ovo_float_y():
  function test_ecoc_exceptions (line 741) | def test_ecoc_exceptions():
  function test_ecoc_fit_predict (line 747) | def test_ecoc_fit_predict():
  function test_ecoc_gridsearch (line 759) | def test_ecoc_gridsearch():
  function test_ecoc_float_y (line 768) | def test_ecoc_float_y():
  function test_ecoc_delegate_sparse_base_estimator (line 784) | def test_ecoc_delegate_sparse_base_estimator():
  function test_pairwise_indices (line 810) | def test_pairwise_indices():
  function test_pairwise_n_features_in (line 827) | def test_pairwise_n_features_in():
  function test_pairwise_attribute (line 897) | def test_pairwise_attribute():
  function test_pairwise_tag (line 912) | def test_pairwise_tag(MultiClassClassifier):
  function test_pairwise_deprecated (line 927) | def test_pairwise_deprecated(MultiClassClassifier):
  function test_pairwise_cross_val_score (line 938) | def test_pairwise_cross_val_score(MultiClassClassifier):
  function test_support_missing_values (line 962) | def test_support_missing_values(MultiClassClassifier):

FILE: sklearn/tests/test_multioutput.py
  function test_multi_target_regression (line 36) | def test_multi_target_regression():
  function test_multi_target_regression_partial_fit (line 54) | def test_multi_target_regression_partial_fit():
  function test_multi_target_regression_one_target (line 77) | def test_multi_target_regression_one_target():
  function test_multi_target_sparse_regression (line 86) | def test_multi_target_sparse_regression():
  function test_multi_target_sample_weights_api (line 107) | def test_multi_target_sample_weights_api():
  function test_multi_target_sample_weight_partial_fit (line 122) | def test_multi_target_sample_weight_partial_fit():
  function test_multi_target_sample_weights (line 138) | def test_multi_target_sample_weights():
  function test_multi_output_classification_partial_fit_parallelism (line 170) | def test_multi_output_classification_partial_fit_parallelism():
  function test_hasattr_multi_output_predict_proba (line 183) | def test_hasattr_multi_output_predict_proba():
  function test_multi_output_predict_proba (line 199) | def test_multi_output_predict_proba():
  function test_multi_output_classification_partial_fit (line 228) | def test_multi_output_classification_partial_fit():
  function test_multi_output_classification_partial_fit_no_first_classes_exception (line 259) | def test_multi_output_classification_partial_fit_no_first_classes_except...
  function test_multi_output_classification (line 267) | def test_multi_output_classification():
  function test_multiclass_multioutput_estimator (line 296) | def test_multiclass_multioutput_estimator():
  function test_multiclass_multioutput_estimator_predict_proba (line 314) | def test_multiclass_multioutput_estimator_predict_proba():
  function test_multi_output_classification_sample_weights (line 361) | def test_multi_output_classification_sample_weights():
  function test_multi_output_classification_partial_fit_sample_weights (line 381) | def test_multi_output_classification_partial_fit_sample_weights():
  function test_multi_output_exceptions (line 400) | def test_multi_output_exceptions():
  function test_multi_output_not_fitted_error (line 421) | def test_multi_output_not_fitted_error(response_method):
  function test_multi_output_delegate_predict_proba (line 428) | def test_multi_output_delegate_predict_proba():
  function generate_multilabel_dataset_with_correlations (line 450) | def generate_multilabel_dataset_with_correlations():
  function test_classifier_chain_fit_and_predict_with_linear_svc (line 462) | def test_classifier_chain_fit_and_predict_with_linear_svc():
  function test_classifier_chain_fit_and_predict_with_sparse_data (line 478) | def test_classifier_chain_fit_and_predict_with_sparse_data():
  function test_classifier_chain_vs_independent_models (line 494) | def test_classifier_chain_vs_independent_models():
  function test_base_chain_fit_and_predict (line 517) | def test_base_chain_fit_and_predict():
  function test_base_chain_fit_and_predict_with_sparse_data_and_cv (line 536) | def test_base_chain_fit_and_predict_with_sparse_data_and_cv():
  function test_base_chain_random_order (line 550) | def test_base_chain_random_order():
  function test_base_chain_crossval_fit_and_predict (line 568) | def test_base_chain_crossval_fit_and_predict():
  function test_multi_output_classes_ (line 596) | def test_multi_output_classes_(estimator):
  class DummyRegressorWithFitParams (line 606) | class DummyRegressorWithFitParams(DummyRegressor):
    method fit (line 607) | def fit(self, X, y, sample_weight=None, **fit_params):
  class DummyClassifierWithFitParams (line 612) | class DummyClassifierWithFitParams(DummyClassifier):
    method fit (line 613) | def fit(self, X, y, sample_weight=None, **fit_params):
  function test_multioutput_estimator_with_fit_params (line 632) | def test_multioutput_estimator_with_fit_params(estimator, dataset):
  function test_regressor_chain_w_fit_params (line 640) | def test_regressor_chain_w_fit_params():
  function test_support_missing_values (line 667) | def test_support_missing_values(MultiOutputEstimator, Estimator):
  function test_classifier_chain_tuple_order (line 681) | def test_classifier_chain_tuple_order(order_type):
  function test_classifier_chain_tuple_invalid_order (line 694) | def test_classifier_chain_tuple_invalid_order():
  function test_multioutputregressor_ducktypes_fitted_estimator (line 705) | def test_multioutputregressor_ducktypes_fitted_estimator():

FILE: sklearn/tests/test_naive_bayes.py
  function test_gnb (line 40) | def test_gnb():
  function test_gnb_var (line 63) | def test_gnb_var():
  function test_gnb_prior (line 71) | def test_gnb_prior():
  function test_gnb_sample_weight (line 80) | def test_gnb_sample_weight():
  function test_gnb_neg_priors (line 112) | def test_gnb_neg_priors():
  function test_gnb_priors (line 121) | def test_gnb_priors():
  function test_gnb_priors_sum_isclose (line 132) | def test_gnb_priors_sum_isclose():
  function test_gnb_wrong_nb_priors (line 155) | def test_gnb_wrong_nb_priors():
  function test_gnb_prior_greater_one (line 165) | def test_gnb_prior_greater_one():
  function test_gnb_prior_large_bias (line 174) | def test_gnb_prior_large_bias():
  function test_gnb_check_update_with_no_data (line 181) | def test_gnb_check_update_with_no_data():
  function test_gnb_partial_fit (line 193) | def test_gnb_partial_fit():
  function test_gnb_naive_bayes_scale_invariance (line 207) | def test_gnb_naive_bayes_scale_invariance():
  function test_discretenb_deprecated_coef_intercept (line 218) | def test_discretenb_deprecated_coef_intercept(DiscreteNaiveBayes):
  function test_discretenb_prior (line 227) | def test_discretenb_prior(DiscreteNaiveBayes):
  function test_discretenb_partial_fit (line 236) | def test_discretenb_partial_fit(DiscreteNaiveBayes):
  function test_NB_partial_fit_no_first_classes (line 286) | def test_NB_partial_fit_no_first_classes(NaiveBayes):
  function test_discretenb_predict_proba (line 304) | def test_discretenb_predict_proba():
  function test_discretenb_uniform_prior (line 339) | def test_discretenb_uniform_prior(DiscreteNaiveBayes):
  function test_discretenb_provide_prior (line 351) | def test_discretenb_provide_prior(DiscreteNaiveBayes):
  function test_discretenb_provide_prior_with_partial_fit (line 370) | def test_discretenb_provide_prior_with_partial_fit(DiscreteNaiveBayes):
  function test_discretenb_sample_weight_multiclass (line 391) | def test_discretenb_sample_weight_multiclass(DiscreteNaiveBayes):
  function test_discretenb_coef_intercept_shape (line 418) | def test_discretenb_coef_intercept_shape(DiscreteNaiveBayes):
  function test_discretenb_degenerate_one_class_case (line 433) | def test_discretenb_degenerate_one_class_case(
  function test_mnnb (line 484) | def test_mnnb(kind):
  function test_mnb_prior_unobserved_targets (line 538) | def test_mnb_prior_unobserved_targets():
  function test_mnb_sample_weight (line 567) | def test_mnb_sample_weight():
  function test_bnb (line 575) | def test_bnb():
  function test_bnb_feature_log_prob (line 622) | def test_bnb_feature_log_prob():
  function test_cnb (line 645) | def test_cnb():
  function test_categoricalnb (line 716) | def test_categoricalnb():
  function test_categoricalnb_with_min_categories (line 800) | def test_categoricalnb_with_min_categories(
  function test_categoricalnb_min_categories_errors (line 825) | def test_categoricalnb_min_categories_errors(min_categories, error_msg):
  function test_alpha (line 835) | def test_alpha():
  function test_alpha_vector (line 900) | def test_alpha_vector():
  function test_check_accuracy_on_digits (line 942) | def test_check_accuracy_on_digits():
  function test_n_features_deprecation (line 977) | def test_n_features_deprecation(Estimator):

FILE: sklearn/tests/test_pipeline.py
  class NoFit (line 55) | class NoFit:
    method __init__ (line 58) | def __init__(self, a=None, b=None):
  class NoTrans (line 63) | class NoTrans(NoFit):
    method fit (line 64) | def fit(self, X, y):
    method get_params (line 67) | def get_params(self, deep=False):
    method set_params (line 70) | def set_params(self, **params):
  class NoInvTransf (line 75) | class NoInvTransf(NoTrans):
    method transform (line 76) | def transform(self, X):
  class Transf (line 80) | class Transf(NoInvTransf):
    method transform (line 81) | def transform(self, X):
    method inverse_transform (line 84) | def inverse_transform(self, X):
  class TransfFitParams (line 88) | class TransfFitParams(Transf):
    method fit (line 89) | def fit(self, X, y, **fit_params):
  class Mult (line 94) | class Mult(BaseEstimator):
    method __init__ (line 95) | def __init__(self, mult=1):
    method fit (line 98) | def fit(self, X, y):
    method transform (line 101) | def transform(self, X):
    method inverse_transform (line 104) | def inverse_transform(self, X):
    method predict (line 107) | def predict(self, X):
    method score (line 112) | def score(self, X, y=None):
  class FitParamT (line 116) | class FitParamT(BaseEstimator):
    method __init__ (line 119) | def __init__(self):
    method fit (line 122) | def fit(self, X, y, should_succeed=False):
    method predict (line 125) | def predict(self, X):
    method fit_predict (line 128) | def fit_predict(self, X, y, should_succeed=False):
    method score (line 132) | def score(self, X, y=None, sample_weight=None):
  class DummyTransf (line 138) | class DummyTransf(Transf):
    method fit (line 141) | def fit(self, X, y):
  class DummyEstimatorParams (line 149) | class DummyEstimatorParams(BaseEstimator):
    method fit (line 152) | def fit(self, X, y):
    method predict (line 155) | def predict(self, X, got_attribute=False):
    method predict_proba (line 159) | def predict_proba(self, X, got_attribute=False):
    method predict_log_proba (line 163) | def predict_log_proba(self, X, got_attribute=False):
  function test_pipeline_init (line 168) | def test_pipeline_init():
  function test_pipeline_init_tuple (line 249) | def test_pipeline_init_tuple():
  function test_pipeline_methods_anova (line 261) | def test_pipeline_methods_anova():
  function test_pipeline_fit_params (line 276) | def test_pipeline_fit_params():
  function test_pipeline_sample_weight_supported (line 292) | def test_pipeline_sample_weight_supported():
  function test_pipeline_sample_weight_unsupported (line 303) | def test_pipeline_sample_weight_unsupported():
  function test_pipeline_raise_set_params_error (line 316) | def test_pipeline_raise_set_params_error():
  function test_pipeline_methods_pca_svm (line 343) | def test_pipeline_methods_pca_svm():
  function test_pipeline_score_samples_pca_lof (line 358) | def test_pipeline_score_samples_pca_lof():
  function test_score_samples_on_pipeline_without_score_samples (line 374) | def test_score_samples_on_pipeline_without_score_samples():
  function test_pipeline_methods_preprocessing_svm (line 388) | def test_pipeline_methods_preprocessing_svm():
  function test_fit_predict_on_pipeline (line 418) | def test_fit_predict_on_pipeline():
  function test_fit_predict_on_pipeline_without_fit_predict (line 440) | def test_fit_predict_on_pipeline_without_fit_predict():
  function test_fit_predict_with_intermediate_fit_params (line 452) | def test_fit_predict_with_intermediate_fit_params():
  function test_predict_methods_with_predict_params (line 467) | def test_predict_methods_with_predict_params(method_name):
  function test_feature_union (line 478) | def test_feature_union():
  function test_make_union (line 525) | def test_make_union():
  function test_make_union_kwargs (line 534) | def test_make_union_kwargs():
  function test_pipeline_transform (line 549) | def test_pipeline_transform():
  function test_pipeline_fit_transform (line 568) | def test_pipeline_fit_transform():
  function test_pipeline_slice (line 584) | def test_pipeline_slice(start, end):
  function test_pipeline_index (line 612) | def test_pipeline_index():
  function test_set_pipeline_steps (line 630) | def test_set_pipeline_steps():
  function test_pipeline_named_steps (line 662) | def test_pipeline_named_steps():
  function test_pipeline_correctly_adjusts_steps (line 680) | def test_pipeline_correctly_adjusts_steps(passthrough):
  function test_set_pipeline_step_passthrough (line 698) | def test_set_pipeline_step_passthrough(passthrough):
  function test_pipeline_ducktyping (line 774) | def test_pipeline_ducktyping():
  function test_make_pipeline (line 802) | def test_make_pipeline():
  function test_feature_union_weights (line 817) | def test_feature_union_weights():
  function test_feature_union_parallel (line 850) | def test_feature_union_parallel():
  function test_feature_union_feature_names (line 898) | def test_feature_union_feature_names(get_names):
  function test_classes_property (line 915) | def test_classes_property():
  function test_set_feature_union_steps (line 934) | def test_set_feature_union_steps(get_names):
  function test_set_feature_union_step_drop (line 971) | def test_set_feature_union_step_drop(get_names):
  function test_set_feature_union_passthrough (line 1018) | def test_set_feature_union_passthrough():
  function test_step_name_validation (line 1072) | def test_step_name_validation():
  function test_set_params_nested_pipeline (line 1110) | def test_set_params_nested_pipeline():
  function test_pipeline_wrong_memory (line 1116) | def test_pipeline_wrong_memory():
  class DummyMemory (line 1133) | class DummyMemory:
    method cache (line 1134) | def cache(self, func):
  class WrongDummyMemory (line 1138) | class WrongDummyMemory:
  function test_pipeline_with_cache_attribute (line 1142) | def test_pipeline_with_cache_attribute():
  function test_pipeline_memory (line 1156) | def test_pipeline_memory():
  function test_make_pipeline_memory (line 1223) | def test_make_pipeline_memory():
  class FeatureNameSaver (line 1239) | class FeatureNameSaver(BaseEstimator):
    method fit (line 1240) | def fit(self, X, y=None):
    method transform (line 1244) | def transform(self, X, y=None):
    method get_feature_names_out (line 1247) | def get_feature_names_out(self, input_features=None):
  function test_features_names_passthrough (line 1251) | def test_features_names_passthrough():
  function test_feature_names_count_vectorizer (line 1267) | def test_feature_names_count_vectorizer():
  function test_pipeline_feature_names_out_error_without_definition (line 1282) | def test_pipeline_feature_names_out_error_without_definition():
  function test_pipeline_param_error (line 1294) | def test_pipeline_param_error():
  function test_verbose (line 1366) | def test_verbose(est, method, pattern, capsys):
  function test_n_features_in_pipeline (line 1381) | def test_n_features_in_pipeline():
  function test_n_features_in_feature_union (line 1404) | def test_n_features_in_feature_union():
  function test_feature_union_fit_params (line 1424) | def test_feature_union_fit_params():
  function test_pipeline_missing_values_leniency (line 1447) | def test_pipeline_missing_values_leniency():
  function test_feature_union_warns_unknown_transformer_weight (line 1457) | def test_feature_union_warns_unknown_transformer_weight():
  function test_feature_union_get_feature_names_deprecated (line 1476) | def test_feature_union_get_feature_names_deprecated():
  function test_pipeline_get_tags_none (line 1488) | def test_pipeline_get_tags_none(passthrough):
  function test_search_cv_using_minimal_compatible_estimator (line 1500) | def test_search_cv_using_minimal_compatible_estimator(Predictor):
  function test_pipeline_check_if_fitted (line 1520) | def test_pipeline_check_if_fitted():
  function test_pipeline_get_feature_names_out_passes_names_through (line 1533) | def test_pipeline_get_feature_names_out_passes_names_through():

FILE: sklearn/tests/test_random_projection.py
  function make_sparse_random_data (line 32) | def make_sparse_random_data(n_samples, n_features, n_nonzeros):
  function densify (line 47) | def densify(matrix):
  function test_invalid_jl_domain (line 67) | def test_invalid_jl_domain(n_samples, eps):
  function test_input_size_jl_min_dim (line 72) | def test_input_size_jl_min_dim():
  function check_input_size_random_matrix (line 84) | def check_input_size_random_matrix(random_matrix):
  function check_size_generated (line 91) | def check_size_generated(random_matrix):
  function check_zero_mean_and_unit_norm (line 100) | def check_zero_mean_and_unit_norm(random_matrix):
  function check_input_with_sparse_random_matrix (line 110) | def check_input_with_sparse_random_matrix(random_matrix):
  function test_basic_property_of_random_matrix (line 119) | def test_basic_property_of_random_matrix(random_matrix):
  function test_basic_property_of_sparse_random_matrix (line 127) | def test_basic_property_of_sparse_random_matrix(random_matrix):
  function test_gaussian_random_matrix (line 135) | def test_gaussian_random_matrix():
  function test_sparse_random_matrix (line 149) | def test_sparse_random_matrix():
  function test_sparse_random_projection_transformer_invalid_density (line 207) | def test_sparse_random_projection_transformer_invalid_density(density):
  function test_random_projection_transformer_invalid_input (line 214) | def test_random_projection_transformer_invalid_input(n_components, fit_d...
  function test_try_to_transform_before_fit (line 220) | def test_try_to_transform_before_fit():
  function test_too_many_samples_to_find_a_safe_embedding (line 226) | def test_too_many_samples_to_find_a_safe_embedding():
  function test_random_projection_embedding_quality (line 240) | def test_random_projection_embedding_quality():
  function test_SparseRandomProj_output_representation (line 270) | def test_SparseRandomProj_output_representation():
  function test_correct_RandomProjection_dimensions_embedding (line 291) | def test_correct_RandomProjection_dimensions_embedding():
  function test_warning_n_components_greater_than_n_features (line 333) | def test_warning_n_components_greater_than_n_features():
  function test_works_with_sparse_data (line 342) | def test_works_with_sparse_data():
  function test_johnson_lindenstrauss_min_dim (line 356) | def test_johnson_lindenstrauss_min_dim():
  function test_random_projection_feature_names_out (line 365) | def test_random_projection_feature_names_out(random_projection_cls):

FILE: sklearn/tree/_classes.py
  class BaseDecisionTree (line 88) | class BaseDecisionTree(MultiOutputMixin, BaseEstimator, metaclass=ABCMeta):
    method __init__ (line 96) | def __init__(
    method get_depth (line 125) | def get_depth(self):
    method get_n_leaves (line 139) | def get_n_leaves(self):
    method fit (line 150) | def fit(self, X, y, sample_weight=None, check_input=True):
    method _validate_X_predict (line 418) | def _validate_X_predict(self, X, check_input):
    method predict (line 431) | def predict(self, X, check_input=True):
    method apply (line 482) | def apply(self, X, check_input=True):
    method decision_path (line 510) | def decision_path(self, X, check_input=True):
    method _prune_tree (line 535) | def _prune_tree(self):
    method cost_complexity_pruning_path (line 560) | def cost_complexity_pruning_path(self, X, y, sample_weight=None):
    method feature_importances_ (line 600) | def feature_importances_(self):
  class DecisionTreeClassifier (line 627) | class DecisionTreeClassifier(ClassifierMixin, BaseDecisionTree):
    method __init__ (line 856) | def __init__(
    method fit (line 887) | def fit(self, X, y, sample_weight=None, check_input=True):
    method predict_proba (line 925) | def predict_proba(self, X, check_input=True):
    method predict_log_proba (line 973) | def predict_log_proba(self, X):
    method n_features_ (line 1006) | def n_features_(self):
    method _more_tags (line 1009) | def _more_tags(self):
  class DecisionTreeRegressor (line 1013) | class DecisionTreeRegressor(RegressorMixin, BaseDecisionTree):
    method __init__ (line 1228) | def __init__(
    method fit (line 1257) | def fit(self, X, y, sample_weight=None, check_input=True):
    method _compute_partial_dependence_recursion (line 1294) | def _compute_partial_dependence_recursion(self, grid, target_features):
    method n_features_ (line 1326) | def n_features_(self):
  class ExtraTreeClassifier (line 1330) | class ExtraTreeClassifier(DecisionTreeClassifier):
    method __init__ (line 1555) | def __init__(
  class ExtraTreeRegressor (line 1587) | class ExtraTreeRegressor(DecisionTreeRegressor):
    method __init__ (line 1791) | def __init__(

FILE: sklearn/tree/_export.py
  function _color_brew (line 28) | def _color_brew(n):
  class Sentinel (line 70) | class Sentinel:
    method __repr__ (line 71) | def __repr__(self):
  function plot_tree (line 78) | def plot_tree(
  class _BaseTreeExporter (line 198) | class _BaseTreeExporter:
    method __init__ (line 199) | def __init__(
    method get_color (line 225) | def get_color(self, value):
    method get_fill_color (line 248) | def get_fill_color(self, tree, node_id):
    method node_to_str (line 269) | def node_to_str(self, tree, node_id, criterion):
  class _DOTTreeExporter (line 383) | class _DOTTreeExporter(_BaseTreeExporter):
    method __init__ (line 384) | def __init__(
    method export (line 446) | def export(self, decision_tree):
    method tail (line 466) | def tail(self):
    method head (line 475) | def head(self):
    method recurse (line 502) | def recurse(self, tree, node_id, criterion, parent=None, depth=0):
  class _MPLTreeExporter (line 573) | class _MPLTreeExporter(_BaseTreeExporter):
    method __init__ (line 574) | def __init__(
    method _make_tree (line 629) | def _make_tree(self, node_id, et, criterion, depth=0):
    method export (line 648) | def export(self, decision_tree, ax=None):
    method recurse (line 696) | def recurse(self, node, tree, ax, scale_x, scale_y, height, depth=0):
  function export_graphviz (line 742) | def export_graphviz(
  function _compute_depth (line 900) | def _compute_depth(tree, node):
  function export_text (line 924) | def export_text(

FILE: sklearn/tree/_reingold_tilford.py
  class DrawTree (line 7) | class DrawTree:
    method __init__ (line 8) | def __init__(self, tree, parent=None, depth=0, number=1):
    method left (line 24) | def left(self):
    method right (line 27) | def right(self):
    method lbrother (line 30) | def lbrother(self):
    method get_lmost_sibling (line 40) | def get_lmost_sibling(self):
    method __str__ (line 47) | def __str__(self):
    method __repr__ (line 50) | def __repr__(self):
    method max_extents (line 53) | def max_extents(self):
  function buchheim (line 59) | def buchheim(tree):
  function third_walk (line 67) | def third_walk(tree, n):
  function first_walk (line 73) | def first_walk(v, distance=1.0):
  function apportion (line 98) | def apportion(v, default_ancestor, distance):
  function move_subtree (line 135) | def move_subtree(wl, wr, shift):
  function execute_shifts (line 147) | def execute_shifts(v):
  function ancestor (line 157) | def ancestor(vil, v, default_ancestor):
  function second_walk (line 168) | def second_walk(v, m=0, depth=0, min=None):
  class Tree (line 181) | class Tree:
    method __init__ (line 182) | def __init__(self, label="", node_id=-1, *children):

FILE: sklearn/tree/setup.py
  function configuration (line 7) | def configuration(parent_package="", top_path=None):

FILE: sklearn/tree/tests/test_export.py
  function test_graphviz_toy (line 25) | def test_graphviz_toy():
  function test_graphviz_errors (line 252) | def test_graphviz_errors():
  function test_friedman_mse_in_graphviz (line 291) | def test_friedman_mse_in_graphviz():
  function test_precision (line 306) | def test_precision():
  function test_export_text_errors (line 350) | def test_export_text_errors():
  function test_export_text (line 368) | def test_export_text():
  function test_plot_tree_entropy (line 467) | def test_plot_tree_entropy(pyplot):
  function test_plot_tree_gini (line 487) | def test_plot_tree_gini(pyplot):
  function test_not_fitted_tree (line 507) | def test_not_fitted_tree(pyplot):

FILE: sklearn/tree/tests/test_reingold_tilford.py
  function test_buchheim (line 21) | def test_buchheim(tree, n_nodes):

FILE: sklearn/tree/tests/test_tree.py
  function assert_tree_equal (line 193) | def assert_tree_equal(d, s, message):
  function test_classification_toy (line 232) | def test_classification_toy():
  function test_weighted_classification_toy (line 244) | def test_weighted_classification_toy():
  function test_regression_toy (line 258) | def test_regression_toy(Tree, criterion):
  function test_xor (line 279) | def test_xor():
  function test_iris (line 300) | def test_iris():
  function test_diabetes_overfit (line 320) | def test_diabetes_overfit(name, Tree, criterion):
  function test_diabetes_underfit (line 342) | def test_diabetes_underfit(name, Tree, criterion, max_depth, metric, max...
  function test_probability (line 352) | def test_probability():
  function test_arrayrepr (line 378) | def test_arrayrepr():
  function test_pure_set (line 389) | def test_pure_set():
  function test_numerical_stability (line 405) | def test_numerical_stability():
  function test_importances (line 430) | def test_importances():
  function test_importances_raises (line 461) | def test_importances_raises():
  function test_importances_gini_equal_squared_error (line 468) | def test_importances_gini_equal_squared_error():
  function test_max_features (line 498) | def test_max_features():
  function test_error (line 565) | def test_error():
  function test_min_samples_split (line 659) | def test_min_samples_split():
  function test_min_samples_leaf (line 690) | def test_min_samples_leaf():
  function check_min_weight_fraction_leaf (line 723) | def check_min_weight_fraction_leaf(name, datasets, sparse=False):
  function test_min_weight_fraction_leaf_on_dense_input (line 785) | def test_min_weight_fraction_leaf_on_dense_input(name):
  function test_min_weight_fraction_leaf_on_sparse_input (line 790) | def test_min_weight_fraction_leaf_on_sparse_input(name):
  function check_min_weight_fraction_leaf_with_min_samples_leaf (line 794) | def check_min_weight_fraction_leaf_with_min_samples_leaf(name, datasets,...
  function test_min_weight_fraction_leaf_with_min_samples_leaf_on_dense_input (line 855) | def test_min_weight_fraction_leaf_with_min_samples_leaf_on_dense_input(n...
  function test_min_weight_fraction_leaf_with_min_samples_leaf_on_sparse_input (line 860) | def test_min_weight_fraction_leaf_with_min_samples_leaf_on_sparse_input(...
  function test_min_impurity_decrease (line 864) | def test_min_impurity_decrease():
  function test_multioutput (line 964) | def test_multioutput():
  function test_classes_shape (line 1024) | def test_classes_shape():
  function test_unbalanced_iris (line 1044) | def test_unbalanced_iris():
  function test_memory_layout (line 1056) | def test_memory_layout():
  function test_sample_weight (line 1099) | def test_sample_weight():
  function test_sample_weight_invalid (line 1151) | def test_sample_weight_invalid():
  function check_class_weights (line 1169) | def check_class_weights(name):
  function test_class_weights (line 1217) | def test_class_weights(name):
  function check_class_weight_errors (line 1221) | def check_class_weight_errors(name):
  function test_class_weight_errors (line 1245) | def test_class_weight_errors(name):
  function test_max_leaf_nodes (line 1249) | def test_max_leaf_nodes():
  function test_max_leaf_nodes_max_depth (line 1269) | def test_max_leaf_nodes_max_depth():
  function test_arrays_persist (line 1278) | def test_arrays_persist():
  function test_only_constant_features (line 1296) | def test_only_constant_features():
  function test_behaviour_constant_feature_after_splits (line 1306) | def test_behaviour_constant_feature_after_splits():
  function test_with_only_one_non_constant_features (line 1320) | def test_with_only_one_non_constant_features():
  function test_big_input (line 1337) | def test_big_input():
  function test_realloc (line 1347) | def test_realloc():
  function test_huge_allocations (line 1354) | def test_huge_allocations():
  function check_sparse_input (line 1375) | def check_sparse_input(tree, dataset, max_depth=None):
  function test_sparse_input (line 1432) | def test_sparse_input(tree_type, dataset):
  function test_sparse_input_reg_trees (line 1439) | def test_sparse_input_reg_trees(tree_type, dataset):
  function check_sparse_parameters (line 1445) | def check_sparse_parameters(tree, dataset):
  function check_sparse_criterion (line 1496) | def check_sparse_criterion(tree, dataset):
  function test_sparse (line 1521) | def test_sparse(tree_type, dataset, check):
  function check_explicit_sparse_zeros (line 1525) | def check_explicit_sparse_zeros(tree, max_depth=3, n_features=10):
  function test_explicit_sparse_zeros (line 1596) | def test_explicit_sparse_zeros(tree_type):
  function check_raise_error_on_1d_input (line 1601) | def check_raise_error_on_1d_input(name):
  function test_1d_input (line 1618) | def test_1d_input(name):
  function _check_min_weight_leaf_split_level (line 1623) | def _check_min_weight_leaf_split_level(TreeEstimator, X, y, sample_weight):
  function check_min_weight_leaf_split_level (line 1633) | def check_min_weight_leaf_split_level(name):
  function test_min_weight_leaf_split_level (line 1645) | def test_min_weight_leaf_split_level(name):
  function check_public_apply (line 1649) | def check_public_apply(name):
  function check_public_apply_sparse (line 1657) | def check_public_apply_sparse(name):
  function test_public_apply_all_trees (line 1666) | def test_public_apply_all_trees(name):
  function test_public_apply_sparse_trees (line 1671) | def test_public_apply_sparse_trees(name):
  function test_decision_path_hardcoded (line 1675) | def test_decision_path_hardcoded():
  function check_decision_path (line 1683) | def check_decision_path(name):
  function test_decision_path (line 1713) | def test_decision_path(name):
  function check_no_sparse_y_support (line 1717) | def check_no_sparse_y_support(name):
  function test_no_sparse_y_support (line 1725) | def test_no_sparse_y_support(name):
  function test_mae (line 1730) | def test_mae():
  function test_criterion_copy (line 1830) | def test_criterion_copy():
  function test_empty_leaf_infinite_threshold (line 1858) | def test_empty_leaf_infinite_threshold():
  function test_prune_tree_classifier_are_subtrees (line 1880) | def test_prune_tree_classifier_are_subtrees(criterion, dataset, tree_cls):
  function test_prune_tree_regression_are_subtrees (line 1897) | def test_prune_tree_regression_are_subtrees(criterion, dataset, tree_cls):
  function test_prune_single_node_tree (line 1912) | def test_prune_single_node_tree():
  function assert_pruning_creates_subtree (line 1924) | def assert_pruning_creates_subtree(estimator_cls, X, y, pruning_path):
  function assert_is_subtree (line 1939) | def assert_is_subtree(tree, subtree):
  function test_prune_tree_raises_negative_ccp_alpha (line 1979) | def test_prune_tree_raises_negative_ccp_alpha():
  function check_apply_path_readonly (line 1995) | def check_apply_path_readonly(name):
  function test_apply_path_readonly_all_trees (line 2007) | def test_apply_path_readonly_all_trees(name):
  function test_balance_property (line 2013) | def test_balance_property(criterion, Tree):
  function test_poisson_zero_nodes (line 2026) | def test_poisson_zero_nodes(seed):
  function test_poisson_vs_mse (line 2059) | def test_poisson_vs_mse():
  function test_decision_tree_regressor_sample_weight_consistentcy (line 2104) | def test_decision_tree_regressor_sample_weight_consistentcy(criterion):
  function test_criterion_deprecated (line 2150) | def test_criterion_deprecated(Tree, old_criterion, new_criterion):
  function test_n_features_deprecated (line 2163) | def test_n_features_deprecated(Tree):
  function test_different_endianness_pickle (line 2175) | def test_different_endianness_pickle():
  function test_different_endianness_joblib_pickle (line 2204) | def test_different_endianness_joblib_pickle():

FILE: sklearn/utils/__init__.py
  class Bunch (line 84) | class Bunch(dict):
    method __init__ (line 107) | def __init__(self, **kwargs):
    method __setattr__ (line 110) | def __setattr__(self, key, value):
    method __dir__ (line 113) | def __dir__(self):
    method __getattr__ (line 116) | def __getattr__(self, key):
    method __setstate__ (line 122) | def __setstate__(self, state):
  function safe_mask (line 134) | def safe_mask(X, mask):
  function axis0_safe_slice (line 159) | def axis0_safe_slice(X, mask, len_mask):
  function _array_indexing (line 194) | def _array_indexing(array, key, key_dtype, axis):
  function _pandas_indexing (line 206) | def _pandas_indexing(X, key, key_dtype, axis):
  function _list_indexing (line 226) | def _list_indexing(X, key, key_dtype):
  function _determine_key_type (line 238) | def _determine_key_type(key, accept_slice=True):
  function _safe_indexing (line 308) | def _safe_indexing(X, indices, *, axis=0):
  function _get_column_indices (line 384) | def _get_column_indices(X, key):
  function resample (line 453) | def resample(*arrays, replace=True, n_samples=None, random_state=None, s...
  function shuffle (line 603) | def shuffle(*arrays, random_state=None, n_samples=None):
  function safe_sqr (line 674) | def safe_sqr(X, *, copy=True):
  function _chunk_generator (line 702) | def _chunk_generator(gen, chunksize):
  function gen_batches (line 713) | def gen_batches(n, batch_size, *, min_batch_size=0):
  function gen_even_slices (line 766) | def gen_even_slices(n, n_packs, *, n_samples=None):
  function tosequence (line 815) | def tosequence(x):
  function _to_object_array (line 830) | def _to_object_array(sequence):
  function indices_to_mask (line 866) | def indices_to_mask(indices, mask_length):
  function _message_with_time (line 898) | def _message_with_time(source, message, time):
  function _print_elapsed_time (line 926) | def _print_elapsed_time(source, message=None):
  function get_chunk_n_rows (line 950) | def get_chunk_n_rows(row_bytes, *, max_n_rows=None, working_memory=None):
  function _is_pandas_na (line 990) | def _is_pandas_na(x):
  function is_scalar_nan (line 1014) | def is_scalar_nan(x):
  function _approximate_mode (line 1046) | def _approximate_mode(class_counts, n_draws, rng):
  function check_matplotlib_support (line 1115) | def check_matplotlib_support(caller_name):
  function check_pandas_support (line 1135) | def check_pandas_support(caller_name):
  function all_estimators (line 1159) | def all_estimators(type_filter=None):

FILE: sklearn/utils/_arpack.py
  function _init_arpack_v0 (line 4) | def _init_arpack_v0(size, random_state):

FILE: sklearn/utils/_encode.py
  function _unique (line 7) | def _unique(values, *, return_inverse=False):
  class MissingValues (line 53) | class MissingValues(NamedTuple):
    method to_list (line 59) | def to_list(self):
  function _extract_missing (line 69) | def _extract_missing(values):
  class _nandict (line 107) | class _nandict(dict):
    method __init__ (line 110) | def __init__(self, mapping):
    method __missing__ (line 117) | def __missing__(self, key):
  function _map_to_integer (line 123) | def _map_to_integer(values, uniques):
  function _unique_python (line 129) | def _unique_python(values, *, return_inverse):
  function _encode (line 151) | def _encode(values, *, uniques, check_unknown=True):
  function _check_unknown (line 193) | def _check_unknown(values, known_values, return_mask=False):

FILE: sklearn/utils/_estimator_html_repr.py
  class _VisualBlock (line 11) | class _VisualBlock:
    method __init__ (line 39) | def __init__(
    method _sk_visual_block_ (line 55) | def _sk_visual_block_(self):
  function _write_label_html (line 59) | def _write_label_html(
  function _get_visual_block (line 88) | def _get_visual_block(estimator):
  function _write_estimator_html (line 118) | def _write_estimator_html(
  function estimator_html_repr (line 323) | def estimator_html_repr(estimator):

FILE: sklearn/utils/_mask.py
  function _get_dense_mask (line 9) | def _get_dense_mask(X, value_to_mask):
  function _get_mask (line 33) | def _get_mask(X, value_to_mask):

FILE: sklearn/utils/_mocking.py
  class ArraySlicingWrapper (line 7) | class ArraySlicingWrapper:
    method __init__ (line 14) | def __init__(self, array):
    method __getitem__ (line 17) | def __getitem__(self, aslice):
  class MockDataFrame (line 21) | class MockDataFrame:
    method __init__ (line 30) | def __init__(self, array):
    method __len__ (line 38) | def __len__(self):
    method __array__ (line 41) | def __array__(self, dtype=None):
    method __eq__ (line 47) | def __eq__(self, other):
    method __ne__ (line 50) | def __ne__(self, other):
    method take (line 53) | def take(self, indices, axis=0):
  class CheckingClassifier (line 57) | class CheckingClassifier(ClassifierMixin, BaseEstimator):
    method __init__ (line 118) | def __init__(
    method _check_X_y (line 137) | def _check_X_y(self, X, y=None, should_be_fitted=True):
    method fit (line 172) | def fit(self, X, y, **fit_params):
    method predict (line 213) | def predict(self, X):
    method predict_proba (line 230) | def predict_proba(self, X):
    method decision_function (line 252) | def decision_function(self, X):
    method score (line 280) | def score(self, X=None, Y=None):
    method _more_tags (line 307) | def _more_tags(self):
  class NoSampleWeightWrapper (line 311) | class NoSampleWeightWrapper(BaseEstimator):
    method __init__ (line 320) | def __init__(self, est=None):
    method fit (line 323) | def fit(self, X, y):
    method predict (line 326) | def predict(self, X):
    method predict_proba (line 329) | def predict_proba(self, X):
    method _more_tags (line 332) | def _more_tags(self):

FILE: sklearn/utils/_pprint.py
  class KeyValTuple (line 75) | class KeyValTuple(tuple):
    method __repr__ (line 78) | def __repr__(self):
  class KeyValTupleParam (line 83) | class KeyValTupleParam(KeyValTuple):
  function _changed_params (line 89) | def _changed_params(estimator):
  class _EstimatorPrettyPrinter (line 116) | class _EstimatorPrettyPrinter(pprint.PrettyPrinter):
    method __init__ (line 167) | def __init__(
    method format (line 188) | def format(self, object, context, maxlevels, level):
    method _pprint_estimator (line 193) | def _pprint_estimator(self, object, stream, indent, allowance, context...
    method _format_dict_items (line 210) | def _format_dict_items(self, items, stream, indent, allowance, context...
    method _format_params (line 215) | def _format_params(self, items, stream, indent, allowance, context, le...
    method _format_params_or_dict_items (line 220) | def _format_params_or_dict_items(
    method _format_items (line 283) | def _format_items(self, items, stream, indent, allowance, context, lev...
    method _pprint_key_val_tuple (line 331) | def _pprint_key_val_tuple(self, object, stream, indent, allowance, con...
  function _safe_repr (line 355) | def _safe_repr(object, context, maxlevels, level, changed_only=False):

FILE: sklearn/utils/_show_versions.py
  function _get_sys_info (line 17) | def _get_sys_info():
  function _get_deps_info (line 37) | def _get_deps_info():
  function show_versions (line 78) | def show_versions():

FILE: sklearn/utils/_tags.py
  function _safe_tags (line 25) | def _safe_tags(estimator, key=None):

FILE: sklearn/utils/_testing.py
  function assert_warns (line 90) | def assert_warns(warning_class, func, *args, **kw):
  function assert_warns_message (line 141) | def assert_warns_message(warning_class, message, func, *args, **kw):
  function assert_no_warnings (line 217) | def assert_no_warnings(func, *args, **kw):
  function ignore_warnings (line 242) | def ignore_warnings(obj=None, category=Warning):
  class _IgnoreWarnings (line 286) | class _IgnoreWarnings:
    method __init__ (line 299) | def __init__(self, category):
    method __call__ (line 306) | def __call__(self, fn):
    method __repr__ (line 317) | def __repr__(self):
    method __enter__ (line 326) | def __enter__(self):
    method __exit__ (line 335) | def __exit__(self, *exc_info):
  function assert_raise_message (line 343) | def assert_raise_message(exceptions, message, function, *args, **kwargs):
  function assert_allclose_dense_sparse (line 385) | def assert_allclose_dense_sparse(x, y, rtol=1e-07, atol=1e-9, err_msg=""):
  function set_random_state (line 427) | def set_random_state(estimator, random_state=0):
  function check_skip_network (line 481) | def check_skip_network():
  function _delete_folder (line 486) | def _delete_folder(folder_path, warn=False):
  class TempMemmap (line 501) | class TempMemmap:
    method __init__ (line 509) | def __init__(self, data, mmap_mode="r"):
    method __enter__ (line 513) | def __enter__(self):
    method __exit__ (line 519) | def __exit__(self, exc_type, exc_val, exc_tb):
  function create_memmap_backed_data (line 523) | def create_memmap_backed_data(data, mmap_mode="r", return_folder=False, ...
  function _get_args (line 562) | def _get_args(function, varargs=False):
  function _get_func_name (line 588) | def _get_func_name(func):
  function check_docstring_parameters (line 614) | def check_docstring_parameters(func, doc=None, ignore=None):
  function assert_run_python_script (line 750) | def assert_run_python_script(source_code, timeout=60):
  function _convert_container (line 801) | def _convert_container(container, constructor_name, columns_name=None, d...
  function raises (line 853) | def raises(expected_exc_type, match=None, may_pass=False, err_msg=None):
  class _Raises (line 893) | class _Raises(contextlib.AbstractContextManager):
    method __init__ (line 895) | def __init__(self, expected_exc_type, match, may_pass, err_msg):
    method __exit__ (line 906) | def __exit__(self, exc_type, exc_value, _):
  class MinimalClassifier (line 938) | class MinimalClassifier:
    method __init__ (line 950) | def __init__(self, param=None):
    method get_params (line 953) | def get_params(self, deep=True):
    method set_params (line 956) | def set_params(self, **params):
    method fit (line 961) | def fit(self, X, y):
    method predict_proba (line 968) | def predict_proba(self, X):
    method predict (line 976) | def predict(self, X):
    method score (line 981) | def score(self, X, y):
  class MinimalRegressor (line 987) | class MinimalRegressor:
    method __init__ (line 999) | def __init__(self, param=None):
    method get_params (line 1002) | def get_params(self, deep=True):
    method set_params (line 1005) | def set_params(self, **params):
    method fit (line 1010) | def fit(self, X, y):
    method predict (line 1016) | def predict(self, X):
    method score (line 1021) | def score(self, X, y):
  class MinimalTransformer (line 1027) | class MinimalTransformer:
    method __init__ (line 1038) | def __init__(self, param=None):
    method get_params (line 1041) | def get_params(self, deep=True):
    method set_params (line 1044) | def set_params(self, **params):
    method fit (line 1049) | def fit(self, X, y=None):
    method transform (line 1054) | def transform(self, X, y=None):
    method fit_transform (line 1059) | def fit_transform(self, X, y=None):

FILE: sklearn/utils/class_weight.py
  function compute_class_weight (line 8) | def compute_class_weight(class_weight, *, classes, y):
  function compute_sample_weight (line 71) | def compute_sample_weight(class_weight, y, *, indices=None):

FILE: sklearn/utils/deprecation.py
  class deprecated (line 8) | class deprecated:
    method __init__ (line 34) | def __init__(self, extra=""):
    method __call__ (line 37) | def __call__(self, obj):
    method _decorate_class (line 58) | def _decorate_class(self, cls):
    method _decorate_fun (line 78) | def _decorate_fun(self, fun):
    method _decorate_property (line 97) | def _decorate_property(self, prop):
    method _update_doc (line 110) | def _update_doc(self, olddoc):
  function _is_deprecated (line 119) | def _is_deprecated(func):

FILE: sklearn/utils/estimator_checks.py
  function _yield_checks (line 78) | def _yield_checks(estimator):
  function _yield_classifier_checks (line 131) | def _yield_classifier_checks(classifier):
  function check_supervised_y_no_nan (line 167) | def check_supervised_y_no_nan(name, estimator_orig):
  function _yield_regressor_checks (line 201) | def _yield_regressor_checks(regressor):
  function _yield_transformer_checks (line 226) | def _yield_transformer_checks(transformer):
  function _yield_clustering_checks (line 254) | def _yield_clustering_checks(clusterer):
  function _yield_outliers_checks (line 266) | def _yield_outliers_checks(estimator):
  function _yield_all_checks (line 283) | def _yield_all_checks(estimator):
  function _get_check_estimator_ids (line 339) | def _get_check_estimator_ids(obj):
  function _construct_instance (line 377) | def _construct_instance(Estimator):
  function _maybe_mark_xfail (line 418) | def _maybe_mark_xfail(estimator, check, pytest):
  function _maybe_skip (line 431) | def _maybe_skip(estimator, check):
  function _should_be_skipped_or_marked (line 452) | def _should_be_skipped_or_marked(estimator, check):
  function parametrize_with_checks (line 468) | def parametrize_with_checks(estimators):
  function check_estimator (line 530) | def check_estimator(Estimator, generate_only=False):
  function _regression_dataset (line 605) | def _regression_dataset():
  function _set_checking_parameters (line 621) | def _set_checking_parameters(estimator):
  class _NotAnArray (line 711) | class _NotAnArray:
    method __init__ (line 720) | def __init__(self, data):
    method __array__ (line 723) | def __array__(self, dtype=None):
    method __array_function__ (line 726) | def __array_function__(self, func, types, args, kwargs):
  function _is_pairwise_metric (line 732) | def _is_pairwise_metric(estimator):
  function _pairwise_estimator_convert_X (line 750) | def _pairwise_estimator_convert_X(X, estimator, kernel=linear_kernel):
  function _generate_sparse_matrix (line 760) | def _generate_sparse_matrix(X_csr):
  function check_estimator_sparse_data (line 793) | def check_estimator_sparse_data(name, estimator_orig):
  function check_sample_weights_pandas_series (line 848) | def check_sample_weights_pandas_series(name, estimator_orig):
  function check_sample_weights_not_an_array (line 892) | def check_sample_weights_not_an_array(name, estimator_orig):
  function check_sample_weights_list (line 921) | def check_sample_weights_list(name, estimator_orig):
  function check_sample_weights_shape (line 936) | def check_sample_weights_shape(name, estimator_orig):
  function check_sample_weights_invariance (line 973) | def check_sample_weights_invariance(name, estimator_orig, kind="ones"):
  function check_sample_weights_not_overwritten (line 1041) | def check_sample_weights_not_overwritten(name, estimator_orig):
  function check_dtype_object (line 1082) | def check_dtype_object(name, estimator_orig):
  function check_complex_data (line 1115) | def check_complex_data(name, estimator_orig):
  function check_dict_unchanged (line 1130) | def check_dict_unchanged(name, estimator_orig):
  function _is_public_parameter (line 1169) | def _is_public_parameter(attr):
  function check_dont_overwrite_parameters (line 1174) | def check_dont_overwrite_parameters(name, estimator_orig):
  function check_fit2d_predict1d (line 1233) | def check_fit2d_predict1d(name, estimator_orig):
  function _apply_on_subsets (line 1257) | def _apply_on_subsets(func, X):
  function check_methods_subset_invariance (line 1276) | def check_methods_subset_invariance(name, estimator_orig):
  function check_methods_sample_order_invariance (line 1314) | def check_methods_sample_order_invariance(name, estimator_orig):
  function check_fit2d_1sample (line 1358) | def check_fit2d_1sample(name, estimator_orig):
  function check_fit2d_1feature (line 1395) | def check_fit2d_1feature(name, estimator_orig):
  function check_fit1d (line 1426) | def check_fit1d(name, estimator_orig):
  function check_transformer_general (line 1445) | def check_transformer_general(name, transformer, readonly_memmap=False):
  function check_transformer_data_not_an_array (line 1464) | def check_transformer_data_not_an_array(name, transformer):
  function check_transformers_unfitted (line 1485) | def check_transformers_unfitted(name, transformer):
  function _check_transformer (line 1501) | def _check_transformer(name, transformer_orig, X, y):
  function check_pipeline_consistency (line 1594) | def check_pipeline_consistency(name, estimator_orig):
  function check_fit_score_takes_y (line 1628) | def check_fit_score_takes_y(name, estimator_orig):
  function check_estimators_dtypes (line 1658) | def check_estimators_dtypes(name, estimator_orig):
  function check_transformer_preserve_dtypes (line 1680) | def check_transformer_preserve_dtypes(name, transformer_orig):
  function check_estimators_empty_data_messages (line 1712) | def check_estimators_empty_data_messages(name, estimator_orig):
  function check_estimators_nan_inf (line 1736) | def check_estimators_nan_inf(name, estimator_orig):
  function check_nonsquare_error (line 1785) | def check_nonsquare_error(name, estimator_orig):
  function check_estimators_pickle (line 1801) | def check_estimators_pickle(name, estimator_orig):
  function check_estimators_partial_fit_n_features (line 1854) | def check_estimators_partial_fit_n_features(name, estimator_orig):
  function check_classifier_multioutput (line 1883) | def check_classifier_multioutput(name, estimator):
  function check_regressor_multioutput (line 1944) | def check_regressor_multioutput(name, estimator):
  function check_clustering (line 1970) | def check_clustering(name, clusterer_orig, readonly_memmap=False):
  function check_clusterer_compute_labels_predict (line 2030) | def check_clusterer_compute_labels_predict(name, clusterer_orig):
  function check_classifiers_one_label (line 2045) | def check_classifiers_one_label(name, classifier_orig):
  function check_classifiers_train (line 2068) | def check_classifiers_train(
  function check_outlier_corruption (line 2218) | def check_outlier_corruption(num_outliers, expected_outliers, decision):
  function check_outliers_train (line 2240) | def check_outliers_train(name, estimator_orig, readonly_memmap=True):
  function check_classifiers_multilabel_representation_invariance (line 2320) | def check_classifiers_multilabel_representation_invariance(name, classif...
  function check_classifiers_multilabel_output_format_predict (line 2361) | def check_classifiers_multilabel_output_format_predict(name, classifier_...
  function check_classifiers_multilabel_output_format_predict_proba (line 2406) | def check_classifiers_multilabel_output_format_predict_proba(name, class...
  function check_classifiers_multilabel_output_format_decision_function (line 2490) | def check_classifiers_multilabel_output_format_decision_function(name, c...
  function check_estimators_fit_returns_self (line 2536) | def check_estimators_fit_returns_self(name, estimator_orig, readonly_mem...
  function check_estimators_unfitted (line 2554) | def check_estimators_unfitted(name, estimator_orig):
  function check_supervised_y_2d (line 2575) | def check_supervised_y_2d(name, estimator_orig):
  function check_classifiers_predictions (line 2611) | def check_classifiers_predictions(X, y, name, classifier_orig):
  function _choose_check_classifiers_labels (line 2671) | def _choose_check_classifiers_labels(name, y, y_names):
  function check_classifiers_classes (line 2681) | def check_classifiers_classes(name, classifier_orig):
  function check_regressors_int (line 2719) | def check_regressors_int(name, regressor_orig):
  function check_regressors_train (line 2747) | def check_regressors_train(
  function check_regressors_no_decision_function (line 2798) | def check_regressors_no_decision_function(name, regressor_orig):
  function check_class_weight_classifiers (line 2815) | def check_class_weight_classifiers(name, classifier_orig):
  function check_class_weight_balanced_classifiers (line 2861) | def check_class_weight_balanced_classifiers(
  function check_class_weight_balanced_linear_classifier (line 2883) | def check_class_weight_balanced_linear_classifier(name, Classifier):
  function check_estimators_overwrite_params (line 2924) | def check_estimators_overwrite_params(name, estimator_orig):
  function check_no_attributes_set_in_init (line 2960) | def check_no_attributes_set_in_init(name, estimator_orig):
  function check_sparsify_coefficients (line 2996) | def check_sparsify_coefficients(name, estimator_orig):
  function check_classifier_data_not_an_array (line 3031) | def check_classifier_data_not_an_array(name, estimator_orig):
  function check_regressor_data_not_an_array (line 3056) | def check_regressor_data_not_an_array(name, estimator_orig):
  function check_estimators_data_not_an_array (line 3065) | def check_estimators_data_not_an_array(name, estimator_orig, X, y, obj_t...
  function check_parameters_default_constructible (line 3111) | def check_parameters_default_constructible(name, Estimator):
  function _enforce_estimator_tags_y (line 3209) | def _enforce_estimator_tags_y(estimator, y):
  function _enforce_estimator_tags_x (line 3226) | def _enforce_estimator_tags_x(estimator, X):
  function check_non_transformer_estimators_n_iter (line 3245) | def check_non_transformer_estimators_n_iter(name, estimator_orig):
  function check_transformer_n_iter (line 3290) | def check_transformer_n_iter(name, estimator_orig):
  function check_get_params_invariance (line 3321) | def check_get_params_invariance(name, estimator_orig):
  function check_set_params (line 3332) | def check_set_params(name, estimator_orig):
  function check_classifiers_regression_target (line 3389) | def check_classifiers_regression_target(name, estimator_orig):
  function check_decision_proba_consistency (line 3403) | def check_decision_proba_consistency(name, estimator_orig):
  function check_outliers_fit_predict (line 3434) | def check_outliers_fit_predict(name, estimator_orig):
  function check_fit_non_negative (line 3484) | def check_fit_non_negative(name, estimator_orig):
  function check_fit_idempotent (line 3494) | def check_fit_idempotent(name, estimator_orig):
  function check_fit_check_is_fitted (line 3552) | def check_fit_check_is_fitted(name, estimator_orig):
  function check_n_features_in (line 3591) | def check_n_features_in(name, estimator_orig):
  function check_requires_y_none (line 3629) | def check_requires_y_none(name, estimator_orig):
  function check_n_features_in_after_fitting (line 3664) | def check_n_features_in_after_fitting(name, estimator_orig):
  function check_estimator_get_tags_default_keys (line 3733) | def check_estimator_get_tags_default_keys(name, estimator_orig):
  function check_dataframe_column_names_consistency (line 3748) | def check_dataframe_column_names_consistency(name, estimator_orig):
  function check_transformer_get_feature_names_out (line 3886) | def check_transformer_get_feature_names_out(name, transformer_orig):
  function check_transformer_get_feature_names_out_pandas (line 3935) | def check_transformer_get_feature_names_out_pandas(name, transformer_orig):

FILE: sklearn/utils/extmath.py
  function squared_norm (line 26) | def squared_norm(x):
  function row_norms (line 51) | def row_norms(X, squared=False):
  function fast_logdet (line 83) | def fast_logdet(A):
  function density (line 100) | def density(w, **kwargs):
  function safe_sparse_dot (line 120) | def safe_sparse_dot(a, b, *, dense_output=False):
  function randomized_range_finder (line 165) | def randomized_range_finder(
  function randomized_svd (line 249) | def randomized_svd(
  function _randomized_eigsh (line 427) | def _randomized_eigsh(
  function weighted_mode (line 582) | def weighted_mode(a, w, *, axis=0):
  function cartesian (line 655) | def cartesian(arrays, out=None):
  function svd_flip (line 708) | def svd_flip(u, v, u_based_decision=True):
  function log_logistic (line 754) | def log_logistic(X, out=None):
  function softmax (line 799) | def softmax(X, copy=True):
  function make_nonnegative (line 833) | def make_nonnegative(X, min_value=0):
  function _safe_accumulator_op (line 869) | def _safe_accumulator_op(op, x, *args, **kwargs):
  function _incremental_mean_and_var (line 899) | def _incremental_mean_and_var(
  function _deterministic_vector_sign_flip (line 1041) | def _deterministic_vector_sign_flip(u):
  function stable_cumsum (line 1063) | def stable_cumsum(arr, axis=None, rtol=1e-05, atol=1e-08):

FILE: sklearn/utils/fixes.py
  function _object_dtype_isnan (line 45) | def _object_dtype_isnan(X):
  function _astype_copy_false (line 50) | def _astype_copy_false(X):
  function _joblib_parallel_args (line 61) | def _joblib_parallel_args(**kwargs):
  class loguniform (line 113) | class loguniform(scipy.stats.reciprocal):
  function _take_along_axis (line 162) | def _take_along_axis(arr, indices, axis):
  function delayed (line 196) | def delayed(function):
  class _FuncWrapper (line 206) | class _FuncWrapper:
    method __init__ (line 209) | def __init__(self, function):
    method __call__ (line 214) | def __call__(self, *args, **kwargs):
  function linspace (line 219) | def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=No...
  function _get_threadpool_controller (line 287) | def _get_threadpool_controller():
  function threadpool_limits (line 297) | def threadpool_limits(limits=None, user_api=None):
  function threadpool_info (line 308) | def threadpool_info():

FILE: sklearn/utils/graph.py
  function single_source_shortest_path_length (line 23) | def single_source_shortest_path_length(graph, source, *, cutoff=None):
  function graph_shortest_path (line 78) | def graph_shortest_path(dist_matrix, directed=True, method="auto"):
  function _fix_connected_components (line 121) | def _fix_connected_components(

FILE: sklearn/utils/metaestimators.py
  class _BaseComposition (line 19) | class _BaseComposition(BaseEstimator, metaclass=ABCMeta):
    method __init__ (line 25) | def __init__(self):
    method _get_params (line 28) | def _get_params(self, attr, deep=True):
    method _set_params (line 50) | def _set_params(self, attr, **params):
    method _replace_estimator (line 68) | def _replace_estimator(self, attr, name, new_val):
    method _validate_names (line 77) | def _validate_names(self, names):
  class _AvailableIfDescriptor (line 94) | class _AvailableIfDescriptor:
    method __init__ (line 105) | def __init__(self, fn, check, attribute_name):
    method __get__ (line 113) | def __get__(self, obj, owner=None):
  function available_if (line 140) | def available_if(check):
  class _IffHasAttrDescriptor (line 176) | class _IffHasAttrDescriptor(_AvailableIfDescriptor):
    method __init__ (line 192) | def __init__(self, fn, delegate_names, attribute_name):
    method _check (line 196) | def _check(self, obj):
  function if_delegate_has_method (line 213) | def if_delegate_has_method(delegate):
  function _safe_split (line 235) | def _safe_split(estimator, X, y, indices, train_indices=None):

FILE: sklearn/utils/multiclass.py
  function _unique_multiclass (line 22) | def _unique_multiclass(y):
  function _unique_indicator (line 29) | def _unique_indicator(y):
  function unique_labels (line 42) | def unique_labels(*ys):
  function _is_integral_float (line 114) | def _is_integral_float(y):
  function is_multilabel (line 118) | def is_multilabel(y):
  function check_classification_targets (line 180) | def check_classification_targets(y):
  function type_of_target (line 202) | def type_of_target(y, input_name=""):
  function _check_partial_fit_first_call (line 340) | def _check_partial_fit_first_call(clf, classes=None):
  function class_distribution (line 375) | def class_distribution(y, sample_weight=None):
  function _ovr_decision_function (line 450) | def _ovr_decision_function(predictions, confidences, n_classes):

FILE: sklearn/utils/optimize.py
  class _LineSearchError (line 23) | class _LineSearchError(RuntimeError):
  function _line_search_wolfe12 (line 27) | def _line_search_wolfe12(f, fprime, xk, pk, gfk, old_fval, old_old_fval,...
  function _cg (line 53) | def _cg(fhess_p, fgrad, maxiter, tol):
  function _newton_cg (line 112) | def _newton_cg(
  function _check_optimize_result (line 217) | def _check_optimize_result(solver, result, max_iter=None, extra_warning_...

FILE: sklearn/utils/random.py
  function _random_choice_csc (line 14) | def _random_choice_csc(n_samples, classes, class_probability=None, rando...

FILE: sklearn/utils/setup.py
  function configuration (line 7) | def configuration(parent_package="", top_path=None):

FILE: sklearn/utils/sparsefuncs.py
  function _raise_typeerror (line 17) | def _raise_typeerror(X):
  function _raise_error_wrong_axis (line 24) | def _raise_error_wrong_axis(axis):
  function inplace_csr_column_scale (line 31) | def inplace_csr_column_scale(X, scale):
  function inplace_csr_row_scale (line 50) | def inplace_csr_row_scale(X, scale):
  function mean_variance_axis (line 68) | def mean_variance_axis(X, axis, weights=None, return_sum_weights=False):
  function incr_mean_variance_axis (line 128) | def incr_mean_variance_axis(X, *, axis, last_mean, last_var, last_n, wei...
  function inplace_column_scale (line 223) | def inplace_column_scale(X, scale):
  function inplace_row_scale (line 246) | def inplace_row_scale(X, scale):
  function inplace_swap_row_csc (line 268) | def inplace_swap_row_csc(X, m, n):
  function inplace_swap_row_csr (line 298) | def inplace_swap_row_csr(X, m, n):
  function inplace_swap_row (line 362) | def inplace_swap_row(X, m, n):
  function inplace_swap_column (line 386) | def inplace_swap_column(X, m, n):
  function _minor_reduce (line 414) | def _minor_reduce(X, ufunc):
  function _min_or_max_axis (line 425) | def _min_or_max_axis(X, axis, min_or_max):
  function _sparse_min_or_max (line 450) | def _sparse_min_or_max(X, axis, min_or_max):
  function _sparse_min_max (line 469) | def _sparse_min_max(X, axis):
  function _sparse_nan_min_max (line 476) | def _sparse_nan_min_max(X, axis):
  function min_max_axis (line 480) | def min_max_axis(X, axis, ignore_nan=False):
  function count_nonzero (line 515) | def count_nonzero(X, axis=None, sample_weight=None):
  function _get_median (line 563) | def _get_median(data, n_zeros):
  function _get_elem_at_rank (line 585) | def _get_elem_at_rank(rank, data, n_negative, n_zeros):
  function csc_median_axis_0 (line 594) | def csc_median_axis_0(X):

FILE: sklearn/utils/src/MurmurHash3.cpp
  function rotl32 (line 45) | inline uint32_t rotl32 ( uint32_t x, int8_t r )
  function rotl64 (line 50) | inline uint64_t rotl64 ( uint64_t x, int8_t r )
  function FORCE_INLINE (line 66) | FORCE_INLINE uint32_t getblock ( const uint32_t * p, int i )
  function FORCE_INLINE (line 71) | FORCE_INLINE uint64_t getblock ( const uint64_t * p, int i )
  function FORCE_INLINE (line 79) | FORCE_INLINE uint32_t fmix ( uint32_t h )
  function FORCE_INLINE (line 92) | FORCE_INLINE uint64_t fmix ( uint64_t k )
  function MurmurHash3_x86_32 (line 105) | void MurmurHash3_x86_32 ( const void * key, int len,
  function MurmurHash3_x86_128 (line 161) | void MurmurHash3_x86_128 ( const void * key, const int len,
  function MurmurHash3_x64_128 (line 266) | void MurmurHash3_x64_128 ( const void * key, const int len,

FILE: sklearn/utils/stats.py
  function _weighted_percentile (line 7) | def _weighted_percentile(array, sample_weight, percentile=50):

FILE: sklearn/utils/tests/conftest.py
  function print_changed_only_false (line 7) | def print_changed_only_false():

FILE: sklearn/utils/tests/test_arpack.py
  function test_init_arpack_v0 (line 9) | def test_init_arpack_v0(seed):

FILE: sklearn/utils/tests/test_arrayfuncs.py
  function test_min_pos (line 8) | def test_min_pos():
  function test_min_pos_no_positive (line 21) | def test_min_pos_no_positive(dtype):

FILE: sklearn/utils/tests/test_class_weight.py
  function test_compute_class_weight (line 13) | def test_compute_class_weight():
  function test_compute_class_weight_not_present (line 25) | def test_compute_class_weight_not_present():
  function test_compute_class_weight_dict (line 43) | def test_compute_class_weight_dict():
  function test_compute_class_weight_invariance (line 66) | def test_compute_class_weight_invariance():
  function test_compute_class_weight_balanced_negative (line 94) | def test_compute_class_weight_balanced_negative():
  function test_compute_class_weight_balanced_unordered (line 114) | def test_compute_class_weight_balanced_unordered():
  function test_compute_class_weight_default (line 125) | def test_compute_class_weight_default():
  function test_compute_sample_weight (line 147) | def test_compute_sample_weight():
  function test_compute_sample_weight_with_subsample (line 191) | def test_compute_sample_weight_with_subsample():
  function test_compute_sample_weight_errors (line 230) | def test_compute_sample_weight_errors():
  function test_compute_sample_weight_more_than_32 (line 258) | def test_compute_sample_weight_more_than_32():

FILE: sklearn/utils/tests/test_cython_blas.py
  function _numpy_to_cython (line 21) | def _numpy_to_cython(dtype):
  function _no_op (line 33) | def _no_op(x):
  function test_dot (line 38) | def test_dot(dtype):
  function test_asum (line 52) | def test_asum(dtype):
  function test_axpy (line 65) | def test_axpy(dtype):
  function test_nrm2 (line 80) | def test_nrm2(dtype):
  function test_copy (line 93) | def test_copy(dtype):
  function test_scal (line 107) | def test_scal(dtype):
  function test_rotg (line 121) | def test_rotg(dtype):
  function test_rot (line 146) | def test_rot(dtype):
  function test_gemv (line 169) | def test_gemv(dtype, opA, transA, order):
  function test_ger (line 188) | def test_ger(dtype, order):
  function test_gemm (line 213) | def test_gemm(dtype, opA, transA, opB, transB, order):

FILE: sklearn/utils/tests/test_cython_templating.py
  function test_files_generated_by_templates_are_git_ignored (line 6) | def test_files_generated_by_templates_are_git_ignored():

FILE: sklearn/utils/tests/test_deprecation.py
  class MockClass1 (line 13) | class MockClass1:
  class MockClass2 (line 17) | class MockClass2:
    method method (line 19) | def method(self):
    method n_features_ (line 24) | def n_features_(self):
  class MockClass3 (line 29) | class MockClass3:
    method __init__ (line 31) | def __init__(self):
  class MockClass4 (line 35) | class MockClass4:
  function mock_function (line 40) | def mock_function():
  function test_deprecated (line 44) | def test_deprecated():
  function test_is_deprecated (line 56) | def test_is_deprecated():
  function test_pickle (line 66) | def test_pickle():
  function test_deprecated_property_docstring_exists (line 70) | def test_deprecated_property_docstring_exists():

FILE: sklearn/utils/tests/test_encode.py
  function test_encode_util (line 24) | def test_encode_util(values, expected):
  function test_encode_with_check_unknown (line 31) | def test_encode_with_check_unknown():
  function _assert_check_unknown (line 50) | def _assert_check_unknown(values, uniques, expected_diff, expected_mask):
  function test_check_unknown (line 109) | def test_check_unknown(values, uniques, expected_diff, expected_mask):
  function test_check_unknown_missing_values (line 115) | def test_check_unknown_missing_values(missing_value, pickle_uniques):
  function test_unique_util_missing_values_objects (line 148) | def test_unique_util_missing_values_objects(missing_value, pickle_uniques):
  function test_unique_util_missing_values_numeric (line 168) | def test_unique_util_missing_values_numeric():
  function test_unique_util_with_all_missing_values (line 185) | def test_unique_util_with_all_missing_values():
  function test_check_unknown_with_both_missing_values (line 199) | def test_check_unknown_with_both_missing_values():

FILE: sklearn/utils/tests/test_estimator_checks.py
  class CorrectNotFittedError (line 60) | class CorrectNotFittedError(ValueError):
  class BaseBadClassifier (line 68) | class BaseBadClassifier(ClassifierMixin, BaseEstimator):
    method fit (line 69) | def fit(self, X, y):
    method predict (line 72) | def predict(self, X):
  class ChangesDict (line 76) | class ChangesDict(BaseEstimator):
    method __init__ (line 77) | def __init__(self, key=0):
    method fit (line 80) | def fit(self, X, y=None):
    method predict (line 84) | def predict(self, X):
  class SetsWrongAttribute (line 90) | class SetsWrongAttribute(BaseEstimator):
    method __init__ (line 91) | def __init__(self, acceptable_key=0):
    method fit (line 94) | def fit(self, X, y=None):
  class ChangesWrongAttribute (line 100) | class ChangesWrongAttribute(BaseEstimator):
    method __init__ (line 101) | def __init__(self, wrong_attribute=0):
    method fit (line 104) | def fit(self, X, y=None):
  class ChangesUnderscoreAttribute (line 110) | class ChangesUnderscoreAttribute(BaseEstimator):
    method fit (line 111) | def fit(self, X, y=None):
  class RaisesErrorInSetParams (line 117) | class RaisesErrorInSetParams(BaseEstimator):
    method __init__ (line 118) | def __init__(self, p=0):
    method set_params (line 121) | def set_params(self, **kwargs):
    method fit (line 129) | def fit(self, X, y=None):
  class HasMutableParameters (line 134) | class HasMutableParameters(BaseEstimator):
    method __init__ (line 135) | def __init__(self, p=object()):
    method fit (line 138) | def fit(self, X, y=None):
  class HasImmutableParameters (line 143) | class HasImmutableParameters(BaseEstimator):
    method __init__ (line 145) | def __init__(self, p=42, q=np.int32(42), r=object):
    method fit (line 150) | def fit(self, X, y=None):
  class ModifiesValueInsteadOfRaisingError (line 155) | class ModifiesValueInsteadOfRaisingError(BaseEstimator):
    method __init__ (line 156) | def __init__(self, p=0):
    method set_params (line 159) | def set_params(self, **kwargs):
    method fit (line 167) | def fit(self, X, y=None):
  class ModifiesAnotherValue (line 172) | class ModifiesAnotherValue(BaseEstimator):
    method __init__ (line 173) | def __init__(self, a=0, b="method1"):
    method set_params (line 177) | def set_params(self, **kwargs):
    method fit (line 186) | def fit(self, X, y=None):
  class NoCheckinPredict (line 191) | class NoCheckinPredict(BaseBadClassifier):
    method fit (line 192) | def fit(self, X, y):
  class NoSparseClassifier (line 197) | class NoSparseClassifier(BaseBadClassifier):
    method fit (line 198) | def fit(self, X, y):
    method predict (line 204) | def predict(self, X):
  class CorrectNotFittedErrorClassifier (line 209) | class CorrectNotFittedErrorClassifier(BaseBadClassifier):
    method fit (line 210) | def fit(self, X, y):
    method predict (line 215) | def predict(self, X):
  class NoSampleWeightPandasSeriesType (line 221) | class NoSampleWeightPandasSeriesType(BaseEstimator):
    method fit (line 222) | def fit(self, X, y, sample_weight=None):
    method predict (line 236) | def predict(self, X):
  class BadBalancedWeightsClassifier (line 241) | class BadBalancedWeightsClassifier(BaseBadClassifier):
    method __init__ (line 242) | def __init__(self, class_weight=None):
    method fit (line 245) | def fit(self, X, y):
  class BadTransformerWithoutMixin (line 263) | class BadTransformerWithoutMixin(BaseEstimator):
    method fit (line 264) | def fit(self, X, y=None):
    method transform (line 268) | def transform(self, X):
  class NotInvariantPredict (line 273) | class NotInvariantPredict(BaseEstimator):
    method fit (line 274) | def fit(self, X, y):
    method predict (line 281) | def predict(self, X):
  class NotInvariantSampleOrder (line 289) | class NotInvariantSampleOrder(BaseEstimator):
    method fit (line 290) | def fit(self, X, y):
    method predict (line 298) | def predict(self, X):
  class LargeSparseNotSupportedClassifier (line 310) | class LargeSparseNotSupportedClassifier(BaseEstimator):
    method fit (line 311) | def fit(self, X, y):
  class SparseTransformer (line 333) | class SparseTransformer(BaseEstimator):
    method fit (line 334) | def fit(self, X, y=None):
    method fit_transform (line 338) | def fit_transform(self, X, y=None):
    method transform (line 341) | def transform(self, X):
  class EstimatorInconsistentForPandas (line 348) | class EstimatorInconsistentForPandas(BaseEstimator):
    method fit (line 349) | def fit(self, X, y):
    method predict (line 365) | def predict(self, X):
  class UntaggedBinaryClassifier (line 370) | class UntaggedBinaryClassifier(SGDClassifier):
    method fit (line 372) | def fit(self, X, y, coef_init=None, intercept_init=None, sample_weight...
    method partial_fit (line 378) | def partial_fit(self, X, y, classes=None, sample_weight=None):
  class TaggedBinaryClassifier (line 385) | class TaggedBinaryClassifier(UntaggedBinaryClassifier):
    method _more_tags (line 387) | def _more_tags(self):
  class EstimatorMissingDefaultTags (line 391) | class EstimatorMissingDefaultTags(BaseEstimator):
    method _get_tags (line 392) | def _get_tags(self):
  class RequiresPositiveYRegressor (line 398) | class RequiresPositiveYRegressor(LinearRegression):
    method fit (line 399) | def fit(self, X, y):
    method _more_tags (line 405) | def _more_tags(self):
  class PoorScoreLogisticRegression (line 409) | class PoorScoreLogisticRegression(LogisticRegression):
    method decision_function (line 410) | def decision_function(self, X):
    method _more_tags (line 413) | def _more_tags(self):
  class PartialFitChecksName (line 417) | class PartialFitChecksName(BaseEstimator):
    method fit (line 418) | def fit(self, X, y):
    method partial_fit (line 422) | def partial_fit(self, X, y):
  function test_not_an_array_array_function (line 429) | def test_not_an_array_array_function():
  function test_check_fit_score_takes_y_works_on_deprecated_fit (line 440) | def test_check_fit_score_takes_y_works_on_deprecated_fit():
  function test_check_estimator (line 452) | def test_check_estimator():
  function test_check_outlier_corruption (line 581) | def test_check_outlier_corruption():
  function test_check_estimator_transformer_no_mixin (line 591) | def test_check_estimator_transformer_no_mixin():
  function test_check_estimator_clones (line 597) | def test_check_estimator_clones():
  function test_check_estimators_unfitted (line 633) | def test_check_estimators_unfitted():
  function test_check_no_attributes_set_in_init (line 645) | def test_check_no_attributes_set_in_init():
  function test_check_estimator_pairwise (line 674) | def test_check_estimator_pairwise():
  function test_check_classifier_data_not_an_array (line 687) | def test_check_classifier_data_not_an_array():
  function test_check_regressor_data_not_an_array (line 694) | def test_check_regressor_data_not_an_array():
  function test_check_estimator_get_tags_default_keys (line 701) | def test_check_estimator_get_tags_default_keys():
  function test_check_dataframe_column_names_consistency (line 715) | def test_check_dataframe_column_names_consistency():
  class _BaseMultiLabelClassifierMock (line 731) | class _BaseMultiLabelClassifierMock(ClassifierMixin, BaseEstimator):
    method __init__ (line 732) | def __init__(self, response_output):
    method fit (line 735) | def fit(self, X, y):
    method _more_tags (line 738) | def _more_tags(self):
  function test_check_classifiers_multilabel_output_format_predict (line 742) | def test_check_classifiers_multilabel_output_format_predict():
  function test_check_classifiers_multilabel_output_format_predict_proba (line 785) | def test_check_classifiers_multilabel_output_format_predict_proba():
  function test_check_classifiers_multilabel_output_format_decision_function (line 908) | def test_check_classifiers_multilabel_output_format_decision_function():
  function run_tests_without_pytest (line 961) | def run_tests_without_pytest():
  function test_check_class_weight_balanced_linear_classifier (line 976) | def test_check_class_weight_balanced_linear_classifier():
  function test_all_estimators_all_public (line 985) | def test_all_estimators_all_public():
  function test_xfail_ignored_in_check_estimator (line 1002) | def test_xfail_ignored_in_check_estimator():
  function test_minimal_class_implementation_checks (line 1012) | def test_minimal_class_implementation_checks():
  function test_check_fit_check_is_fitted (line 1022) | def test_check_fit_check_is_fitted():

FILE: sklearn/utils/tests/test_estimator_html_repr.py
  function test_write_label_html (line 35) | def test_write_label_html(checked):
  function test_get_visual_block_single_str_none (line 51) | def test_get_visual_block_single_str_none(est):
  function test_get_visual_block_single_estimator (line 60) | def test_get_visual_block_single_estimator():
  function test_get_visual_block_pipeline (line 69) | def test_get_visual_block_pipeline():
  function test_get_visual_block_feature_union (line 90) | def test_get_visual_block_feature_union():
  function test_get_visual_block_voting (line 101) | def test_get_visual_block_voting():
  function test_get_visual_block_column_transformer (line 112) | def test_get_visual_block_column_transformer():
  function test_estimator_html_repr_pipeline (line 123) | def test_estimator_html_repr_pipeline():
  function test_stacking_classsifer (line 205) | def test_stacking_classsifer(final_estimator):
  function test_stacking_regressor (line 224) | def test_stacking_regressor(final_estimator):
  function test_birch_duck_typing_meta (line 238) | def test_birch_duck_typing_meta():
  function test_ovo_classifier_duck_typing_meta (line 252) | def test_ovo_classifier_duck_typing_meta():
  function test_duck_typing_nested_estimator (line 266) | def test_duck_typing_nested_estimator():
  function test_one_estimator_print_change_only (line 277) | def test_one_estimator_print_change_only(print_changed_only):
  function test_fallback_exists (line 286) | def test_fallback_exists():

FILE: sklearn/utils/tests/test_extmath.py
  function test_density (line 39) | def test_density():
  function test_uniform_weights (line 53) | def test_uniform_weights():
  function test_random_weights (line 67) | def test_random_weights():
  function check_randomized_svd_low_rank (line 85) | def check_randomized_svd_low_rank(dtype):
  function test_randomized_svd_low_rank_all_dtypes (line 164) | def test_randomized_svd_low_rank_all_dtypes(dtype):
  function test_randomized_eigsh (line 169) | def test_randomized_eigsh(dtype):
  function test_randomized_eigsh_compared_to_others (line 192) | def test_randomized_eigsh_compared_to_others(k):
  function test_randomized_eigsh_reconst_low_rank (line 274) | def test_randomized_eigsh_reconst_low_rank(n, rank):
  function test_row_norms (line 301) | def test_row_norms(dtype):
  function test_randomized_svd_low_rank_with_noise (line 327) | def test_randomized_svd_low_rank_with_noise():
  function test_randomized_svd_infinite_rank (line 368) | def test_randomized_svd_infinite_rank():
  function test_randomized_svd_transpose_consistency (line 409) | def test_randomized_svd_transpose_consistency():
  function test_randomized_svd_power_iteration_normalizer (line 441) | def test_randomized_svd_power_iteration_normalizer():
  function test_randomized_svd_sparse_warnings (line 486) | def test_randomized_svd_sparse_warnings():
  function test_svd_flip (line 501) | def test_svd_flip():
  function test_randomized_svd_sign_flip (line 526) | def test_randomized_svd_sign_flip():
  function test_randomized_svd_sign_flip_with_transpose (line 538) | def test_randomized_svd_sign_flip_with_transpose():
  function test_cartesian (line 571) | def test_cartesian():
  function test_logistic_sigmoid (line 601) | def test_logistic_sigmoid():
  function rng (line 614) | def rng():
  function test_incremental_weighted_mean_and_variance_simple (line 619) | def test_incremental_weighted_mean_and_variance_simple(rng, dtype):
  function test_incremental_weighted_mean_and_variance (line 638) | def test_incremental_weighted_mean_and_variance(
  function test_incremental_weighted_mean_and_variance_ignore_nan (line 678) | def test_incremental_weighted_mean_and_variance_ignore_nan(dtype):
  function test_incremental_variance_update_formulas (line 714) | def test_incremental_variance_update_formulas():
  function test_incremental_mean_and_variance_ignore_nan (line 740) | def test_incremental_mean_and_variance_ignore_nan():
  function test_incremental_variance_numerical_stability (line 769) | def test_incremental_variance_numerical_stability():
  function test_incremental_variance_ddof (line 841) | def test_incremental_variance_ddof():
  function test_vector_sign_flip (line 873) | def test_vector_sign_flip():
  function test_softmax (line 884) | def test_softmax():
  function test_stable_cumsum (line 892) | def test_stable_cumsum():
  function test_safe_sparse_dot_2d (line 911) | def test_safe_sparse_dot_2d(A_array_constr, B_array_constr):
  function test_safe_sparse_dot_nd (line 925) | def test_safe_sparse_dot_nd():
  function test_safe_sparse_dot_2d_1d (line 948) | def test_safe_sparse_dot_2d_1d(A_array_constr):
  function test_safe_sparse_dot_dense_output (line 969) | def test_safe_sparse_dot_dense_output(dense_output):

FILE: sklearn/utils/tests/test_fast_dict.py
  function test_int_float_dict (line 8) | def test_int_float_dict():
  function test_int_float_dict_argmin (line 26) | def test_int_float_dict_argmin():

FILE: sklearn/utils/tests/test_fixes.py
  function test_joblib_parallel_args (line 21) | def test_joblib_parallel_args(monkeypatch, joblib_version):
  function test_object_dtype_isnan (line 54) | def test_object_dtype_isnan(dtype, val):
  function test_loguniform (line 65) | def test_loguniform(low, high, base):
  function test_linspace (line 86) | def test_linspace():

FILE: sklearn/utils/tests/test_graph.py
  function test_fix_connected_components (line 9) | def test_fix_connected_components():
  function test_fix_connected_components_wrong_mode (line 23) | def test_fix_connected_components_wrong_mode():
  function test_fix_connected_components_connectivity_mode (line 35) | def test_fix_connected_components_connectivity_mode():
  function test_fix_connected_components_distance_mode (line 46) | def test_fix_connected_components_distance_mode():

FILE: sklearn/utils/tests/test_metaestimators.py
  class Prefix (line 8) | class Prefix:
    method func (line 9) | def func(self):
  class MockMetaEstimator (line 13) | class MockMetaEstimator:
    method func (line 19) | def func(self):
  function test_delegated_docstring (line 24) | def test_delegated_docstring():
  class MetaEst (line 32) | class MetaEst:
    method __init__ (line 35) | def __init__(self, sub_est, better_sub_est=None):
    method predict (line 40) | def predict(self):
  class MetaEstTestTuple (line 44) | class MetaEstTestTuple(MetaEst):
    method predict (line 48) | def predict(self):
  class MetaEstTestList (line 52) | class MetaEstTestList(MetaEst):
    method predict (line 56) | def predict(self):
  class HasPredict (line 60) | class HasPredict:
    method predict (line 63) | def predict(self):
  class HasNoPredict (line 67) | class HasNoPredict:
  class HasPredictAsNDArray (line 73) | class HasPredictAsNDArray:
  function test_if_delegate_has_method (line 79) | def test_if_delegate_has_method():
  class AvailableParameterEstimator (line 89) | class AvailableParameterEstimator:
    method __init__ (line 92) | def __init__(self, available=True):
    method available_func (line 96) | def available_func(self):
  function test_available_if_docstring (line 101) | def test_available_if_docstring():
  function test_available_if (line 113) | def test_available_if():
  function test_available_if_unbound_method (line 118) | def test_available_if_unbound_method():
  function test_if_delegate_has_method_numpy_array (line 134) | def test_if_delegate_has_method_numpy_array():

FILE: sklearn/utils/tests/test_mocking.py
  function iris (line 17) | def iris():
  function _success (line 21) | def _success(x):
  function _fail (line 25) | def _fail(x):
  function test_check_on_fit_success (line 38) | def test_check_on_fit_success(iris, kwargs):
  function test_check_on_fit_fail (line 53) | def test_check_on_fit_fail(iris, kwargs):
  function test_check_X_on_predict_success (line 63) | def test_check_X_on_predict_success(iris, pred_func):
  function test_check_X_on_predict_fail (line 72) | def test_check_X_on_predict_fail(iris, pred_func):
  function test_checking_classifier (line 81) | def test_checking_classifier(iris, input_type):
  function test_checking_classifier_with_params (line 125) | def test_checking_classifier_with_params(iris):
  function test_checking_classifier_fit_params (line 142) | def test_checking_classifier_fit_params(iris):
  function test_checking_classifier_missing_fit_params (line 152) | def test_checking_classifier_missing_fit_params(iris):
  function test_checking_classifier_methods_to_check (line 166) | def test_checking_classifier_methods_to_check(iris, methods_to_check, pr...

FILE: sklearn/utils/tests/test_multiclass.py
  function test_unique_labels (line 149) | def test_unique_labels():
  function test_unique_labels_non_specific (line 179) | def test_unique_labels_non_specific():
  function test_unique_labels_mixed_types (line 203) | def test_unique_labels_mixed_types():
  function test_is_multilabel (line 228) | def test_is_multilabel():
  function test_check_classification_targets (line 273) | def test_check_classification_targets():
  function test_type_of_target (line 286) | def test_type_of_target():
  function test_type_of_target_pandas_sparse (line 312) | def test_type_of_target_pandas_sparse():
  function test_class_distribution (line 326) | def test_class_distribution():
  function test_safe_split_with_precomputed_kernel (line 377) | def test_safe_split_with_precomputed_kernel():
  function test_ovr_decision_function (line 399) | def test_ovr_decision_function():

FILE: sklearn/utils/tests/test_murmurhash.py
  function test_mmhash3_int (line 11) | def test_mmhash3_int():
  function test_mmhash3_int_array (line 25) | def test_mmhash3_int_array():
  function test_mmhash3_bytes (line 41) | def test_mmhash3_bytes():
  function test_mmhash3_unicode (line 49) | def test_mmhash3_unicode():
  function test_no_collision_on_byte_range (line 57) | def test_no_collision_on_byte_range():
  function test_uniform_distribution (line 64) | def test_uniform_distribution():

FILE: sklearn/utils/tests/test_optimize.py
  function test_newton_cg (line 9) | def test_newton_cg():

FILE: sklearn/utils/tests/test_parallel.py
  function get_working_memory (line 13) | def get_working_memory():
  function test_configuration_passes_through_to_joblib (line 19) | def test_configuration_passes_through_to_joblib(n_jobs, backend):

FILE: sklearn/utils/tests/test_pprint.py
  class LogisticRegression (line 18) | class LogisticRegression(BaseEstimator):
    method __init__ (line 19) | def __init__(
    method fit (line 53) | def fit(self, X, y):
  class StandardScaler (line 57) | class StandardScaler(TransformerMixin, BaseEstimator):
    method __init__ (line 58) | def __init__(self, copy=True, with_mean=True, with_std=True):
    method transform (line 63) | def transform(self, X, copy=None):
  class RFE (line 67) | class RFE(BaseEstimator):
    method __init__ (line 68) | def __init__(self, estimator, n_features_to_select=None, step=1, verbo...
  class GridSearchCV (line 75) | class GridSearchCV(BaseEstimator):
    method __init__ (line 76) | def __init__(
  class CountVectorizer (line 103) | class CountVectorizer(BaseEstimator):
    method __init__ (line 104) | def __init__(
  class Pipeline (line 143) | class Pipeline(BaseEstimator):
    method __init__ (line 144) | def __init__(self, steps, memory=None):
  class SVC (line 149) | class SVC(BaseEstimator):
    method __init__ (line 150) | def __init__(
  class PCA (line 183) | class PCA(BaseEstimator):
    method __init__ (line 184) | def __init__(
  class NMF (line 203) | class NMF(BaseEstimator):
    method __init__ (line 204) | def __init__(
  class SimpleImputer (line 231) | class SimpleImputer(BaseEstimator):
    method __init__ (line 232) | def __init__(
  function test_basic (line 247) | def test_basic(print_changed_only_false):
  function test_changed_only (line 261) | def test_changed_only():
  function test_pipeline (line 290) | def test_pipeline(print_changed_only_false):
  function test_deeply_nested (line 311) | def test_deeply_nested(print_changed_only_false):
  function test_gridsearch (line 348) | def test_gridsearch(print_changed_only_false):
  function test_gridsearch_pipeline (line 374) | def test_gridsearch_pipeline(print_changed_only_false):
  function test_n_max_elements_to_show (line 440) | def test_n_max_elements_to_show(print_changed_only_false):
  function test_bruteforce_ellipsis (line 531) | def test_bruteforce_ellipsis(print_changed_only_false):
  function test_builtin_prettyprinter (line 605) | def test_builtin_prettyprinter():
  function test_kwargs_in_init (line 613) | def test_kwargs_in_init():
  function test_complexity_print_changed_only (line 649) | def test_complexity_print_changed_only():

FILE: sklearn/utils/tests/test_random.py
  function test_invalid_sample_without_replacement_algorithm (line 14) | def test_invalid_sample_without_replacement_algorithm():
  function test_sample_without_replacement_algorithms (line 19) | def test_sample_without_replacement_algorithms():
  function check_edge_case_of_sample_int (line 36) | def check_edge_case_of_sample_int(sample_without_replacement):
  function check_sample_int (line 60) | def check_sample_int(sample_without_replacement):
  function check_sample_int_distribution (line 78) | def check_sample_int_distribution(sample_without_replacement):
  function test_random_choice_csc (line 110) | def test_random_choice_csc(n_samples=10000, random_state=24):
  function test_random_choice_csc_errors (line 165) | def test_random_choice_csc_errors():
  function test_our_rand_r (line 191) | def test_our_rand_r():

FILE: sklearn/utils/tests/test_readonly_wrapper.py
  function _readonly_array_copy (line 9) | def _readonly_array_copy(x):
  function _create_memmap_backed_data (line 16) | def _create_memmap_backed_data(data):
  function test_readonly_array_wrapper (line 24) | def test_readonly_array_wrapper(readonly, dtype):

FILE: sklearn/utils/tests/test_seq_dataset.py
  function assert_csr_equal_values (line 32) | def assert_csr_equal_values(current, expected):
  function make_dense_dataset_32 (line 43) | def make_dense_dataset_32():
  function make_dense_dataset_64 (line 47) | def make_dense_dataset_64():
  function make_sparse_dataset_32 (line 51) | def make_sparse_dataset_32():
  function make_sparse_dataset_64 (line 57) | def make_sparse_dataset_64():
  function test_seq_dataset_basic_iteration (line 72) | def test_seq_dataset_basic_iteration(dataset_constructor):
  function test_seq_dataset_shuffle (line 100) | def test_seq_dataset_shuffle(make_dense_dataset, make_sparse_dataset):
  function test_fused_types_consistency (line 140) | def test_fused_types_consistency(make_dataset_32, make_dataset_64):
  function test_buffer_dtype_mismatch_error (line 155) | def test_buffer_dtype_mismatch_error():

FILE: sklearn/utils/tests/test_shortest_path.py
  function test_graph_shortest_path_deprecation (line 10) | def test_graph_shortest_path_deprecation():
  function floyd_warshall_slow (line 17) | def floyd_warshall_slow(graph, directed=False):
  function generate_graph (line 39) | def generate_graph(N=20):
  function test_floyd_warshall (line 58) | def test_floyd_warshall():
  function test_dijkstra (line 69) | def test_dijkstra():
  function test_shortest_path (line 79) | def test_shortest_path():
  function test_dijkstra_bug_fix (line 99) | def test_dijkstra_bug_fix():

FILE: sklearn/utils/tests/test_show_versions.py
  function test_get_sys_info (line 8) | def test_get_sys_info():
  function test_get_deps_info (line 16) | def test_get_deps_info():
  function test_show_versions (line 31) | def test_show_versions(capsys):

FILE: sklearn/utils/tests/test_sparsefuncs.py
  function test_mean_variance_axis0 (line 30) | def test_mean_variance_axis0():
  function test_mean_variance_axis0_precision (line 66) | def test_mean_variance_axis0_precision(dtype, sparse_constructor):
  function test_mean_variance_axis1 (line 84) | def test_mean_variance_axis1():
  function test_incr_mean_variance_axis_weighted_axis1 (line 150) | def test_incr_mean_variance_axis_weighted_axis1(
  function test_incr_mean_variance_axis_weighted_axis0 (line 247) | def test_incr_mean_variance_axis_weighted_axis0(
  function test_incr_mean_variance_axis (line 315) | def test_incr_mean_variance_axis():
  function test_incr_mean_variance_axis_dim_mismatch (line 397) | def test_incr_mean_variance_axis_dim_mismatch(sparse_constructor):
  function test_incr_mean_variance_axis_equivalence_mean_variance (line 444) | def test_incr_mean_variance_axis_equivalence_mean_variance(X1, X2):
  function test_incr_mean_variance_no_new_n (line 464) | def test_incr_mean_variance_no_new_n():
  function test_incr_mean_variance_n_float (line 483) | def test_incr_mean_variance_n_float():
  function test_incr_mean_variance_axis_ignore_nan (line 497) | def test_incr_mean_variance_axis_ignore_nan(axis, sparse_constructor):
  function test_mean_variance_illegal_axis (line 544) | def test_mean_variance_illegal_axis():
  function test_densify_rows (line 574) | def test_densify_rows():
  function test_inplace_column_scale (line 590) | def test_inplace_column_scale():
  function test_inplace_row_scale (line 622) | def test_inplace_row_scale():
  function test_inplace_swap_row (line 654) | def test_inplace_swap_row():
  function test_inplace_swap_column (line 702) | def test_inplace_swap_column():
  function test_min_max (line 758) | def test_min_max(
  function test_min_max_axis_errors (line 788) | def test_min_max_axis_errors():
  function test_count_nonzero (line 802) | def test_count_nonzero():
  function test_csc_row_median (line 846) | def test_csc_row_median():
  function test_inplace_normalize (line 880) | def test_inplace_normalize():
  function test_csr_row_norms (line 907) | def test_csr_row_norms(dtype):

FILE: sklearn/utils/tests/test_stats.py
  function test_weighted_percentile (line 8) | def test_weighted_percentile():
  function test_weighted_percentile_equal (line 20) | def test_weighted_percentile_equal():
  function test_weighted_percentile_zero_weight (line 29) | def test_weighted_percentile_zero_weight():
  function test_weighted_percentile_zero_weight_zero_percentile (line 38) | def test_weighted_percentile_zero_weight_zero_percentile():
  function test_weighted_median_equal_weights (line 51) | def test_weighted_median_equal_weights():
  function test_weighted_median_integer_weights (line 63) | def test_weighted_median_integer_weights():
  function test_weighted_percentile_2d (line 77) | def test_weighted_percentile_2d():

FILE: sklearn/utils/tests/test_tags.py
  class NoTagsEstimator (line 10) | class NoTagsEstimator:
  class MoreTagsEstimator (line 14) | class MoreTagsEstimator:
    method _more_tags (line 15) | def _more_tags(self):
  function test_safe_tags_error (line 26) | def test_safe_tags_error(estimator, err_msg):
  function test_safe_tags_no_get_tags (line 44) | def test_safe_tags_no_get_tags(estimator, key, expected_results):

FILE: sklearn/utils/tests/test_testing.py
  function test_set_random_state (line 37) | def test_set_random_state():
  function test_assert_allclose_dense_sparse (line 46) | def test_assert_allclose_dense_sparse():
  function test_assert_raises_msg (line 65) | def test_assert_raises_msg():
  function test_assert_raise_message (line 71) | def test_assert_raise_message():
  function test_ignore_warning (line 110) | def test_ignore_warning():
  class TestWarns (line 219) | class TestWarns(unittest.TestCase):
    method test_warn (line 220) | def test_warn(self):
    method test_warn_wrong_warning (line 242) | def test_warn_wrong_warning(self):
  function f_ok (line 268) | def f_ok(a, b):
  function f_bad_sections (line 287) | def f_bad_sections(a, b):
  function f_bad_order (line 306) | def f_bad_order(b, a):
  function f_too_many_param_docstring (line 325) | def f_too_many_param_docstring(a, b):
  function f_missing (line 346) | def f_missing(a, b):
  function f_check_param_definition (line 363) | def f_check_param_definition(a, b, c, d, e):
  class Klass (line 382) | class Klass:
    method f_missing (line 383) | def f_missing(self, X, y):
    method f_bad_sections (line 386) | def f_bad_sections(self, X, y):
  class MockEst (line 404) | class MockEst:
    method __init__ (line 405) | def __init__(self):
    method fit (line 408) | def fit(self, X, y):
    method predict (line 411) | def predict(self, X):
    method predict_proba (line 414) | def predict_proba(self, X):
    method score (line 417) | def score(self, X):
  class MockMetaEstimator (line 421) | class MockMetaEstimator:
    method __init__ (line 422) | def __init__(self, delegate):
    method predict (line 433) | def predict(self, X):
    method score (line 445) | def score(self, X):
    method predict_proba (line 455) | def predict_proba(self, X):
    method fit (line 466) | def fit(self, X, y):
  class MockMetaEstimatorDeprecatedDelegation (line 470) | class MockMetaEstimatorDeprecatedDelegation:
    method __init__ (line 471) | def __init__(self, delegate):
    method predict (line 482) | def predict(self, X):
    method score (line 494) | def score(self, X):
    method predict_proba (line 504) | def predict_proba(self, X):
    method fit (line 515) | def fit(self, X, y):
  function test_check_docstring_parameters (line 526) | def test_check_docstring_parameters(mock_meta):
  class RegistrationCounter (line 647) | class RegistrationCounter:
    method __init__ (line 648) | def __init__(self):
    method __call__ (line 651) | def __call__(self, to_register_func):
  function check_memmap (line 656) | def check_memmap(input_array, mmap_data, mmap_mode="r"):
  function test_tempmemmap (line 663) | def test_tempmemmap(monkeypatch):
  function test_create_memmap_backed_data (line 685) | def test_create_memmap_backed_data(monkeypatch, aligned):
  function test_memmap_on_contiguous_data (line 720) | def test_memmap_on_contiguous_data(dtype):
  function test_convert_container (line 763) | def test_convert_container(
  function test_raises (line 793) | def test_raises():

FILE: sklearn/utils/tests/test_utils.py
  function test_make_rng (line 42) | def test_make_rng():
  function test_gen_batches (line 60) | def test_gen_batches():
  function test_deprecated (line 73) | def test_deprecated():
  function test_resample (line 110) | def test_resample():
  function test_resample_stratified (line 124) | def test_resample_stratified():
  function test_resample_stratified_replace (line 140) | def test_resample_stratified_replace():
  function test_resample_stratify_2dy (line 165) | def test_resample_stratify_2dy():
  function test_resample_stratify_sparse_error (line 175) | def test_resample_stratify_sparse_error():
  function test_safe_mask (line 186) | def test_safe_mask():
  function test_column_or_1d (line 199) | def test_column_or_1d():
  function test_determine_key_type (line 250) | def test_determine_key_type(key, dtype):
  function test_determine_key_type_error (line 254) | def test_determine_key_type_error():
  function test_determine_key_type_slice_error (line 259) | def test_determine_key_type_slice_error():
  function test_safe_indexing_2d_container_axis_0 (line 266) | def test_safe_indexing_2d_container_axis_0(array_type, indices_type):
  function test_safe_indexing_1d_container (line 280) | def test_safe_indexing_1d_container(array_type, indices_type):
  function test_safe_indexing_2d_container_axis_1 (line 293) | def test_safe_indexing_2d_container_axis_1(array_type, indices_type, ind...
  function test_safe_indexing_2d_read_only_axis_1 (line 327) | def test_safe_indexing_2d_read_only_axis_1(
  function test_safe_indexing_1d_container_mask (line 344) | def test_safe_indexing_1d_container_mask(array_type, indices_type):
  function test_safe_indexing_2d_mask (line 358) | def test_safe_indexing_2d_mask(array_type, indices_type, axis, expected_...
  function test_safe_indexing_2d_scalar_axis_0 (line 381) | def test_safe_indexing_2d_scalar_axis_0(array_type, expected_output_type):
  function test_safe_indexing_1d_scalar (line 390) | def test_safe_indexing_1d_scalar(array_type):
  function test_safe_indexing_2d_scalar_axis_1 (line 402) | def test_safe_indexing_2d_scalar_axis_1(array_type, expected_output_type...
  function test_safe_indexing_None_axis_0 (line 426) | def test_safe_indexing_None_axis_0(array_type):
  function test_safe_indexing_pandas_no_matching_cols_error (line 432) | def test_safe_indexing_pandas_no_matching_cols_error():
  function test_safe_indexing_error_axis (line 441) | def test_safe_indexing_error_axis(axis):
  function test_safe_indexing_1d_array_error (line 447) | def test_safe_indexing_1d_array_error(X_constructor):
  function test_safe_indexing_container_axis_0_unsupported_type (line 462) | def test_safe_indexing_container_axis_0_unsupported_type():
  function test_safe_indexing_pandas_no_settingwithcopy_warning (line 470) | def test_safe_indexing_pandas_no_settingwithcopy_warning():
  function test_get_column_indices_error (line 494) | def test_get_column_indices_error(key, err_msg):
  function test_get_column_indices_pandas_nonunique_columns_error (line 505) | def test_get_column_indices_pandas_nonunique_columns_error(key):
  function test_shuffle_on_ndim_equals_three (line 517) | def test_shuffle_on_ndim_equals_three():
  function test_shuffle_dont_convert_to_array (line 527) | def test_shuffle_dont_convert_to_array():
  function test_gen_even_slices (line 552) | def test_gen_even_slices():
  function test_get_chunk_n_rows (line 583) | def test_get_chunk_n_rows(row_bytes, max_n_rows, working_memory, expecte...
  function test_message_with_time (line 624) | def test_message_with_time(source, message, is_long, time, time_str):
  function test_print_elapsed_time (line 657) | def test_print_elapsed_time(message, expected, capsys, monkeypatch):
  function test_is_scalar_nan (line 681) | def test_is_scalar_nan(value, result):
  function test_approximate_mode (line 687) | def test_approximate_mode():
  function dummy_func (line 704) | def dummy_func():
  function test_deprecation_joblib_api (line 708) | def test_deprecation_joblib_api(tmpdir):
  function test_to_object_array (line 723) | def test_to_object_array(sequence):

FILE: sklearn/utils/tests/test_validation.py
  function test_as_float_array (line 68) | def test_as_float_array():
  function test_as_float_array_nan (line 112) | def test_as_float_array_nan(X):
  function test_np_matrix (line 122) | def test_np_matrix():
  function test_memmap (line 131) | def test_memmap():
  function test_ordering (line 147) | def test_ordering():
  function test_check_array_force_all_finite_valid (line 170) | def test_check_array_force_all_finite_valid(value, force_all_finite, ret...
  function test_check_array_force_all_finiteinvalid (line 197) | def test_check_array_force_all_finiteinvalid(
  function test_check_array_links_to_imputer_doc_only_for_X (line 213) | def test_check_array_links_to_imputer_doc_only_for_X(input_name, retype):
  function test_check_array_force_all_finite_object (line 249) | def test_check_array_force_all_finite_object():
  function test_check_array_force_all_finite_object_unsafe_casting (line 281) | def test_check_array_force_all_finite_object_unsafe_casting(
  function test_check_array (line 291) | def test_check_array():
  function test_check_array_numeric_warns (line 416) | def test_check_array_numeric_warns(X):
  function test_check_array_dtype_numeric_errors (line 438) | def test_check_array_dtype_numeric_errors(X):
  function test_check_array_pandas_na_support (line 456) | def test_check_array_pandas_na_support(pd_dtype, dtype, expected_dtype):
  function test_check_array_pandas_dtype_object_conversion (line 486) | def test_check_array_pandas_dtype_object_conversion():
  function test_check_array_pandas_dtype_casting (line 501) | def test_check_array_pandas_dtype_casting():
  function test_check_array_on_mock_dataframe (line 538) | def test_check_array_on_mock_dataframe():
  function test_check_array_dtype_stability (line 547) | def test_check_array_dtype_stability():
  function test_check_array_dtype_warning (line 554) | def test_check_array_dtype_warning():
  function test_check_array_accept_sparse_type_exception (line 598) | def test_check_array_accept_sparse_type_exception():
  function test_check_array_accept_sparse_no_exception (line 629) | def test_check_array_accept_sparse_no_exception():
  function X_64bit (line 640) | def X_64bit(request):
  function test_check_array_accept_large_sparse_no_exception (line 648) | def test_check_array_accept_large_sparse_no_exception(X_64bit):
  function test_check_array_accept_large_sparse_raise_exception (line 653) | def test_check_array_accept_large_sparse_raise_exception(X_64bit):
  function test_check_array_min_samples_and_features_messages (line 663) | def test_check_array_min_samples_and_features_messages():
  function test_check_array_complex_data_error (line 721) | def test_check_array_complex_data_error():
  function test_has_fit_parameter (line 763) | def test_has_fit_parameter():
  function test_check_symmetric (line 779) | def test_check_symmetric():
  function test_check_is_fitted_with_is_fitted (line 814) | def test_check_is_fitted_with_is_fitted():
  function test_check_is_fitted (line 828) | def test_check_is_fitted():
  function test_check_is_fitted_attributes (line 864) | def test_check_is_fitted_attributes():
  function test_check_is_fitted_with_attributes (line 895) | def test_check_is_fitted_with_attributes(wrap):
  function test_check_consistent_length (line 910) | def test_check_consistent_length():
  function test_check_dataframe_fit_attribute (line 930) | def test_check_dataframe_fit_attribute():
  function test_suppress_validation (line 943) | def test_suppress_validation():
  function test_check_array_series (line 954) | def test_check_array_series():
  function test_check_dataframe_mixed_float_dtypes (line 966) | def test_check_dataframe_mixed_float_dtypes():
  class DummyMemory (line 986) | class DummyMemory:
    method cache (line 987) | def cache(self, func):
  class WrongDummyMemory (line 991) | class WrongDummyMemory:
  function test_check_memory (line 996) | def test_check_memory():
  function test_check_array_memmap (line 1021) | def test_check_array_memmap(copy):
  function test_check_non_negative (line 1042) | def test_check_non_negative(retype):
  function test_check_X_y_informative_error (line 1055) | def test_check_X_y_informative_error():
  function test_retrieve_samples_from_non_standard_shape (line 1062) | def test_retrieve_samples_from_non_standard_shape():
  function test_check_scalar_valid (line 1083) | def test_check_scalar_valid(x):
  function test_check_scalar_invalid (line 1163) | def test_check_scalar_invalid(
  function test_check_psd_eigenvalues_valid (line 1218) | def test_check_psd_eigenvalues_valid(
  function test_check_psd_eigenvalues_invalid (line 1271) | def test_check_psd_eigenvalues_invalid(lambdas, err_type, err_msg):
  function test_check_sample_weight (line 1279) | def test_check_sample_weight():
  function test_allclose_dense_sparse_equals (line 1324) | def test_allclose_dense_sparse_equals(toarray):
  function test_allclose_dense_sparse_not_equals (line 1331) | def test_allclose_dense_sparse_not_equals(toarray):
  function test_allclose_dense_sparse_raise (line 1338) | def test_allclose_dense_sparse_raise(toarray):
  function test_deprecate_positional_args_warns_for_function (line 1347) | def test_deprecate_positional_args_warns_for_function():
  function test_deprecate_positional_args_warns_for_function_version (line 1374) | def test_deprecate_positional_args_warns_for_function_version():
  function test_deprecate_positional_args_warns_for_class (line 1385) | def test_deprecate_positional_args_warns_for_class():
  function test_check_fit_params (line 1410) | def test_check_fit_params(indices):
  function test_check_sparse_pandas_sp_format (line 1435) | def test_check_sparse_pandas_sp_format(sp_format):
  function test_check_pandas_sparse_invalid (line 1467) | def test_check_pandas_sparse_invalid(ntype1, ntype2):
  function test_check_pandas_sparse_valid (line 1511) | def test_check_pandas_sparse_valid(ntype1, ntype2, expected_subtype):
  function test_num_features (line 1529) | def test_num_features(constructor_name):
  function test_num_features_errors_1d_containers (line 1548) | def test_num_features_errors_1d_containers(X, constructor_name):
  function test_num_features_errors_scalars (line 1570) | def test_num_features_errors_scalars(X):
  function test_check_array_deprecated_matrix (line 1578) | def test_check_array_deprecated_matrix():
  function test_get_feature_names_pandas_with_ints_no_warning (line 1595) | def test_get_feature_names_pandas_with_ints_no_warning(names):
  function test_get_feature_names_pandas (line 1606) | def test_get_feature_names_pandas():
  function test_get_feature_names_numpy (line 1616) | def test_get_feature_names_numpy():
  function test_get_feature_names_invalid_dtypes_warns (line 1632) | def test_get_feature_names_invalid_dtypes_warns(names, dtypes):
  class PassthroughTransformer (line 1646) | class PassthroughTransformer(BaseEstimator):
    method fit (line 1647) | def fit(self, X, y=None):
    method transform (line 1651) | def transform(self, X):
    method get_feature_names_out (line 1654) | def get_feature_names_out(self, input_features=None):
  function test_check_feature_names_in (line 1658) | def test_check_feature_names_in():
  function test_check_feature_names_in_pandas (line 1676) | def test_check_feature_names_in_pandas():

FILE: sklearn/utils/tests/test_weight_vector.py
  function test_type_invariance (line 16) | def test_type_invariance(dtype, WeightVector):

FILE: sklearn/utils/validation.py
  function _deprecate_positional_args (line 36) | def _deprecate_positional_args(func=None, *, version="1.1 (renaming of 0...
  function _assert_all_finite (line 90) | def _assert_all_finite(
  function assert_all_finite (line 147) | def assert_all_finite(
  function as_float_array (line 179) | def as_float_array(X, *, copy=True, force_all_finite=True):
  function _is_arraylike (line 238) | def _is_arraylike(x):
  function _num_features (line 243) | def _num_features(X):
  function _num_samples (line 296) | def _num_samples(x):
  function check_memory (line 325) | def check_memory(memory):
  function check_consistent_length (line 360) | def check_consistent_length(*arrays):
  function _make_indexable (line 380) | def _make_indexable(iterable):
  function indexable (line 400) | def indexable(*iterables):
  function _ensure_sparse_format (line 424) | def _ensure_sparse_format(
  function _ensure_no_complex_data (line 548) | def _ensure_no_complex_data(array):
  function _check_estimator_name (line 558) | def _check_estimator_name(estimator):
  function _pandas_dtype_needs_early_conversion (line 567) | def _pandas_dtype_needs_early_conversion(pd_dtype):
  function check_array (line 594) | def check_array(
  function _check_large_sparse (line 920) | def _check_large_sparse(X, accept_large_sparse=False):
  function check_X_y (line 939) | def check_X_y(
  function _check_y (line 1081) | def _check_y(y, multi_output=False, y_numeric=False, estimator=None):
  function column_or_1d (line 1104) | def column_or_1d(y, *, warn=False):
  function check_random_state (line 1145) | def check_random_state(seed):
  function has_fit_parameter (line 1167) | def has_fit_parameter(estimator, parameter):
  function check_symmetric (line 1194) | def check_symmetric(array, *, tol=1e-10, raise_warning=True, raise_excep...
  function check_is_fitted (line 1255) | def check_is_fitted(estimator, attributes=None, *, msg=None, all_or_any=...
  function check_non_negative (line 1327) | def check_non_negative(X, whom):
  function check_scalar (line 1354) | def check_scalar(
  function _check_psd_eigenvalues (line 1439) | def _check_psd_eigenvalues(lambdas, enable_warnings=False):
  function _check_sample_weight (line 1612) | def _check_sample_weight(
  function _allclose_dense_sparse (line 1687) | def _allclose_dense_sparse(x, y, rtol=1e-7, atol=1e-9):
  function _check_fit_params (line 1726) | def _check_fit_params(X, fit_params, indices=None):
  function _get_feature_names (line 1766) | def _get_feature_names(X):
  function _check_feature_names_in (line 1814) | def _check_feature_names_in(estimator, input_features=None, *, generate_...
  function _generate_get_feature_names_out (line 1868) | def _generate_get_feature_names_out(estimator, n_features_out, input_fea...