Scikit-learn 官方文档

cluster

  • cluster.AffinityPropagation
  • cluster.AffinityPropagation()
  • cluster.AffinityPropagation.fit()
  • cluster.AffinityPropagation.fit_predict()
  • cluster.AffinityPropagation.get_params()
  • cluster.AffinityPropagation.predict()
  • cluster.AffinityPropagation.set_params()
  • cluster.AffinityPropagation.__init__()
  • cluster.affinity_propagation()
  • cluster.AgglomerativeClustering
  • cluster.AgglomerativeClustering()
  • cluster.AgglomerativeClustering.fit()
  • cluster.AgglomerativeClustering.fit_predict()
  • cluster.AgglomerativeClustering.get_params()
  • cluster.AgglomerativeClustering.set_params()
  • cluster.AgglomerativeClustering.__init__()
  • cluster.Birch
  • cluster.Birch()
  • cluster.Birch.fit()
  • cluster.Birch.fit_predict()
  • cluster.Birch.fit_transform()
  • cluster.Birch.get_params()
  • cluster.Birch.partial_fit()
  • cluster.Birch.predict()
  • cluster.Birch.set_params()
  • cluster.Birch.transform()
  • cluster.Birch.__init__()
  • cluster.DBSCAN
  • cluster.DBSCAN()
  • cluster.DBSCAN.fit()
  • cluster.DBSCAN.fit_predict()
  • cluster.DBSCAN.get_params()
  • cluster.DBSCAN.set_params()
  • cluster.DBSCAN.__init__()
  • cluster.estimate_bandwidth()
  • cluster.FeatureAgglomeration
  • cluster.FeatureAgglomeration()
  • cluster.FeatureAgglomeration.fit()
  • cluster.FeatureAgglomeration.fit_transform()
  • cluster.FeatureAgglomeration.get_params()
  • cluster.FeatureAgglomeration.inverse_transform()
  • cluster.FeatureAgglomeration.pooling_func()
  • cluster.FeatureAgglomeration.set_params()
  • cluster.FeatureAgglomeration.transform()
  • cluster.FeatureAgglomeration.__init__()
  • cluster.KMeans
  • cluster.KMeans()
  • cluster.KMeans.fit()
  • cluster.KMeans.fit_predict()
  • cluster.KMeans.fit_transform()
  • cluster.KMeans.get_params()
  • cluster.KMeans.predict()
  • cluster.KMeans.score()
  • cluster.KMeans.set_params()
  • cluster.KMeans.transform()
  • cluster.KMeans.__init__()
  • cluster.k_means()
  • cluster.MeanShift
  • cluster.MeanShift()
  • cluster.MeanShift.fit()
  • cluster.MeanShift.fit_predict()
  • cluster.MeanShift.get_params()
  • cluster.MeanShift.predict()
  • cluster.MeanShift.set_params()
  • cluster.MeanShift.__init__()
  • cluster.mean_shift()
  • cluster.MiniBatchKMeans
  • cluster.MiniBatchKMeans()
  • cluster.MiniBatchKMeans.fit()
  • cluster.MiniBatchKMeans.fit_predict()
  • cluster.MiniBatchKMeans.fit_transform()
  • cluster.MiniBatchKMeans.get_params()
  • cluster.MiniBatchKMeans.partial_fit()
  • cluster.MiniBatchKMeans.predict()
  • cluster.MiniBatchKMeans.score()
  • cluster.MiniBatchKMeans.set_params()
  • cluster.MiniBatchKMeans.transform()
  • cluster.MiniBatchKMeans.__init__()
  • cluster.SpectralClustering
  • cluster.SpectralClustering()
  • cluster.SpectralClustering.fit()
  • cluster.SpectralClustering.fit_predict()
  • cluster.SpectralClustering.get_params()
  • cluster.SpectralClustering.set_params()
  • cluster.SpectralClustering.__init__()
  • cluster.spectral_clustering()
  • cluster.ward_tree()
  • sklearn.cluster.affinity_propagation()
  • sklearn.cluster.estimate_bandwidth()
  • sklearn.cluster.k_means()
  • sklearn.cluster.mean_shift()
  • sklearn.cluster.spectral_clustering()
  • sklearn.cluster.ward_tree()
  • covariance

  • covariance.EllipticEnvelope
  • covariance.EllipticEnvelope()
  • covariance.EllipticEnvelope.correct_covariance()
  • covariance.EllipticEnvelope.decision_function()
  • covariance.EllipticEnvelope.error_norm()
  • covariance.EllipticEnvelope.get_params()
  • covariance.EllipticEnvelope.get_precision()
  • covariance.EllipticEnvelope.mahalanobis()
  • covariance.EllipticEnvelope.predict()
  • covariance.EllipticEnvelope.reweight_covariance()
  • covariance.EllipticEnvelope.score()
  • covariance.EllipticEnvelope.set_params()
  • covariance.EllipticEnvelope.__init__()
  • covariance.EmpiricalCovariance
  • covariance.EmpiricalCovariance()
  • covariance.EmpiricalCovariance.error_norm()
  • covariance.EmpiricalCovariance.fit()
  • covariance.EmpiricalCovariance.get_params()
  • covariance.EmpiricalCovariance.get_precision()
  • covariance.EmpiricalCovariance.mahalanobis()
  • covariance.EmpiricalCovariance.score()
  • covariance.EmpiricalCovariance.set_params()
  • covariance.EmpiricalCovariance.__init__()
  • covariance.empirical_covariance()
  • covariance.GraphLasso
  • covariance.GraphLasso()
  • covariance.GraphLasso.error_norm()
  • covariance.GraphLasso.get_params()
  • covariance.GraphLasso.get_precision()
  • covariance.GraphLasso.mahalanobis()
  • covariance.GraphLasso.score()
  • covariance.GraphLasso.set_params()
  • covariance.GraphLasso.__init__()
  • covariance.GraphLassoCV
  • covariance.GraphLassoCV()
  • covariance.GraphLassoCV.error_norm()
  • covariance.GraphLassoCV.fit()
  • covariance.GraphLassoCV.get_params()
  • covariance.GraphLassoCV.get_precision()
  • covariance.GraphLassoCV.mahalanobis()
  • covariance.GraphLassoCV.score()
  • covariance.GraphLassoCV.set_params()
  • covariance.GraphLassoCV.__init__()
  • covariance.graph_lasso()
  • covariance.LedoitWolf
  • covariance.LedoitWolf()
  • covariance.LedoitWolf.error_norm()
  • covariance.LedoitWolf.fit()
  • covariance.LedoitWolf.get_params()
  • covariance.LedoitWolf.get_precision()
  • covariance.LedoitWolf.mahalanobis()
  • covariance.LedoitWolf.score()
  • covariance.LedoitWolf.set_params()
  • covariance.LedoitWolf.__init__()
  • covariance.ledoit_wolf()
  • covariance.MinCovDet
  • covariance.MinCovDet()
  • covariance.MinCovDet.correct_covariance()
  • covariance.MinCovDet.error_norm()
  • covariance.MinCovDet.fit()
  • covariance.MinCovDet.get_params()
  • covariance.MinCovDet.get_precision()
  • covariance.MinCovDet.mahalanobis()
  • covariance.MinCovDet.reweight_covariance()
  • covariance.MinCovDet.score()
  • covariance.MinCovDet.set_params()
  • covariance.MinCovDet.__init__()
  • covariance.OAS
  • covariance.OAS()
  • covariance.OAS.error_norm()
  • covariance.OAS.fit()
  • covariance.OAS.get_params()
  • covariance.OAS.get_precision()
  • covariance.OAS.mahalanobis()
  • covariance.OAS.score()
  • covariance.OAS.set_params()
  • covariance.OAS.__init__()
  • covariance.ShrunkCovariance
  • covariance.ShrunkCovariance()
  • covariance.ShrunkCovariance.error_norm()
  • covariance.ShrunkCovariance.fit()
  • covariance.ShrunkCovariance.get_params()
  • covariance.ShrunkCovariance.get_precision()
  • covariance.ShrunkCovariance.mahalanobis()
  • covariance.ShrunkCovariance.score()
  • covariance.ShrunkCovariance.set_params()
  • covariance.ShrunkCovariance.__init__()
  • covariance.shrunk_covariance()
  • sklearn.covariance.empirical_covariance()
  • sklearn.covariance.graph_lasso()
  • sklearn.covariance.ledoit_wolf()
  • sklearn.covariance.shrunk_covariance()
  • datasets

  • datasets.clear_data_home()
  • datasets.dump_svmlight_file()
  • datasets.fetch_20newsgroups()
  • datasets.fetch_20newsgroups_vectorized()
  • datasets.fetch_california_housing()
  • datasets.fetch_covtype()
  • datasets.fetch_kddcup99()
  • datasets.fetch_lfw_pairs()
  • datasets.fetch_lfw_people()
  • datasets.fetch_mldata()
  • datasets.fetch_olivetti_faces()
  • datasets.fetch_rcv1()
  • datasets.fetch_species_distributions()
  • datasets.get_data_home()
  • datasets.load_boston()
  • datasets.load_breast_cancer()
  • datasets.load_diabetes()
  • datasets.load_digits()
  • datasets.load_files()
  • datasets.load_iris()
  • datasets.load_linnerud()
  • datasets.load_mlcomp()
  • datasets.load_sample_image()
  • datasets.load_sample_images()
  • datasets.load_svmlight_file()
  • datasets.load_svmlight_files()
  • datasets.make_biclusters()
  • datasets.make_blobs()
  • datasets.make_checkerboard()
  • datasets.make_circles()
  • datasets.make_classification()
  • datasets.make_friedman1()
  • datasets.make_friedman2()
  • datasets.make_friedman3()
  • datasets.make_gaussian_quantiles()
  • datasets.make_hastie_10_2()
  • datasets.make_low_rank_matrix()
  • datasets.make_moons()
  • datasets.make_multilabel_classification()
  • datasets.make_regression()
  • datasets.make_sparse_coded_signal()
  • datasets.make_sparse_spd_matrix()
  • datasets.make_sparse_uncorrelated()
  • datasets.make_spd_matrix()
  • datasets.make_swiss_roll()
  • datasets.make_s_curve()
  • datasets.mldata_filename()
  • sklearn.datasets.clear_data_home()
  • sklearn.datasets.dump_svmlight_file()
  • sklearn.datasets.fetch_20newsgroups()
  • sklearn.datasets.fetch_20newsgroups_vectorized()
  • sklearn.datasets.fetch_california_housing()
  • sklearn.datasets.fetch_covtype()
  • sklearn.datasets.fetch_kddcup99()
  • sklearn.datasets.fetch_lfw_pairs()
  • sklearn.datasets.fetch_lfw_people()
  • sklearn.datasets.fetch_mldata()
  • sklearn.datasets.fetch_olivetti_faces()
  • sklearn.datasets.fetch_rcv1()
  • sklearn.datasets.fetch_species_distributions()
  • sklearn.datasets.get_data_home()
  • sklearn.datasets.load_boston()
  • sklearn.datasets.load_breast_cancer()
  • sklearn.datasets.load_diabetes()
  • sklearn.datasets.load_digits()
  • sklearn.datasets.load_files()
  • sklearn.datasets.load_iris()
  • sklearn.datasets.load_linnerud()
  • sklearn.datasets.load_mlcomp()
  • sklearn.datasets.load_sample_image()
  • sklearn.datasets.load_sample_images()
  • sklearn.datasets.load_svmlight_file()
  • sklearn.datasets.load_svmlight_files()
  • sklearn.datasets.make_biclusters()
  • sklearn.datasets.make_blobs()
  • sklearn.datasets.make_checkerboard()
  • sklearn.datasets.make_circles()
  • sklearn.datasets.make_classification()
  • sklearn.datasets.make_friedman1()
  • sklearn.datasets.make_friedman2()
  • sklearn.datasets.make_friedman3()
  • sklearn.datasets.make_gaussian_quantiles()
  • sklearn.datasets.make_hastie_10_2()
  • sklearn.datasets.make_low_rank_matrix()
  • sklearn.datasets.make_moons()
  • sklearn.datasets.make_multilabel_classification()
  • sklearn.datasets.make_regression()
  • sklearn.datasets.make_sparse_coded_signal()
  • sklearn.datasets.make_sparse_spd_matrix()
  • sklearn.datasets.make_sparse_uncorrelated()
  • sklearn.datasets.make_spd_matrix()
  • sklearn.datasets.make_swiss_roll()
  • sklearn.datasets.make_s_curve()
  • sklearn.datasets.mldata_filename()
  • decomposition

  • decomposition.DictionaryLearning
  • decomposition.DictionaryLearning()
  • decomposition.DictionaryLearning.fit()
  • decomposition.DictionaryLearning.fit_transform()
  • decomposition.DictionaryLearning.get_params()
  • decomposition.DictionaryLearning.set_params()
  • decomposition.DictionaryLearning.transform()
  • decomposition.DictionaryLearning.__init__()
  • decomposition.dict_learning()
  • decomposition.dict_learning_online()
  • decomposition.FactorAnalysis
  • decomposition.FactorAnalysis()
  • decomposition.FactorAnalysis.fit()
  • decomposition.FactorAnalysis.fit_transform()
  • decomposition.FactorAnalysis.get_covariance()
  • decomposition.FactorAnalysis.get_params()
  • decomposition.FactorAnalysis.get_precision()
  • decomposition.FactorAnalysis.score()
  • decomposition.FactorAnalysis.score_samples()
  • decomposition.FactorAnalysis.set_params()
  • decomposition.FactorAnalysis.transform()
  • decomposition.FactorAnalysis.__init__()
  • decomposition.FastICA
  • decomposition.FastICA()
  • decomposition.FastICA.fit()
  • decomposition.FastICA.fit_transform()
  • decomposition.FastICA.get_params()
  • decomposition.FastICA.inverse_transform()
  • decomposition.FastICA.set_params()
  • decomposition.FastICA.transform()
  • decomposition.FastICA.__init__()
  • decomposition.IncrementalPCA
  • decomposition.IncrementalPCA()
  • decomposition.IncrementalPCA.fit()
  • decomposition.IncrementalPCA.fit_transform()
  • decomposition.IncrementalPCA.get_covariance()
  • decomposition.IncrementalPCA.get_params()
  • decomposition.IncrementalPCA.get_precision()
  • decomposition.IncrementalPCA.inverse_transform()
  • decomposition.IncrementalPCA.partial_fit()
  • decomposition.IncrementalPCA.set_params()
  • decomposition.IncrementalPCA.transform()
  • decomposition.IncrementalPCA.__init__()
  • decomposition.KernelPCA
  • decomposition.KernelPCA()
  • decomposition.KernelPCA.fit()
  • decomposition.KernelPCA.fit_transform()
  • decomposition.KernelPCA.get_params()
  • decomposition.KernelPCA.inverse_transform()
  • decomposition.KernelPCA.set_params()
  • decomposition.KernelPCA.transform()
  • decomposition.KernelPCA.__init__()
  • decomposition.LatentDirichletAllocation
  • decomposition.LatentDirichletAllocation()
  • decomposition.LatentDirichletAllocation.fit()
  • decomposition.LatentDirichletAllocation.fit_transform()
  • decomposition.LatentDirichletAllocation.get_params()
  • decomposition.LatentDirichletAllocation.partial_fit()
  • decomposition.LatentDirichletAllocation.perplexity()
  • decomposition.LatentDirichletAllocation.score()
  • decomposition.LatentDirichletAllocation.set_params()
  • decomposition.LatentDirichletAllocation.transform()
  • decomposition.LatentDirichletAllocation.__init__()
  • decomposition.MiniBatchDictionaryLearning
  • decomposition.MiniBatchDictionaryLearning()
  • decomposition.MiniBatchDictionaryLearning.fit()
  • decomposition.MiniBatchDictionaryLearning.fit_transform()
  • decomposition.MiniBatchDictionaryLearning.get_params()
  • decomposition.MiniBatchDictionaryLearning.partial_fit()
  • decomposition.MiniBatchDictionaryLearning.set_params()
  • decomposition.MiniBatchDictionaryLearning.transform()
  • decomposition.MiniBatchDictionaryLearning.__init__()
  • decomposition.MiniBatchSparsePCA
  • decomposition.MiniBatchSparsePCA()
  • decomposition.MiniBatchSparsePCA.fit()
  • decomposition.MiniBatchSparsePCA.fit_transform()
  • decomposition.MiniBatchSparsePCA.get_params()
  • decomposition.MiniBatchSparsePCA.set_params()
  • decomposition.MiniBatchSparsePCA.transform()
  • decomposition.MiniBatchSparsePCA.__init__()
  • decomposition.NMF
  • decomposition.NMF()
  • decomposition.NMF.fit()
  • decomposition.NMF.fit_transform()
  • decomposition.NMF.get_params()
  • decomposition.NMF.inverse_transform()
  • decomposition.NMF.set_params()
  • decomposition.NMF.transform()
  • decomposition.NMF.__init__()
  • decomposition.PCA
  • decomposition.PCA()
  • decomposition.PCA.fit()
  • decomposition.PCA.fit_transform()
  • decomposition.PCA.get_covariance()
  • decomposition.PCA.get_params()
  • decomposition.PCA.get_precision()
  • decomposition.PCA.inverse_transform()
  • decomposition.PCA.score()
  • decomposition.PCA.score_samples()
  • decomposition.PCA.set_params()
  • decomposition.PCA.transform()
  • decomposition.PCA.__init__()
  • decomposition.ProjectedGradientNMF
  • decomposition.ProjectedGradientNMF()
  • decomposition.ProjectedGradientNMF.fit()
  • decomposition.ProjectedGradientNMF.fit_transform()
  • decomposition.ProjectedGradientNMF.get_params()
  • decomposition.ProjectedGradientNMF.inverse_transform()
  • decomposition.ProjectedGradientNMF.set_params()
  • decomposition.ProjectedGradientNMF.transform()
  • decomposition.ProjectedGradientNMF.__init__()
  • decomposition.RandomizedPCA
  • decomposition.RandomizedPCA()
  • decomposition.RandomizedPCA.fit()
  • decomposition.RandomizedPCA.fit_transform()
  • decomposition.RandomizedPCA.get_params()
  • decomposition.RandomizedPCA.inverse_transform()
  • decomposition.RandomizedPCA.set_params()
  • decomposition.RandomizedPCA.transform()
  • decomposition.RandomizedPCA.__init__()
  • decomposition.SparseCoder
  • decomposition.SparseCoder()
  • decomposition.SparseCoder.fit()
  • decomposition.SparseCoder.fit_transform()
  • decomposition.SparseCoder.get_params()
  • decomposition.SparseCoder.set_params()
  • decomposition.SparseCoder.transform()
  • decomposition.SparseCoder.__init__()
  • decomposition.SparsePCA
  • decomposition.SparsePCA()
  • decomposition.SparsePCA.fit()
  • decomposition.SparsePCA.fit_transform()
  • decomposition.SparsePCA.get_params()
  • decomposition.SparsePCA.set_params()
  • decomposition.SparsePCA.transform()
  • decomposition.SparsePCA.__init__()
  • decomposition.sparse_encode()
  • decomposition.TruncatedSVD
  • decomposition.TruncatedSVD()
  • decomposition.TruncatedSVD.fit()
  • decomposition.TruncatedSVD.fit_transform()
  • decomposition.TruncatedSVD.get_params()
  • decomposition.TruncatedSVD.inverse_transform()
  • decomposition.TruncatedSVD.set_params()
  • decomposition.TruncatedSVD.transform()
  • decomposition.TruncatedSVD.__init__()
  • sklearn.decomposition.dict_learning()
  • sklearn.decomposition.dict_learning_online()
  • sklearn.decomposition.sparse_encode()
  • ensemble

  • ensemble.AdaBoostClassifier
  • ensemble.AdaBoostClassifier()
  • ensemble.AdaBoostClassifier.decision_function()
  • ensemble.AdaBoostClassifier.feature_importances_
  • ensemble.AdaBoostClassifier.fit()
  • ensemble.AdaBoostClassifier.get_params()
  • ensemble.AdaBoostClassifier.predict()
  • ensemble.AdaBoostClassifier.predict_log_proba()
  • ensemble.AdaBoostClassifier.predict_proba()
  • ensemble.AdaBoostClassifier.score()
  • ensemble.AdaBoostClassifier.set_params()
  • ensemble.AdaBoostClassifier.staged_decision_function()
  • ensemble.AdaBoostClassifier.staged_predict()
  • ensemble.AdaBoostClassifier.staged_predict_proba()
  • ensemble.AdaBoostClassifier.staged_score()
  • ensemble.AdaBoostClassifier.__init__()
  • ensemble.AdaBoostRegressor
  • ensemble.AdaBoostRegressor()
  • ensemble.AdaBoostRegressor.feature_importances_
  • ensemble.AdaBoostRegressor.fit()
  • ensemble.AdaBoostRegressor.get_params()
  • ensemble.AdaBoostRegressor.predict()
  • ensemble.AdaBoostRegressor.score()
  • ensemble.AdaBoostRegressor.set_params()
  • ensemble.AdaBoostRegressor.staged_predict()
  • ensemble.AdaBoostRegressor.staged_score()
  • ensemble.AdaBoostRegressor.__init__()
  • ensemble.BaggingClassifier
  • ensemble.BaggingClassifier()
  • ensemble.BaggingClassifier.decision_function()
  • ensemble.BaggingClassifier.estimators_samples_
  • ensemble.BaggingClassifier.fit()
  • ensemble.BaggingClassifier.get_params()
  • ensemble.BaggingClassifier.predict()
  • ensemble.BaggingClassifier.predict_log_proba()
  • ensemble.BaggingClassifier.predict_proba()
  • ensemble.BaggingClassifier.score()
  • ensemble.BaggingClassifier.set_params()
  • ensemble.BaggingClassifier.__init__()
  • ensemble.BaggingRegressor
  • ensemble.BaggingRegressor()
  • ensemble.BaggingRegressor.estimators_samples_
  • ensemble.BaggingRegressor.fit()
  • ensemble.BaggingRegressor.get_params()
  • ensemble.BaggingRegressor.predict()
  • ensemble.BaggingRegressor.score()
  • ensemble.BaggingRegressor.set_params()
  • ensemble.BaggingRegressor.__init__()
  • ensemble.ExtraTreesClassifier
  • ensemble.ExtraTreesClassifier()
  • ensemble.ExtraTreesClassifier.apply()
  • ensemble.ExtraTreesClassifier.decision_path()
  • ensemble.ExtraTreesClassifier.feature_importances_
  • ensemble.ExtraTreesClassifier.fit()
  • ensemble.ExtraTreesClassifier.fit_transform()
  • ensemble.ExtraTreesClassifier.get_params()
  • ensemble.ExtraTreesClassifier.predict()
  • ensemble.ExtraTreesClassifier.predict_log_proba()
  • ensemble.ExtraTreesClassifier.predict_proba()
  • ensemble.ExtraTreesClassifier.score()
  • ensemble.ExtraTreesClassifier.set_params()
  • ensemble.ExtraTreesClassifier.transform()
  • ensemble.ExtraTreesClassifier.__init__()
  • ensemble.ExtraTreesRegressor
  • ensemble.ExtraTreesRegressor()
  • ensemble.ExtraTreesRegressor.apply()
  • ensemble.ExtraTreesRegressor.decision_path()
  • ensemble.ExtraTreesRegressor.feature_importances_
  • ensemble.ExtraTreesRegressor.fit()
  • ensemble.ExtraTreesRegressor.fit_transform()
  • ensemble.ExtraTreesRegressor.get_params()
  • ensemble.ExtraTreesRegressor.predict()
  • ensemble.ExtraTreesRegressor.score()
  • ensemble.ExtraTreesRegressor.set_params()
  • ensemble.ExtraTreesRegressor.transform()
  • ensemble.ExtraTreesRegressor.__init__()
  • ensemble.GradientBoostingClassifier
  • ensemble.GradientBoostingClassifier()
  • ensemble.GradientBoostingClassifier.apply()
  • ensemble.GradientBoostingClassifier.decision_function()
  • ensemble.GradientBoostingClassifier.feature_importances_
  • ensemble.GradientBoostingClassifier.fit()
  • ensemble.GradientBoostingClassifier.fit_transform()
  • ensemble.GradientBoostingClassifier.get_params()
  • ensemble.GradientBoostingClassifier.predict()
  • ensemble.GradientBoostingClassifier.predict_log_proba()
  • ensemble.GradientBoostingClassifier.predict_proba()
  • ensemble.GradientBoostingClassifier.score()
  • ensemble.GradientBoostingClassifier.set_params()
  • ensemble.GradientBoostingClassifier.staged_decision_function()
  • ensemble.GradientBoostingClassifier.staged_predict()
  • ensemble.GradientBoostingClassifier.staged_predict_proba()
  • ensemble.GradientBoostingClassifier.transform()
  • ensemble.GradientBoostingClassifier.__init__()
  • ensemble.GradientBoostingRegressor
  • ensemble.GradientBoostingRegressor()
  • ensemble.GradientBoostingRegressor.apply()
  • ensemble.GradientBoostingRegressor.decision_function()
  • ensemble.GradientBoostingRegressor.feature_importances_
  • ensemble.GradientBoostingRegressor.fit()
  • ensemble.GradientBoostingRegressor.fit_transform()
  • ensemble.GradientBoostingRegressor.get_params()
  • ensemble.GradientBoostingRegressor.predict()
  • ensemble.GradientBoostingRegressor.score()
  • ensemble.GradientBoostingRegressor.set_params()
  • ensemble.GradientBoostingRegressor.staged_decision_function()
  • ensemble.GradientBoostingRegressor.staged_predict()
  • ensemble.GradientBoostingRegressor.transform()
  • ensemble.GradientBoostingRegressor.__init__()
  • ensemble.IsolationForest
  • ensemble.IsolationForest()
  • ensemble.IsolationForest.decision_function()
  • ensemble.IsolationForest.estimators_samples_
  • ensemble.IsolationForest.fit()
  • ensemble.IsolationForest.get_params()
  • ensemble.IsolationForest.predict()
  • ensemble.IsolationForest.set_params()
  • ensemble.IsolationForest.__init__()
  • ensemble.RandomForestClassifier
  • ensemble.RandomForestClassifier()
  • ensemble.RandomForestClassifier.apply()
  • ensemble.RandomForestClassifier.decision_path()
  • ensemble.RandomForestClassifier.feature_importances_
  • ensemble.RandomForestClassifier.fit()
  • ensemble.RandomForestClassifier.fit_transform()
  • ensemble.RandomForestClassifier.get_params()
  • ensemble.RandomForestClassifier.predict()
  • ensemble.RandomForestClassifier.predict_log_proba()
  • ensemble.RandomForestClassifier.predict_proba()
  • ensemble.RandomForestClassifier.score()
  • ensemble.RandomForestClassifier.set_params()
  • ensemble.RandomForestClassifier.transform()
  • ensemble.RandomForestClassifier.__init__()
  • ensemble.RandomForestRegressor
  • ensemble.RandomForestRegressor()
  • ensemble.RandomForestRegressor.apply()
  • ensemble.RandomForestRegressor.decision_path()
  • ensemble.RandomForestRegressor.feature_importances_
  • ensemble.RandomForestRegressor.fit()
  • ensemble.RandomForestRegressor.fit_transform()
  • ensemble.RandomForestRegressor.get_params()
  • ensemble.RandomForestRegressor.predict()
  • ensemble.RandomForestRegressor.score()
  • ensemble.RandomForestRegressor.set_params()
  • ensemble.RandomForestRegressor.transform()
  • ensemble.RandomForestRegressor.__init__()
  • ensemble.RandomTreesEmbedding
  • ensemble.RandomTreesEmbedding()
  • ensemble.RandomTreesEmbedding.apply()
  • ensemble.RandomTreesEmbedding.decision_path()
  • ensemble.RandomTreesEmbedding.feature_importances_
  • ensemble.RandomTreesEmbedding.fit()
  • ensemble.RandomTreesEmbedding.fit_transform()
  • ensemble.RandomTreesEmbedding.get_params()
  • ensemble.RandomTreesEmbedding.set_params()
  • ensemble.RandomTreesEmbedding.transform()
  • ensemble.RandomTreesEmbedding.__init__()
  • ensemble.VotingClassifier
  • ensemble.VotingClassifier()
  • ensemble.VotingClassifier.fit()
  • ensemble.VotingClassifier.fit_transform()
  • ensemble.VotingClassifier.get_params()
  • ensemble.VotingClassifier.predict()
  • ensemble.VotingClassifier.predict_proba
  • ensemble.VotingClassifier.score()
  • ensemble.VotingClassifier.set_params()
  • ensemble.VotingClassifier.transform()
  • ensemble.VotingClassifier.__init__()
  • Examples

  • Example: A demo of K-Means clustering on the handwritten digits data
  • Example: A demo of structured Ward hierarchical clustering on a raccoon face image
  • Example: A demo of the mean-shift clustering algorithm
  • Example: A demo of the Spectral Biclustering algorithm
  • Example: A demo of the Spectral Co-Clustering algorithm
  • Example: Adjustment for chance in clustering performance evaluation
  • Example: Agglomerative clustering with and without structure
  • Example: Agglomerative clustering with different metrics
  • Example: Automatic Relevance Determination Regression
  • Example: Bayesian Ridge Regression
  • Example: Biclustering documents with the Spectral Co-clustering algorithm
  • Example: Blind source separation using FastICA
  • Example: Classification of text documents
  • Example: Classification of text documents using sparse features
  • Example: Classifier comparison
  • Example: Clustering text documents using k-means
  • Example: Color Quantization using K-Means
  • Example: Compare BIRCH and MiniBatchKMeans
  • Example: Compare cross decomposition methods
  • Example: Compare Stochastic learning strategies for MLPClassifier
  • Example: Comparing different clustering algorithms on toy datasets
  • Example: Comparing random forests and the multi-output meta estimator
  • Example: Comparing randomized search and grid search for hyperparameter estimation
  • Example: Comparing various online solvers
  • Example: Comparison of Calibration of Classifiers
  • Example: Comparison of F-test and mutual information
  • Example: Comparison of kernel ridge and Gaussian process regression
  • Example: Comparison of kernel ridge regression and SVR
  • Example: Comparison of LDA and PCA 2D projection of Iris dataset
  • Example: Comparison of Manifold Learning methods
  • Example: Comparison of the K-Means and MiniBatchKMeans clustering algorithms
  • Example: Compressive sensing
  • Example: Concatenating multiple feature extraction methods
  • Example: Concentration Prior Type Analysis of Variation Bayesian Gaussian Mixture
  • Example: Confusion matrix
  • Example: Cross-validation on diabetes Dataset Exercise
  • Example: Cross-validation on Digits Dataset Exercise
  • Example: Decision boundary of label propagation versus SVM on the Iris dataset
  • Example: Decision Tree Regression
  • Example: Decision Tree Regression with AdaBoost
  • Example: Demo of affinity propagation clustering algorithm
  • Example: Demo of DBSCAN clustering algorithm
  • Example: Demonstration of k-means assumptions
  • Example: Density Estimation for a Gaussian mixture
  • Example: Digits Classification Exercise
  • Example: Discrete versus Real AdaBoost
  • Example: Empirical evaluation of the impact of k-means initialization
  • Example: Explicit feature map approximation for RBF kernels
  • Example: Face completion with a multi-output estimators
  • Example: Faces dataset decompositions
  • Example: Faces recognition example using eigenfaces and SVMs
  • Example: FastICA on 2D point clouds
  • Example: Feature agglomeration
  • Example: Feature agglomeration vs. univariate selection
  • Example: Feature importances with forests of trees
  • Example: Feature selection using SelectFromModel and LassoCV
  • Example: Feature transformations with ensembles of trees
  • Example: Feature Union with Heterogeneous Data Sources
  • Example: FeatureHasher and DictVectorizer Comparison
  • Example: Gaussian Mixture Model Ellipsoids
  • Example: Gaussian Mixture Model Selection
  • Example: Gaussian Mixture Model Sine Curve
  • Example: Gaussian process classification on iris dataset
  • Example: Gaussian process regression on Mauna Loa CO2 data.
  • Example: Gaussian process regression with noise-level estimation
  • Example: Gaussian Processes regression
  • Example: GMM covariances
  • Example: Gradient Boosting Out-of-Bag estimates
  • Example: Gradient Boosting regression
  • Example: Gradient Boosting regularization
  • Example: Hashing feature transformation using Totally Random Trees
  • Example: Hierarchical clustering
  • Example: HuberRegressor vs Ridge on dataset with strong outliers
  • Example: Hyper-parameters of Approximate Nearest Neighbors
  • Example: Illustration of Gaussian process classification on the XOR dataset
  • Example: Illustration of prior and posterior Gaussian process for different kernels
  • Example: Image denoising using dictionary learning
  • Example: Imputing missing values before building an estimator
  • Example: Incremental PCA
  • Example: Iso-probability lines for Gaussian Processes classification
  • Example: IsolationForest example
  • Example: Isotonic Regression
  • Example: Joint feature selection with multi-task Lasso
  • Example: K-means Clustering
  • Example: Kernel Density Estimate of Species Distributions
  • Example: Kernel Density Estimation
  • Example: Kernel PCA
  • Example: L1 Penalty and Sparsity in Logistic Regression
  • Example: Label Propagation digits
  • Example: Label Propagation digits active learning
  • Example: Label Propagation learning a complex structure
  • Example: Lasso and Elastic Net
  • Example: Lasso and Elastic Net for Sparse Signals
  • Example: Lasso model selection
  • Example: Lasso on dense and sparse data
  • Example: Lasso path using LARS
  • Example: Ledoit-Wolf vs OAS estimation
  • Example: Libsvm GUI
  • Example: Linear and Quadratic Discriminant Analysis with confidence ellipsoid
  • Example: Linear Regression Example
  • Example: Logistic Regression 3-class Classifier
  • Example: Logit function
  • Example: Manifold Learning methods on a severed sphere
  • Example: Manifold learning on handwritten digits
  • Example: Model Complexity Influence
  • Example: Model selection with Probabilistic PCA and Factor Analysis
  • Example: Multi-class AdaBoosted Decision Trees
  • Example: Multi-dimensional scaling
  • Example: Multi-output Decision Tree Regression
  • Example: Multilabel classification
  • Example: Nearest Centroid Classification
  • Example: Nearest Neighbors Classification
  • Example: Nearest Neighbors regression
  • Example: Nested versus non-nested cross-validation
  • Example: Non-linear SVM
  • Example: Normal and Shrinkage Linear Discriminant Analysis for classification
  • Example: One-class SVM with non-linear kernel
  • Example: Online learning of a dictionary of parts of faces
  • Example: OOB Errors for Random Forests
  • Example: Ordinary Least Squares and Ridge Regression Variance
  • Example: Orthogonal Matching Pursuit
  • Example: Out-of-core classification of text documents
  • Example: Outlier detection on a real data set
  • Example: Outlier detection with several methods.
  • Example: Parameter estimation using grid search with cross-validation
  • Example: Partial Dependence Plots
  • Example: Path with L1- Logistic Regression
  • Example: PCA example with Iris Data-set
  • Example: Pipeline Anova SVM
  • Example: Pipelining
  • Example: Pixel importances with a parallel forest of trees
  • Example: Plot class probabilities calculated by the VotingClassifier
  • Example: Plot classification probability
  • Example: Plot different SVM classifiers in the iris dataset
  • Example: Plot multi-class SGD on the iris dataset
  • Example: Plot multinomial and One-vs-Rest Logistic Regression
  • Example: Plot randomly generated classification dataset
  • Example: Plot randomly generated multilabel dataset
  • Example: Plot Ridge coefficients as a function of the L2 regularization
  • Example: Plot Ridge coefficients as a function of the regularization
  • Example: Plot the decision boundaries of a VotingClassifier
  • Example: Plot the decision surface of a decision tree on the iris dataset
  • Example: Plot the decision surfaces of ensembles of trees on the iris dataset
  • Example: Plotting Cross-Validated Predictions
  • Example: Plotting Learning Curves
  • Example: Plotting Validation Curves
  • Example: Polynomial interpolation
  • Example: Precision-Recall
  • Example: Prediction Intervals for Gradient Boosting Regression
  • Example: Prediction Latency
  • Example: Principal components analysis
  • Example: Probabilistic predictions with Gaussian process classification
  • Example: Probability Calibration curves
  • Example: Probability Calibration for 3-class classification
  • Example: Probability calibration of classifiers
  • Example: RBF SVM parameters
  • Example: Receiver Operating Characteristic
  • Example: Receiver Operating Characteristic with cross validation
  • Example: Recognizing hand-written digits
  • Example: Recursive feature elimination
  • Example: Recursive feature elimination with cross-validation
  • Example: Restricted Boltzmann Machine features for digit classification
  • Example: Robust covariance estimation and Mahalanobis distances relevance
  • Example: Robust linear estimator fitting
  • Example: Robust linear model estimation using RANSAC
  • Example: Robust Scaling on Toy Data
  • Example: Robust vs Empirical covariance estimate
  • Example: Sample pipeline for text feature extraction and evaluation
  • Example: Scalability of Approximate Nearest Neighbors
  • Example: Scaling the regularization parameter for SVCs
  • Example: Segmenting the picture of a raccoon face in regions
  • Example: Selecting dimensionality reduction with Pipeline and GridSearchCV
  • Example: Selecting the number of clusters with silhouette analysis on KMeans clustering
  • Example: SGD: convex loss functions
  • Example: SGD: Maximum margin separating hyperplane
  • Example: SGD: Penalties
  • Example: SGD: Weighted samples
  • Example: Shrinkage covariance estimation
  • Example: Simple 1D Kernel Density Estimation
  • Example: Single estimator versus bagging
  • Example: Sparse coding with a precomputed dictionary
  • Example: Sparse inverse covariance estimation
  • Example: Sparse recovery
  • Example: Sparsity Example
  • Example: Species distribution modeling
  • Example: Spectral clustering for image segmentation
  • Example: Support Vector Regression using linear and non-linear kernels
  • Example: SVM Exercise
  • Example: SVM Margins Example
  • Example: SVM with custom kernel
  • Example: SVM-Anova
  • Example: SVM-Kernels
  • Example: SVM: Maximum margin separating hyperplane
  • Example: SVM: Separating hyperplane for unbalanced classes
  • Example: SVM: Weighted samples
  • Example: Swiss Roll reduction with LLE
  • Example: Test with permutations the significance of a classification score
  • Example: The Digit Dataset
  • Example: The Iris Dataset
  • Example: The Johnson-Lindenstrauss bound for embedding with random projections
  • Example: Theil-Sen Regression
  • Example: Topic extraction with Non-negative Matrix Factorization and Latent Dirichlet Allocation
  • Example: Train error vs Test error
  • Example: Two-class AdaBoost
  • Example: Underfitting vs. Overfitting
  • Example: Understanding the decision tree structure
  • Example: Univariate Feature Selection
  • Example: Using FunctionTransformer to select columns
  • Example: Various Agglomerative Clustering on a 2D embedding of digits
  • Example: Varying regularization in Multi-layer Perceptron
  • Example: Vector Quantization Example
  • Example: Visualization of MLP weights on MNIST
  • Example: Visualizing the stock market structure
  • feature_extraction.text

  • feature_extraction.text.CountVectorizer
  • feature_extraction.text.CountVectorizer()
  • feature_extraction.text.CountVectorizer.build_analyzer()
  • feature_extraction.text.CountVectorizer.build_preprocessor()
  • feature_extraction.text.CountVectorizer.build_tokenizer()
  • feature_extraction.text.CountVectorizer.decode()
  • feature_extraction.text.CountVectorizer.fit()
  • feature_extraction.text.CountVectorizer.fit_transform()
  • feature_extraction.text.CountVectorizer.get_feature_names()
  • feature_extraction.text.CountVectorizer.get_params()
  • feature_extraction.text.CountVectorizer.get_stop_words()
  • feature_extraction.text.CountVectorizer.inverse_transform()
  • feature_extraction.text.CountVectorizer.set_params()
  • feature_extraction.text.CountVectorizer.transform()
  • feature_extraction.text.CountVectorizer.__init__()
  • feature_extraction.text.HashingVectorizer
  • feature_extraction.text.HashingVectorizer()
  • feature_extraction.text.HashingVectorizer.build_analyzer()
  • feature_extraction.text.HashingVectorizer.build_preprocessor()
  • feature_extraction.text.HashingVectorizer.build_tokenizer()
  • feature_extraction.text.HashingVectorizer.decode()
  • feature_extraction.text.HashingVectorizer.fit()
  • feature_extraction.text.HashingVectorizer.fit_transform()
  • feature_extraction.text.HashingVectorizer.get_params()
  • feature_extraction.text.HashingVectorizer.get_stop_words()
  • feature_extraction.text.HashingVectorizer.partial_fit()
  • feature_extraction.text.HashingVectorizer.set_params()
  • feature_extraction.text.HashingVectorizer.transform()
  • feature_extraction.text.HashingVectorizer.__init__()
  • feature_extraction.text.TfidfTransformer
  • feature_extraction.text.TfidfTransformer()
  • feature_extraction.text.TfidfTransformer.fit()
  • feature_extraction.text.TfidfTransformer.fit_transform()
  • feature_extraction.text.TfidfTransformer.get_params()
  • feature_extraction.text.TfidfTransformer.set_params()
  • feature_extraction.text.TfidfTransformer.transform()
  • feature_extraction.text.TfidfTransformer.__init__()
  • feature_extraction.text.TfidfVectorizer
  • feature_extraction.text.TfidfVectorizer()
  • feature_extraction.text.TfidfVectorizer.build_analyzer()
  • feature_extraction.text.TfidfVectorizer.build_preprocessor()
  • feature_extraction.text.TfidfVectorizer.build_tokenizer()
  • feature_extraction.text.TfidfVectorizer.decode()
  • feature_extraction.text.TfidfVectorizer.fit()
  • feature_extraction.text.TfidfVectorizer.fit_transform()
  • feature_extraction.text.TfidfVectorizer.get_feature_names()
  • feature_extraction.text.TfidfVectorizer.get_params()
  • feature_extraction.text.TfidfVectorizer.get_stop_words()
  • feature_extraction.text.TfidfVectorizer.inverse_transform()
  • feature_extraction.text.TfidfVectorizer.set_params()
  • feature_extraction.text.TfidfVectorizer.transform()
  • feature_extraction.text.TfidfVectorizer.__init__()
  • feature_selection

  • feature_selection.chi2()
  • feature_selection.f_classif()
  • feature_selection.f_regression()
  • feature_selection.GenericUnivariateSelect
  • feature_selection.GenericUnivariateSelect()
  • feature_selection.GenericUnivariateSelect.fit()
  • feature_selection.GenericUnivariateSelect.fit_transform()
  • feature_selection.GenericUnivariateSelect.get_params()
  • feature_selection.GenericUnivariateSelect.get_support()
  • feature_selection.GenericUnivariateSelect.inverse_transform()
  • feature_selection.GenericUnivariateSelect.set_params()
  • feature_selection.GenericUnivariateSelect.transform()
  • feature_selection.GenericUnivariateSelect.__init__()
  • feature_selection.mutual_info_classif()
  • feature_selection.mutual_info_regression()
  • feature_selection.RFE
  • feature_selection.RFE()
  • feature_selection.RFE.fit()
  • feature_selection.RFE.fit_transform()
  • feature_selection.RFE.get_params()
  • feature_selection.RFE.get_support()
  • feature_selection.RFE.inverse_transform()
  • feature_selection.RFE.predict()
  • feature_selection.RFE.score()
  • feature_selection.RFE.set_params()
  • feature_selection.RFE.transform()
  • feature_selection.RFE.__init__()
  • feature_selection.RFECV
  • feature_selection.RFECV()
  • feature_selection.RFECV.fit()
  • feature_selection.RFECV.fit_transform()
  • feature_selection.RFECV.get_params()
  • feature_selection.RFECV.get_support()
  • feature_selection.RFECV.inverse_transform()
  • feature_selection.RFECV.predict()
  • feature_selection.RFECV.score()
  • feature_selection.RFECV.set_params()
  • feature_selection.RFECV.transform()
  • feature_selection.RFECV.__init__()
  • feature_selection.SelectFdr
  • feature_selection.SelectFdr()
  • feature_selection.SelectFdr.fit()
  • feature_selection.SelectFdr.fit_transform()
  • feature_selection.SelectFdr.get_params()
  • feature_selection.SelectFdr.get_support()
  • feature_selection.SelectFdr.inverse_transform()
  • feature_selection.SelectFdr.set_params()
  • feature_selection.SelectFdr.transform()
  • feature_selection.SelectFdr.__init__()
  • feature_selection.SelectFpr
  • feature_selection.SelectFpr()
  • feature_selection.SelectFpr.fit()
  • feature_selection.SelectFpr.fit_transform()
  • feature_selection.SelectFpr.get_params()
  • feature_selection.SelectFpr.get_support()
  • feature_selection.SelectFpr.inverse_transform()
  • feature_selection.SelectFpr.set_params()
  • feature_selection.SelectFpr.transform()
  • feature_selection.SelectFpr.__init__()
  • feature_selection.SelectFromModel
  • feature_selection.SelectFromModel()
  • feature_selection.SelectFromModel.fit()
  • feature_selection.SelectFromModel.fit_transform()
  • feature_selection.SelectFromModel.get_params()
  • feature_selection.SelectFromModel.get_support()
  • feature_selection.SelectFromModel.inverse_transform()
  • feature_selection.SelectFromModel.partial_fit()
  • feature_selection.SelectFromModel.set_params()
  • feature_selection.SelectFromModel.transform()
  • feature_selection.SelectFromModel.__init__()
  • feature_selection.SelectFwe
  • feature_selection.SelectFwe()
  • feature_selection.SelectFwe.fit()
  • feature_selection.SelectFwe.fit_transform()
  • feature_selection.SelectFwe.get_params()
  • feature_selection.SelectFwe.get_support()
  • feature_selection.SelectFwe.inverse_transform()
  • feature_selection.SelectFwe.set_params()
  • feature_selection.SelectFwe.transform()
  • feature_selection.SelectFwe.__init__()
  • feature_selection.SelectKBest
  • feature_selection.SelectKBest()
  • feature_selection.SelectKBest.fit()
  • feature_selection.SelectKBest.fit_transform()
  • feature_selection.SelectKBest.get_params()
  • feature_selection.SelectKBest.get_support()
  • feature_selection.SelectKBest.inverse_transform()
  • feature_selection.SelectKBest.set_params()
  • feature_selection.SelectKBest.transform()
  • feature_selection.SelectKBest.__init__()
  • feature_selection.SelectPercentile
  • feature_selection.SelectPercentile()
  • feature_selection.SelectPercentile.fit()
  • feature_selection.SelectPercentile.fit_transform()
  • feature_selection.SelectPercentile.get_params()
  • feature_selection.SelectPercentile.get_support()
  • feature_selection.SelectPercentile.inverse_transform()
  • feature_selection.SelectPercentile.set_params()
  • feature_selection.SelectPercentile.transform()
  • feature_selection.SelectPercentile.__init__()
  • feature_selection.VarianceThreshold
  • feature_selection.VarianceThreshold()
  • feature_selection.VarianceThreshold.fit()
  • feature_selection.VarianceThreshold.fit_transform()
  • feature_selection.VarianceThreshold.get_params()
  • feature_selection.VarianceThreshold.get_support()
  • feature_selection.VarianceThreshold.inverse_transform()
  • feature_selection.VarianceThreshold.set_params()
  • feature_selection.VarianceThreshold.transform()
  • feature_selection.VarianceThreshold.__init__()
  • sklearn.feature_selection.chi2()
  • sklearn.feature_selection.f_classif()
  • sklearn.feature_selection.f_regression()
  • sklearn.feature_selection.mutual_info_classif()
  • sklearn.feature_selection.mutual_info_regression()
  • gaussian_process.kernels

  • gaussian_process.kernels.CompoundKernel
  • gaussian_process.kernels.CompoundKernel()
  • gaussian_process.kernels.CompoundKernel.bounds
  • gaussian_process.kernels.CompoundKernel.clone_with_theta()
  • gaussian_process.kernels.CompoundKernel.diag()
  • gaussian_process.kernels.CompoundKernel.get_params()
  • gaussian_process.kernels.CompoundKernel.hyperparameters
  • gaussian_process.kernels.CompoundKernel.is_stationary()
  • gaussian_process.kernels.CompoundKernel.n_dims
  • gaussian_process.kernels.CompoundKernel.set_params()
  • gaussian_process.kernels.CompoundKernel.theta
  • gaussian_process.kernels.CompoundKernel.__init__()
  • gaussian_process.kernels.ConstantKernel
  • gaussian_process.kernels.ConstantKernel()
  • gaussian_process.kernels.ConstantKernel.bounds
  • gaussian_process.kernels.ConstantKernel.clone_with_theta()
  • gaussian_process.kernels.ConstantKernel.diag()
  • gaussian_process.kernels.ConstantKernel.get_params()
  • gaussian_process.kernels.ConstantKernel.hyperparameters
  • gaussian_process.kernels.ConstantKernel.is_stationary()
  • gaussian_process.kernels.ConstantKernel.n_dims
  • gaussian_process.kernels.ConstantKernel.set_params()
  • gaussian_process.kernels.ConstantKernel.theta
  • gaussian_process.kernels.ConstantKernel.__init__()
  • gaussian_process.kernels.DotProduct
  • gaussian_process.kernels.DotProduct()
  • gaussian_process.kernels.DotProduct.bounds
  • gaussian_process.kernels.DotProduct.clone_with_theta()
  • gaussian_process.kernels.DotProduct.diag()
  • gaussian_process.kernels.DotProduct.get_params()
  • gaussian_process.kernels.DotProduct.hyperparameters
  • gaussian_process.kernels.DotProduct.is_stationary()
  • gaussian_process.kernels.DotProduct.n_dims
  • gaussian_process.kernels.DotProduct.set_params()
  • gaussian_process.kernels.DotProduct.theta
  • gaussian_process.kernels.DotProduct.__init__()
  • gaussian_process.kernels.Exponentiation
  • gaussian_process.kernels.Exponentiation()
  • gaussian_process.kernels.Exponentiation.bounds
  • gaussian_process.kernels.Exponentiation.clone_with_theta()
  • gaussian_process.kernels.Exponentiation.diag()
  • gaussian_process.kernels.Exponentiation.get_params()
  • gaussian_process.kernels.Exponentiation.hyperparameters
  • gaussian_process.kernels.Exponentiation.is_stationary()
  • gaussian_process.kernels.Exponentiation.n_dims
  • gaussian_process.kernels.Exponentiation.set_params()
  • gaussian_process.kernels.Exponentiation.theta
  • gaussian_process.kernels.Exponentiation.__init__()
  • gaussian_process.kernels.ExpSineSquared
  • gaussian_process.kernels.ExpSineSquared()
  • gaussian_process.kernels.ExpSineSquared.bounds
  • gaussian_process.kernels.ExpSineSquared.clone_with_theta()
  • gaussian_process.kernels.ExpSineSquared.diag()
  • gaussian_process.kernels.ExpSineSquared.get_params()
  • gaussian_process.kernels.ExpSineSquared.hyperparameters
  • gaussian_process.kernels.ExpSineSquared.is_stationary()
  • gaussian_process.kernels.ExpSineSquared.n_dims
  • gaussian_process.kernels.ExpSineSquared.set_params()
  • gaussian_process.kernels.ExpSineSquared.theta
  • gaussian_process.kernels.ExpSineSquared.__init__()
  • gaussian_process.kernels.Hyperparameter
  • gaussian_process.kernels.Hyperparameter
  • gaussian_process.kernels.Hyperparameter.bounds
  • gaussian_process.kernels.Hyperparameter.count()
  • gaussian_process.kernels.Hyperparameter.fixed
  • gaussian_process.kernels.Hyperparameter.index()
  • gaussian_process.kernels.Hyperparameter.name
  • gaussian_process.kernels.Hyperparameter.n_elements
  • gaussian_process.kernels.Hyperparameter.value_type
  • gaussian_process.kernels.Hyperparameter.__init__()
  • gaussian_process.kernels.Kernel
  • gaussian_process.kernels.Kernel
  • gaussian_process.kernels.Kernel.bounds
  • gaussian_process.kernels.Kernel.clone_with_theta()
  • gaussian_process.kernels.Kernel.diag()
  • gaussian_process.kernels.Kernel.get_params()
  • gaussian_process.kernels.Kernel.hyperparameters
  • gaussian_process.kernels.Kernel.is_stationary()
  • gaussian_process.kernels.Kernel.n_dims
  • gaussian_process.kernels.Kernel.set_params()
  • gaussian_process.kernels.Kernel.theta
  • gaussian_process.kernels.Kernel.__init__()
  • gaussian_process.kernels.Matern
  • gaussian_process.kernels.Matern()
  • gaussian_process.kernels.Matern.bounds
  • gaussian_process.kernels.Matern.clone_with_theta()
  • gaussian_process.kernels.Matern.diag()
  • gaussian_process.kernels.Matern.get_params()
  • gaussian_process.kernels.Matern.hyperparameters
  • gaussian_process.kernels.Matern.is_stationary()
  • gaussian_process.kernels.Matern.n_dims
  • gaussian_process.kernels.Matern.set_params()
  • gaussian_process.kernels.Matern.theta
  • gaussian_process.kernels.Matern.__init__()
  • gaussian_process.kernels.PairwiseKernel
  • gaussian_process.kernels.PairwiseKernel()
  • gaussian_process.kernels.PairwiseKernel.bounds
  • gaussian_process.kernels.PairwiseKernel.clone_with_theta()
  • gaussian_process.kernels.PairwiseKernel.diag()
  • gaussian_process.kernels.PairwiseKernel.get_params()
  • gaussian_process.kernels.PairwiseKernel.hyperparameters
  • gaussian_process.kernels.PairwiseKernel.is_stationary()
  • gaussian_process.kernels.PairwiseKernel.n_dims
  • gaussian_process.kernels.PairwiseKernel.set_params()
  • gaussian_process.kernels.PairwiseKernel.theta
  • gaussian_process.kernels.PairwiseKernel.__init__()
  • gaussian_process.kernels.Product
  • gaussian_process.kernels.Product()
  • gaussian_process.kernels.Product.bounds
  • gaussian_process.kernels.Product.clone_with_theta()
  • gaussian_process.kernels.Product.diag()
  • gaussian_process.kernels.Product.get_params()
  • gaussian_process.kernels.Product.hyperparameters
  • gaussian_process.kernels.Product.is_stationary()
  • gaussian_process.kernels.Product.n_dims
  • gaussian_process.kernels.Product.set_params()
  • gaussian_process.kernels.Product.theta
  • gaussian_process.kernels.Product.__init__()
  • gaussian_process.kernels.RationalQuadratic
  • gaussian_process.kernels.RationalQuadratic()
  • gaussian_process.kernels.RationalQuadratic.bounds
  • gaussian_process.kernels.RationalQuadratic.clone_with_theta()
  • gaussian_process.kernels.RationalQuadratic.diag()
  • gaussian_process.kernels.RationalQuadratic.get_params()
  • gaussian_process.kernels.RationalQuadratic.hyperparameters
  • gaussian_process.kernels.RationalQuadratic.is_stationary()
  • gaussian_process.kernels.RationalQuadratic.n_dims
  • gaussian_process.kernels.RationalQuadratic.set_params()
  • gaussian_process.kernels.RationalQuadratic.theta
  • gaussian_process.kernels.RationalQuadratic.__init__()
  • gaussian_process.kernels.RBF
  • gaussian_process.kernels.RBF()
  • gaussian_process.kernels.RBF.bounds
  • gaussian_process.kernels.RBF.clone_with_theta()
  • gaussian_process.kernels.RBF.diag()
  • gaussian_process.kernels.RBF.get_params()
  • gaussian_process.kernels.RBF.hyperparameters
  • gaussian_process.kernels.RBF.is_stationary()
  • gaussian_process.kernels.RBF.n_dims
  • gaussian_process.kernels.RBF.set_params()
  • gaussian_process.kernels.RBF.theta
  • gaussian_process.kernels.RBF.__init__()
  • gaussian_process.kernels.Sum
  • gaussian_process.kernels.Sum()
  • gaussian_process.kernels.Sum.bounds
  • gaussian_process.kernels.Sum.clone_with_theta()
  • gaussian_process.kernels.Sum.diag()
  • gaussian_process.kernels.Sum.get_params()
  • gaussian_process.kernels.Sum.hyperparameters
  • gaussian_process.kernels.Sum.is_stationary()
  • gaussian_process.kernels.Sum.n_dims
  • gaussian_process.kernels.Sum.set_params()
  • gaussian_process.kernels.Sum.theta
  • gaussian_process.kernels.Sum.__init__()
  • gaussian_process.kernels.WhiteKernel
  • gaussian_process.kernels.WhiteKernel()
  • gaussian_process.kernels.WhiteKernel.bounds
  • gaussian_process.kernels.WhiteKernel.clone_with_theta()
  • gaussian_process.kernels.WhiteKernel.diag()
  • gaussian_process.kernels.WhiteKernel.get_params()
  • gaussian_process.kernels.WhiteKernel.hyperparameters
  • gaussian_process.kernels.WhiteKernel.is_stationary()
  • gaussian_process.kernels.WhiteKernel.n_dims
  • gaussian_process.kernels.WhiteKernel.set_params()
  • gaussian_process.kernels.WhiteKernel.theta
  • gaussian_process.kernels.WhiteKernel.__init__()
  • linear_model

  • linear_model.ARDRegression
  • linear_model.ARDRegression()
  • linear_model.ARDRegression.decision_function()
  • linear_model.ARDRegression.fit()
  • linear_model.ARDRegression.get_params()
  • linear_model.ARDRegression.predict()
  • linear_model.ARDRegression.score()
  • linear_model.ARDRegression.set_params()
  • linear_model.ARDRegression.__init__()
  • linear_model.BayesianRidge
  • linear_model.BayesianRidge()
  • linear_model.BayesianRidge.decision_function()
  • linear_model.BayesianRidge.fit()
  • linear_model.BayesianRidge.get_params()
  • linear_model.BayesianRidge.predict()
  • linear_model.BayesianRidge.score()
  • linear_model.BayesianRidge.set_params()
  • linear_model.BayesianRidge.__init__()
  • linear_model.ElasticNet
  • linear_model.ElasticNet()
  • linear_model.ElasticNet.decision_function()
  • linear_model.ElasticNet.fit()
  • linear_model.ElasticNet.get_params()
  • linear_model.ElasticNet.predict()
  • linear_model.ElasticNet.score()
  • linear_model.ElasticNet.set_params()
  • linear_model.ElasticNet.sparse_coef_
  • linear_model.ElasticNet.__init__()
  • linear_model.ElasticNetCV
  • linear_model.ElasticNetCV()
  • linear_model.ElasticNetCV.decision_function()
  • linear_model.ElasticNetCV.fit()
  • linear_model.ElasticNetCV.get_params()
  • linear_model.ElasticNetCV.predict()
  • linear_model.ElasticNetCV.score()
  • linear_model.ElasticNetCV.set_params()
  • linear_model.ElasticNetCV.__init__()
  • linear_model.HuberRegressor
  • linear_model.HuberRegressor()
  • linear_model.HuberRegressor.decision_function()
  • linear_model.HuberRegressor.fit()
  • linear_model.HuberRegressor.get_params()
  • linear_model.HuberRegressor.predict()
  • linear_model.HuberRegressor.score()
  • linear_model.HuberRegressor.set_params()
  • linear_model.HuberRegressor.__init__()
  • linear_model.Lars
  • linear_model.Lars()
  • linear_model.Lars.decision_function()
  • linear_model.Lars.fit()
  • linear_model.Lars.get_params()
  • linear_model.Lars.predict()
  • linear_model.Lars.score()
  • linear_model.Lars.set_params()
  • linear_model.Lars.__init__()
  • linear_model.LarsCV
  • linear_model.LarsCV()
  • linear_model.LarsCV.decision_function()
  • linear_model.LarsCV.fit()
  • linear_model.LarsCV.get_params()
  • linear_model.LarsCV.predict()
  • linear_model.LarsCV.score()
  • linear_model.LarsCV.set_params()
  • linear_model.LarsCV.__init__()
  • linear_model.lars_path()
  • linear_model.Lasso
  • linear_model.Lasso()
  • linear_model.Lasso.decision_function()
  • linear_model.Lasso.fit()
  • linear_model.Lasso.get_params()
  • linear_model.Lasso.predict()
  • linear_model.Lasso.score()
  • linear_model.Lasso.set_params()
  • linear_model.Lasso.sparse_coef_
  • linear_model.Lasso.__init__()
  • linear_model.LassoCV
  • linear_model.LassoCV()
  • linear_model.LassoCV.decision_function()
  • linear_model.LassoCV.fit()
  • linear_model.LassoCV.get_params()
  • linear_model.LassoCV.predict()
  • linear_model.LassoCV.score()
  • linear_model.LassoCV.set_params()
  • linear_model.LassoCV.__init__()
  • linear_model.LassoLars
  • linear_model.LassoLars()
  • linear_model.LassoLars.decision_function()
  • linear_model.LassoLars.fit()
  • linear_model.LassoLars.get_params()
  • linear_model.LassoLars.predict()
  • linear_model.LassoLars.score()
  • linear_model.LassoLars.set_params()
  • linear_model.LassoLars.__init__()
  • linear_model.LassoLarsCV
  • linear_model.LassoLarsCV()
  • linear_model.LassoLarsCV.decision_function()
  • linear_model.LassoLarsCV.fit()
  • linear_model.LassoLarsCV.get_params()
  • linear_model.LassoLarsCV.predict()
  • linear_model.LassoLarsCV.score()
  • linear_model.LassoLarsCV.set_params()
  • linear_model.LassoLarsCV.__init__()
  • linear_model.LassoLarsIC
  • linear_model.LassoLarsIC()
  • linear_model.LassoLarsIC.decision_function()
  • linear_model.LassoLarsIC.fit()
  • linear_model.LassoLarsIC.get_params()
  • linear_model.LassoLarsIC.predict()
  • linear_model.LassoLarsIC.score()
  • linear_model.LassoLarsIC.set_params()
  • linear_model.LassoLarsIC.__init__()
  • linear_model.lasso_path()
  • linear_model.lasso_stability_path()
  • linear_model.LinearRegression
  • linear_model.LinearRegression()
  • linear_model.LinearRegression.decision_function()
  • linear_model.LinearRegression.fit()
  • linear_model.LinearRegression.get_params()
  • linear_model.LinearRegression.predict()
  • linear_model.LinearRegression.residues_
  • linear_model.LinearRegression.score()
  • linear_model.LinearRegression.set_params()
  • linear_model.LinearRegression.__init__()
  • linear_model.LogisticRegression
  • linear_model.LogisticRegression()
  • linear_model.LogisticRegression.decision_function()
  • linear_model.LogisticRegression.densify()
  • linear_model.LogisticRegression.fit()
  • linear_model.LogisticRegression.fit_transform()
  • linear_model.LogisticRegression.get_params()
  • linear_model.LogisticRegression.predict()
  • linear_model.LogisticRegression.predict_log_proba()
  • linear_model.LogisticRegression.predict_proba()
  • linear_model.LogisticRegression.score()
  • linear_model.LogisticRegression.set_params()
  • linear_model.LogisticRegression.sparsify()
  • linear_model.LogisticRegression.transform()
  • linear_model.LogisticRegression.__init__()
  • linear_model.LogisticRegressionCV
  • linear_model.LogisticRegressionCV()
  • linear_model.LogisticRegressionCV.decision_function()
  • linear_model.LogisticRegressionCV.densify()
  • linear_model.LogisticRegressionCV.fit()
  • linear_model.LogisticRegressionCV.fit_transform()
  • linear_model.LogisticRegressionCV.get_params()
  • linear_model.LogisticRegressionCV.predict()
  • linear_model.LogisticRegressionCV.predict_log_proba()
  • linear_model.LogisticRegressionCV.predict_proba()
  • linear_model.LogisticRegressionCV.score()
  • linear_model.LogisticRegressionCV.set_params()
  • linear_model.LogisticRegressionCV.sparsify()
  • linear_model.LogisticRegressionCV.transform()
  • linear_model.LogisticRegressionCV.__init__()
  • linear_model.logistic_regression_path()
  • linear_model.MultiTaskElasticNet
  • linear_model.MultiTaskElasticNet()
  • linear_model.MultiTaskElasticNet.decision_function()
  • linear_model.MultiTaskElasticNet.fit()
  • linear_model.MultiTaskElasticNet.get_params()
  • linear_model.MultiTaskElasticNet.path()
  • linear_model.MultiTaskElasticNet.predict()
  • linear_model.MultiTaskElasticNet.score()
  • linear_model.MultiTaskElasticNet.set_params()
  • linear_model.MultiTaskElasticNet.sparse_coef_
  • linear_model.MultiTaskElasticNet.__init__()
  • linear_model.MultiTaskElasticNetCV
  • linear_model.MultiTaskElasticNetCV()
  • linear_model.MultiTaskElasticNetCV.decision_function()
  • linear_model.MultiTaskElasticNetCV.fit()
  • linear_model.MultiTaskElasticNetCV.get_params()
  • linear_model.MultiTaskElasticNetCV.predict()
  • linear_model.MultiTaskElasticNetCV.score()
  • linear_model.MultiTaskElasticNetCV.set_params()
  • linear_model.MultiTaskElasticNetCV.__init__()
  • linear_model.MultiTaskLasso
  • linear_model.MultiTaskLasso()
  • linear_model.MultiTaskLasso.decision_function()
  • linear_model.MultiTaskLasso.fit()
  • linear_model.MultiTaskLasso.get_params()
  • linear_model.MultiTaskLasso.path()
  • linear_model.MultiTaskLasso.predict()
  • linear_model.MultiTaskLasso.score()
  • linear_model.MultiTaskLasso.set_params()
  • linear_model.MultiTaskLasso.sparse_coef_
  • linear_model.MultiTaskLasso.__init__()
  • linear_model.MultiTaskLassoCV
  • linear_model.MultiTaskLassoCV()
  • linear_model.MultiTaskLassoCV.decision_function()
  • linear_model.MultiTaskLassoCV.fit()
  • linear_model.MultiTaskLassoCV.get_params()
  • linear_model.MultiTaskLassoCV.predict()
  • linear_model.MultiTaskLassoCV.score()
  • linear_model.MultiTaskLassoCV.set_params()
  • linear_model.MultiTaskLassoCV.__init__()
  • linear_model.OrthogonalMatchingPursuit
  • linear_model.OrthogonalMatchingPursuit()
  • linear_model.OrthogonalMatchingPursuit.decision_function()
  • linear_model.OrthogonalMatchingPursuit.fit()
  • linear_model.OrthogonalMatchingPursuit.get_params()
  • linear_model.OrthogonalMatchingPursuit.predict()
  • linear_model.OrthogonalMatchingPursuit.score()
  • linear_model.OrthogonalMatchingPursuit.set_params()
  • linear_model.OrthogonalMatchingPursuit.__init__()
  • linear_model.OrthogonalMatchingPursuitCV
  • linear_model.OrthogonalMatchingPursuitCV()
  • linear_model.OrthogonalMatchingPursuitCV.decision_function()
  • linear_model.OrthogonalMatchingPursuitCV.fit()
  • linear_model.OrthogonalMatchingPursuitCV.get_params()
  • linear_model.OrthogonalMatchingPursuitCV.predict()
  • linear_model.OrthogonalMatchingPursuitCV.score()
  • linear_model.OrthogonalMatchingPursuitCV.set_params()
  • linear_model.OrthogonalMatchingPursuitCV.__init__()
  • linear_model.orthogonal_mp()
  • linear_model.orthogonal_mp_gram()
  • linear_model.PassiveAggressiveClassifier
  • linear_model.PassiveAggressiveClassifier()
  • linear_model.PassiveAggressiveClassifier.decision_function()
  • linear_model.PassiveAggressiveClassifier.densify()
  • linear_model.PassiveAggressiveClassifier.fit()
  • linear_model.PassiveAggressiveClassifier.get_params()
  • linear_model.PassiveAggressiveClassifier.partial_fit()
  • linear_model.PassiveAggressiveClassifier.predict()
  • linear_model.PassiveAggressiveClassifier.score()
  • linear_model.PassiveAggressiveClassifier.sparsify()
  • linear_model.PassiveAggressiveClassifier.__init__()
  • linear_model.PassiveAggressiveRegressor
  • linear_model.PassiveAggressiveRegressor()
  • linear_model.PassiveAggressiveRegressor.decision_function()
  • linear_model.PassiveAggressiveRegressor.densify()
  • linear_model.PassiveAggressiveRegressor.fit()
  • linear_model.PassiveAggressiveRegressor.get_params()
  • linear_model.PassiveAggressiveRegressor.partial_fit()
  • linear_model.PassiveAggressiveRegressor.predict()
  • linear_model.PassiveAggressiveRegressor.score()
  • linear_model.PassiveAggressiveRegressor.sparsify()
  • linear_model.PassiveAggressiveRegressor.__init__()
  • linear_model.Perceptron
  • linear_model.Perceptron()
  • linear_model.Perceptron.decision_function()
  • linear_model.Perceptron.densify()
  • linear_model.Perceptron.fit()
  • linear_model.Perceptron.fit_transform()
  • linear_model.Perceptron.get_params()
  • linear_model.Perceptron.partial_fit()
  • linear_model.Perceptron.predict()
  • linear_model.Perceptron.score()
  • linear_model.Perceptron.sparsify()
  • linear_model.Perceptron.transform()
  • linear_model.Perceptron.__init__()
  • linear_model.RandomizedLasso
  • linear_model.RandomizedLasso()
  • linear_model.RandomizedLasso.fit()
  • linear_model.RandomizedLasso.fit_transform()
  • linear_model.RandomizedLasso.get_params()
  • linear_model.RandomizedLasso.get_support()
  • linear_model.RandomizedLasso.inverse_transform()
  • linear_model.RandomizedLasso.set_params()
  • linear_model.RandomizedLasso.transform()
  • linear_model.RandomizedLasso.__init__()
  • linear_model.RandomizedLogisticRegression
  • linear_model.RandomizedLogisticRegression()
  • linear_model.RandomizedLogisticRegression.fit()
  • linear_model.RandomizedLogisticRegression.fit_transform()
  • linear_model.RandomizedLogisticRegression.get_params()
  • linear_model.RandomizedLogisticRegression.get_support()
  • linear_model.RandomizedLogisticRegression.inverse_transform()
  • linear_model.RandomizedLogisticRegression.set_params()
  • linear_model.RandomizedLogisticRegression.transform()
  • linear_model.RandomizedLogisticRegression.__init__()
  • linear_model.RANSACRegressor
  • linear_model.RANSACRegressor()
  • linear_model.RANSACRegressor.fit()
  • linear_model.RANSACRegressor.get_params()
  • linear_model.RANSACRegressor.predict()
  • linear_model.RANSACRegressor.score()
  • linear_model.RANSACRegressor.set_params()
  • linear_model.RANSACRegressor.__init__()
  • linear_model.Ridge
  • linear_model.Ridge()
  • linear_model.Ridge.decision_function()
  • linear_model.Ridge.fit()
  • linear_model.Ridge.get_params()
  • linear_model.Ridge.predict()
  • linear_model.Ridge.score()
  • linear_model.Ridge.set_params()
  • linear_model.Ridge.__init__()
  • linear_model.RidgeClassifier
  • linear_model.RidgeClassifier()
  • linear_model.RidgeClassifier.decision_function()
  • linear_model.RidgeClassifier.fit()
  • linear_model.RidgeClassifier.get_params()
  • linear_model.RidgeClassifier.predict()
  • linear_model.RidgeClassifier.score()
  • linear_model.RidgeClassifier.set_params()
  • linear_model.RidgeClassifier.__init__()
  • linear_model.RidgeClassifierCV
  • linear_model.RidgeClassifierCV()
  • linear_model.RidgeClassifierCV.decision_function()
  • linear_model.RidgeClassifierCV.fit()
  • linear_model.RidgeClassifierCV.get_params()
  • linear_model.RidgeClassifierCV.predict()
  • linear_model.RidgeClassifierCV.score()
  • linear_model.RidgeClassifierCV.set_params()
  • linear_model.RidgeClassifierCV.__init__()
  • linear_model.RidgeCV
  • linear_model.RidgeCV()
  • linear_model.RidgeCV.decision_function()
  • linear_model.RidgeCV.fit()
  • linear_model.RidgeCV.get_params()
  • linear_model.RidgeCV.predict()
  • linear_model.RidgeCV.score()
  • linear_model.RidgeCV.set_params()
  • linear_model.RidgeCV.__init__()
  • linear_model.SGDClassifier
  • linear_model.SGDClassifier()
  • linear_model.SGDClassifier.decision_function()
  • linear_model.SGDClassifier.densify()
  • linear_model.SGDClassifier.fit()
  • linear_model.SGDClassifier.fit_transform()
  • linear_model.SGDClassifier.get_params()
  • linear_model.SGDClassifier.partial_fit()
  • linear_model.SGDClassifier.predict()
  • linear_model.SGDClassifier.predict_log_proba
  • linear_model.SGDClassifier.predict_proba
  • linear_model.SGDClassifier.score()
  • linear_model.SGDClassifier.sparsify()
  • linear_model.SGDClassifier.transform()
  • linear_model.SGDClassifier.__init__()
  • linear_model.SGDRegressor
  • linear_model.SGDRegressor()
  • linear_model.SGDRegressor.decision_function()
  • linear_model.SGDRegressor.densify()
  • linear_model.SGDRegressor.fit()
  • linear_model.SGDRegressor.fit_transform()
  • linear_model.SGDRegressor.get_params()
  • linear_model.SGDRegressor.partial_fit()
  • linear_model.SGDRegressor.predict()
  • linear_model.SGDRegressor.score()
  • linear_model.SGDRegressor.sparsify()
  • linear_model.SGDRegressor.transform()
  • linear_model.SGDRegressor.__init__()
  • linear_model.TheilSenRegressor
  • linear_model.TheilSenRegressor()
  • linear_model.TheilSenRegressor.decision_function()
  • linear_model.TheilSenRegressor.fit()
  • linear_model.TheilSenRegressor.get_params()
  • linear_model.TheilSenRegressor.predict()
  • linear_model.TheilSenRegressor.score()
  • linear_model.TheilSenRegressor.set_params()
  • linear_model.TheilSenRegressor.__init__()
  • sklearn.linear_model.lars_path()
  • sklearn.linear_model.lasso_path()
  • sklearn.linear_model.lasso_stability_path()
  • sklearn.linear_model.logistic_regression_path()
  • sklearn.linear_model.orthogonal_mp()
  • sklearn.linear_model.orthogonal_mp_gram()
  • metrics

  • metrics.accuracy_score()
  • metrics.adjusted_mutual_info_score()
  • metrics.adjusted_rand_score()
  • metrics.auc()
  • metrics.average_precision_score()
  • metrics.brier_score_loss()
  • metrics.calinski_harabaz_score()
  • metrics.classification_report()
  • metrics.cohen_kappa_score()
  • metrics.completeness_score()
  • metrics.confusion_matrix()
  • metrics.consensus_score()
  • metrics.coverage_error()
  • metrics.explained_variance_score()
  • metrics.f1_score()
  • metrics.fbeta_score()
  • metrics.fowlkes_mallows_score()
  • metrics.get_scorer()
  • metrics.hamming_loss()
  • metrics.hinge_loss()
  • metrics.homogeneity_completeness_v_measure()
  • metrics.homogeneity_score()
  • metrics.jaccard_similarity_score()
  • metrics.label_ranking_average_precision_score()
  • metrics.label_ranking_loss()
  • metrics.log_loss()
  • metrics.make_scorer()
  • metrics.matthews_corrcoef()
  • metrics.mean_absolute_error()
  • metrics.mean_squared_error()
  • metrics.median_absolute_error()
  • metrics.mutual_info_score()
  • metrics.normalized_mutual_info_score()
  • metrics.pairwise_distances()
  • metrics.pairwise_distances_argmin()
  • metrics.pairwise_distances_argmin_min()
  • metrics.precision_recall_curve()
  • metrics.precision_recall_fscore_support()
  • metrics.precision_score()
  • metrics.r2_score()
  • metrics.recall_score()
  • metrics.roc_auc_score()
  • metrics.roc_curve()
  • metrics.silhouette_samples()
  • metrics.silhouette_score()
  • metrics.v_measure_score()
  • metrics.zero_one_loss()
  • sklearn.metrics.accuracy_score()
  • sklearn.metrics.adjusted_mutual_info_score()
  • sklearn.metrics.adjusted_rand_score()
  • sklearn.metrics.auc()
  • sklearn.metrics.average_precision_score()
  • sklearn.metrics.brier_score_loss()
  • sklearn.metrics.calinski_harabaz_score()
  • sklearn.metrics.classification_report()
  • sklearn.metrics.cohen_kappa_score()
  • sklearn.metrics.completeness_score()
  • sklearn.metrics.confusion_matrix()
  • sklearn.metrics.consensus_score()
  • sklearn.metrics.coverage_error()
  • sklearn.metrics.explained_variance_score()
  • sklearn.metrics.f1_score()
  • sklearn.metrics.fbeta_score()
  • sklearn.metrics.fowlkes_mallows_score()
  • sklearn.metrics.get_scorer()
  • sklearn.metrics.hamming_loss()
  • sklearn.metrics.hinge_loss()
  • sklearn.metrics.homogeneity_completeness_v_measure()
  • sklearn.metrics.homogeneity_score()
  • sklearn.metrics.jaccard_similarity_score()
  • sklearn.metrics.label_ranking_average_precision_score()
  • sklearn.metrics.label_ranking_loss()
  • sklearn.metrics.log_loss()
  • sklearn.metrics.make_scorer()
  • sklearn.metrics.matthews_corrcoef()
  • sklearn.metrics.mean_absolute_error()
  • sklearn.metrics.mean_squared_error()
  • sklearn.metrics.median_absolute_error()
  • sklearn.metrics.mutual_info_score()
  • sklearn.metrics.normalized_mutual_info_score()
  • sklearn.metrics.pairwise_distances()
  • sklearn.metrics.pairwise_distances_argmin()
  • sklearn.metrics.pairwise_distances_argmin_min()
  • sklearn.metrics.precision_recall_curve()
  • sklearn.metrics.precision_recall_fscore_support()
  • sklearn.metrics.precision_score()
  • sklearn.metrics.r2_score()
  • sklearn.metrics.recall_score()
  • sklearn.metrics.roc_auc_score()
  • sklearn.metrics.roc_curve()
  • sklearn.metrics.silhouette_samples()
  • sklearn.metrics.silhouette_score()
  • sklearn.metrics.v_measure_score()
  • sklearn.metrics.zero_one_loss()
  • metrics.pairwise

  • metrics.pairwise.additive_chi2_kernel()
  • metrics.pairwise.chi2_kernel()
  • metrics.pairwise.cosine_distances()
  • metrics.pairwise.cosine_similarity()
  • metrics.pairwise.distance_metrics()
  • metrics.pairwise.euclidean_distances()
  • metrics.pairwise.kernel_metrics()
  • metrics.pairwise.laplacian_kernel()
  • metrics.pairwise.linear_kernel()
  • metrics.pairwise.manhattan_distances()
  • metrics.pairwise.paired_cosine_distances()
  • metrics.pairwise.paired_distances()
  • metrics.pairwise.paired_euclidean_distances()
  • metrics.pairwise.paired_manhattan_distances()
  • metrics.pairwise.pairwise_distances()
  • metrics.pairwise.pairwise_kernels()
  • metrics.pairwise.polynomial_kernel()
  • metrics.pairwise.rbf_kernel()
  • metrics.pairwise.sigmoid_kernel()
  • sklearn.metrics.pairwise.additive_chi2_kernel()
  • sklearn.metrics.pairwise.chi2_kernel()
  • sklearn.metrics.pairwise.cosine_distances()
  • sklearn.metrics.pairwise.cosine_similarity()
  • sklearn.metrics.pairwise.distance_metrics()
  • sklearn.metrics.pairwise.euclidean_distances()
  • sklearn.metrics.pairwise.kernel_metrics()
  • sklearn.metrics.pairwise.laplacian_kernel()
  • sklearn.metrics.pairwise.linear_kernel()
  • sklearn.metrics.pairwise.manhattan_distances()
  • sklearn.metrics.pairwise.paired_cosine_distances()
  • sklearn.metrics.pairwise.paired_distances()
  • sklearn.metrics.pairwise.paired_euclidean_distances()
  • sklearn.metrics.pairwise.paired_manhattan_distances()
  • sklearn.metrics.pairwise.pairwise_distances()
  • sklearn.metrics.pairwise.pairwise_kernels()
  • sklearn.metrics.pairwise.polynomial_kernel()
  • sklearn.metrics.pairwise.rbf_kernel()
  • sklearn.metrics.pairwise.sigmoid_kernel()
  • model_selection

  • model_selection.cross_val_predict()
  • model_selection.cross_val_score()
  • model_selection.GridSearchCV
  • model_selection.GridSearchCV()
  • model_selection.GridSearchCV.decision_function()
  • model_selection.GridSearchCV.fit()
  • model_selection.GridSearchCV.get_params()
  • model_selection.GridSearchCV.inverse_transform()
  • model_selection.GridSearchCV.predict()
  • model_selection.GridSearchCV.predict_log_proba()
  • model_selection.GridSearchCV.predict_proba()
  • model_selection.GridSearchCV.score()
  • model_selection.GridSearchCV.set_params()
  • model_selection.GridSearchCV.transform()
  • model_selection.GridSearchCV.__init__()
  • model_selection.GroupKFold
  • model_selection.GroupKFold()
  • model_selection.GroupKFold.get_n_splits()
  • model_selection.GroupKFold.split()
  • model_selection.GroupKFold.__init__()
  • model_selection.GroupShuffleSplit
  • model_selection.GroupShuffleSplit()
  • model_selection.GroupShuffleSplit.get_n_splits()
  • model_selection.GroupShuffleSplit.split()
  • model_selection.GroupShuffleSplit.__init__()
  • model_selection.KFold
  • model_selection.KFold()
  • model_selection.KFold.get_n_splits()
  • model_selection.KFold.split()
  • model_selection.KFold.__init__()
  • model_selection.learning_curve()
  • model_selection.LeaveOneGroupOut
  • model_selection.LeaveOneGroupOut
  • model_selection.LeaveOneGroupOut.get_n_splits()
  • model_selection.LeaveOneGroupOut.split()
  • model_selection.LeaveOneGroupOut.__init__()
  • model_selection.LeaveOneOut
  • model_selection.LeaveOneOut
  • model_selection.LeaveOneOut.get_n_splits()
  • model_selection.LeaveOneOut.split()
  • model_selection.LeaveOneOut.__init__()
  • model_selection.LeavePGroupsOut
  • model_selection.LeavePGroupsOut()
  • model_selection.LeavePGroupsOut.get_n_splits()
  • model_selection.LeavePGroupsOut.split()
  • model_selection.LeavePGroupsOut.__init__()
  • model_selection.LeavePOut
  • model_selection.LeavePOut()
  • model_selection.LeavePOut.get_n_splits()
  • model_selection.LeavePOut.split()
  • model_selection.LeavePOut.__init__()
  • model_selection.ParameterGrid
  • model_selection.ParameterGrid()
  • model_selection.ParameterSampler
  • model_selection.ParameterSampler()
  • model_selection.permutation_test_score()
  • model_selection.PredefinedSplit
  • model_selection.PredefinedSplit()
  • model_selection.PredefinedSplit.get_n_splits()
  • model_selection.PredefinedSplit.split()
  • model_selection.PredefinedSplit.__init__()
  • model_selection.RandomizedSearchCV
  • model_selection.RandomizedSearchCV()
  • model_selection.RandomizedSearchCV.decision_function()
  • model_selection.RandomizedSearchCV.fit()
  • model_selection.RandomizedSearchCV.get_params()
  • model_selection.RandomizedSearchCV.inverse_transform()
  • model_selection.RandomizedSearchCV.predict()
  • model_selection.RandomizedSearchCV.predict_log_proba()
  • model_selection.RandomizedSearchCV.predict_proba()
  • model_selection.RandomizedSearchCV.score()
  • model_selection.RandomizedSearchCV.set_params()
  • model_selection.RandomizedSearchCV.transform()
  • model_selection.RandomizedSearchCV.__init__()
  • model_selection.ShuffleSplit
  • model_selection.ShuffleSplit()
  • model_selection.ShuffleSplit.get_n_splits()
  • model_selection.ShuffleSplit.split()
  • model_selection.ShuffleSplit.__init__()
  • model_selection.StratifiedKFold
  • model_selection.StratifiedKFold()
  • model_selection.StratifiedKFold.get_n_splits()
  • model_selection.StratifiedKFold.split()
  • model_selection.StratifiedKFold.__init__()
  • model_selection.StratifiedShuffleSplit
  • model_selection.StratifiedShuffleSplit()
  • model_selection.StratifiedShuffleSplit.get_n_splits()
  • model_selection.StratifiedShuffleSplit.split()
  • model_selection.StratifiedShuffleSplit.__init__()
  • model_selection.TimeSeriesSplit
  • model_selection.TimeSeriesSplit()
  • model_selection.TimeSeriesSplit.get_n_splits()
  • model_selection.TimeSeriesSplit.split()
  • model_selection.TimeSeriesSplit.__init__()
  • model_selection.train_test_split()
  • model_selection.validation_curve()
  • sklearn.model_selection.cross_val_predict()
  • sklearn.model_selection.cross_val_score()
  • sklearn.model_selection.learning_curve()
  • sklearn.model_selection.permutation_test_score()
  • sklearn.model_selection.train_test_split()
  • sklearn.model_selection.validation_curve()
  • neighbors

  • neighbors.BallTree
  • neighbors.BallTree
  • neighbors.BallTree.kernel_density()
  • neighbors.BallTree.query()
  • neighbors.BallTree.query_radius()
  • neighbors.BallTree.two_point_correlation()
  • neighbors.BallTree.__init__()
  • neighbors.DistanceMetric
  • neighbors.DistanceMetric
  • neighbors.DistanceMetric.dist_to_rdist()
  • neighbors.DistanceMetric.get_metric()
  • neighbors.DistanceMetric.pairwise()
  • neighbors.DistanceMetric.rdist_to_dist()
  • neighbors.DistanceMetric.__init__()
  • neighbors.KDTree
  • neighbors.KDTree
  • neighbors.KDTree.kernel_density()
  • neighbors.KDTree.query()
  • neighbors.KDTree.query_radius()
  • neighbors.KDTree.two_point_correlation()
  • neighbors.KDTree.__init__()
  • neighbors.KernelDensity
  • neighbors.KernelDensity()
  • neighbors.KernelDensity.fit()
  • neighbors.KernelDensity.get_params()
  • neighbors.KernelDensity.sample()
  • neighbors.KernelDensity.score()
  • neighbors.KernelDensity.score_samples()
  • neighbors.KernelDensity.set_params()
  • neighbors.KernelDensity.__init__()
  • neighbors.KNeighborsClassifier
  • neighbors.KNeighborsClassifier()
  • neighbors.KNeighborsClassifier.fit()
  • neighbors.KNeighborsClassifier.get_params()
  • neighbors.KNeighborsClassifier.kneighbors()
  • neighbors.KNeighborsClassifier.kneighbors_graph()
  • neighbors.KNeighborsClassifier.predict()
  • neighbors.KNeighborsClassifier.predict_proba()
  • neighbors.KNeighborsClassifier.score()
  • neighbors.KNeighborsClassifier.set_params()
  • neighbors.KNeighborsClassifier.__init__()
  • neighbors.KNeighborsRegressor
  • neighbors.KNeighborsRegressor()
  • neighbors.KNeighborsRegressor.fit()
  • neighbors.KNeighborsRegressor.get_params()
  • neighbors.KNeighborsRegressor.kneighbors()
  • neighbors.KNeighborsRegressor.kneighbors_graph()
  • neighbors.KNeighborsRegressor.predict()
  • neighbors.KNeighborsRegressor.score()
  • neighbors.KNeighborsRegressor.set_params()
  • neighbors.KNeighborsRegressor.__init__()
  • neighbors.kneighbors_graph()
  • neighbors.LSHForest
  • neighbors.LSHForest()
  • neighbors.LSHForest.fit()
  • neighbors.LSHForest.get_params()
  • neighbors.LSHForest.kneighbors()
  • neighbors.LSHForest.kneighbors_graph()
  • neighbors.LSHForest.partial_fit()
  • neighbors.LSHForest.radius_neighbors()
  • neighbors.LSHForest.radius_neighbors_graph()
  • neighbors.LSHForest.set_params()
  • neighbors.LSHForest.__init__()
  • neighbors.NearestCentroid
  • neighbors.NearestCentroid()
  • neighbors.NearestCentroid.fit()
  • neighbors.NearestCentroid.get_params()
  • neighbors.NearestCentroid.predict()
  • neighbors.NearestCentroid.score()
  • neighbors.NearestCentroid.set_params()
  • neighbors.NearestCentroid.__init__()
  • neighbors.NearestNeighbors
  • neighbors.NearestNeighbors()
  • neighbors.NearestNeighbors.fit()
  • neighbors.NearestNeighbors.get_params()
  • neighbors.NearestNeighbors.kneighbors()
  • neighbors.NearestNeighbors.kneighbors_graph()
  • neighbors.NearestNeighbors.radius_neighbors()
  • neighbors.NearestNeighbors.radius_neighbors_graph()
  • neighbors.NearestNeighbors.set_params()
  • neighbors.NearestNeighbors.__init__()
  • neighbors.RadiusNeighborsClassifier
  • neighbors.RadiusNeighborsClassifier()
  • neighbors.RadiusNeighborsClassifier.fit()
  • neighbors.RadiusNeighborsClassifier.get_params()
  • neighbors.RadiusNeighborsClassifier.predict()
  • neighbors.RadiusNeighborsClassifier.radius_neighbors()
  • neighbors.RadiusNeighborsClassifier.radius_neighbors_graph()
  • neighbors.RadiusNeighborsClassifier.score()
  • neighbors.RadiusNeighborsClassifier.set_params()
  • neighbors.RadiusNeighborsClassifier.__init__()
  • neighbors.RadiusNeighborsRegressor
  • neighbors.RadiusNeighborsRegressor()
  • neighbors.RadiusNeighborsRegressor.fit()
  • neighbors.RadiusNeighborsRegressor.get_params()
  • neighbors.RadiusNeighborsRegressor.predict()
  • neighbors.RadiusNeighborsRegressor.radius_neighbors()
  • neighbors.RadiusNeighborsRegressor.radius_neighbors_graph()
  • neighbors.RadiusNeighborsRegressor.score()
  • neighbors.RadiusNeighborsRegressor.set_params()
  • neighbors.RadiusNeighborsRegressor.__init__()
  • neighbors.radius_neighbors_graph()
  • sklearn.neighbors.kneighbors_graph()
  • sklearn.neighbors.radius_neighbors_graph()
  • preprocessing

  • preprocessing.add_dummy_feature()
  • preprocessing.binarize()
  • preprocessing.Binarizer
  • preprocessing.Binarizer()
  • preprocessing.Binarizer.fit()
  • preprocessing.Binarizer.fit_transform()
  • preprocessing.Binarizer.get_params()
  • preprocessing.Binarizer.set_params()
  • preprocessing.Binarizer.transform()
  • preprocessing.Binarizer.__init__()
  • preprocessing.FunctionTransformer
  • preprocessing.FunctionTransformer()
  • preprocessing.FunctionTransformer.fit_transform()
  • preprocessing.FunctionTransformer.get_params()
  • preprocessing.FunctionTransformer.set_params()
  • preprocessing.FunctionTransformer.__init__()
  • preprocessing.Imputer
  • preprocessing.Imputer()
  • preprocessing.Imputer.fit()
  • preprocessing.Imputer.fit_transform()
  • preprocessing.Imputer.get_params()
  • preprocessing.Imputer.set_params()
  • preprocessing.Imputer.transform()
  • preprocessing.Imputer.__init__()
  • preprocessing.KernelCenterer
  • preprocessing.KernelCenterer
  • preprocessing.KernelCenterer.fit()
  • preprocessing.KernelCenterer.fit_transform()
  • preprocessing.KernelCenterer.get_params()
  • preprocessing.KernelCenterer.set_params()
  • preprocessing.KernelCenterer.transform()
  • preprocessing.KernelCenterer.__init__()
  • preprocessing.LabelBinarizer
  • preprocessing.LabelBinarizer()
  • preprocessing.LabelBinarizer.fit()
  • preprocessing.LabelBinarizer.fit_transform()
  • preprocessing.LabelBinarizer.get_params()
  • preprocessing.LabelBinarizer.inverse_transform()
  • preprocessing.LabelBinarizer.set_params()
  • preprocessing.LabelBinarizer.transform()
  • preprocessing.LabelBinarizer.__init__()
  • preprocessing.LabelEncoder
  • preprocessing.LabelEncoder
  • preprocessing.LabelEncoder.fit()
  • preprocessing.LabelEncoder.fit_transform()
  • preprocessing.LabelEncoder.get_params()
  • preprocessing.LabelEncoder.inverse_transform()
  • preprocessing.LabelEncoder.set_params()
  • preprocessing.LabelEncoder.transform()
  • preprocessing.LabelEncoder.__init__()
  • preprocessing.label_binarize()
  • preprocessing.MaxAbsScaler
  • preprocessing.MaxAbsScaler()
  • preprocessing.MaxAbsScaler.fit()
  • preprocessing.MaxAbsScaler.fit_transform()
  • preprocessing.MaxAbsScaler.get_params()
  • preprocessing.MaxAbsScaler.inverse_transform()
  • preprocessing.MaxAbsScaler.partial_fit()
  • preprocessing.MaxAbsScaler.set_params()
  • preprocessing.MaxAbsScaler.transform()
  • preprocessing.MaxAbsScaler.__init__()
  • preprocessing.maxabs_scale()
  • preprocessing.MinMaxScaler
  • preprocessing.MinMaxScaler()
  • preprocessing.MinMaxScaler.data_min
  • preprocessing.MinMaxScaler.data_range
  • preprocessing.MinMaxScaler.fit()
  • preprocessing.MinMaxScaler.fit_transform()
  • preprocessing.MinMaxScaler.get_params()
  • preprocessing.MinMaxScaler.inverse_transform()
  • preprocessing.MinMaxScaler.partial_fit()
  • preprocessing.MinMaxScaler.set_params()
  • preprocessing.MinMaxScaler.transform()
  • preprocessing.MinMaxScaler.__init__()
  • preprocessing.minmax_scale()
  • preprocessing.MultiLabelBinarizer
  • preprocessing.MultiLabelBinarizer()
  • preprocessing.MultiLabelBinarizer.fit()
  • preprocessing.MultiLabelBinarizer.fit_transform()
  • preprocessing.MultiLabelBinarizer.get_params()
  • preprocessing.MultiLabelBinarizer.inverse_transform()
  • preprocessing.MultiLabelBinarizer.set_params()
  • preprocessing.MultiLabelBinarizer.transform()
  • preprocessing.MultiLabelBinarizer.__init__()
  • preprocessing.normalize()
  • preprocessing.Normalizer
  • preprocessing.Normalizer()
  • preprocessing.Normalizer.fit()
  • preprocessing.Normalizer.fit_transform()
  • preprocessing.Normalizer.get_params()
  • preprocessing.Normalizer.set_params()
  • preprocessing.Normalizer.transform()
  • preprocessing.Normalizer.__init__()
  • preprocessing.OneHotEncoder
  • preprocessing.OneHotEncoder()
  • preprocessing.OneHotEncoder.fit()
  • preprocessing.OneHotEncoder.fit_transform()
  • preprocessing.OneHotEncoder.get_params()
  • preprocessing.OneHotEncoder.set_params()
  • preprocessing.OneHotEncoder.transform()
  • preprocessing.OneHotEncoder.__init__()
  • preprocessing.PolynomialFeatures
  • preprocessing.PolynomialFeatures()
  • preprocessing.PolynomialFeatures.fit()
  • preprocessing.PolynomialFeatures.fit_transform()
  • preprocessing.PolynomialFeatures.get_feature_names()
  • preprocessing.PolynomialFeatures.get_params()
  • preprocessing.PolynomialFeatures.set_params()
  • preprocessing.PolynomialFeatures.transform()
  • preprocessing.PolynomialFeatures.__init__()
  • preprocessing.RobustScaler
  • preprocessing.RobustScaler()
  • preprocessing.RobustScaler.fit()
  • preprocessing.RobustScaler.fit_transform()
  • preprocessing.RobustScaler.get_params()
  • preprocessing.RobustScaler.inverse_transform()
  • preprocessing.RobustScaler.set_params()
  • preprocessing.RobustScaler.transform()
  • preprocessing.RobustScaler.__init__()
  • preprocessing.robust_scale()
  • preprocessing.scale()
  • preprocessing.StandardScaler
  • preprocessing.StandardScaler()
  • preprocessing.StandardScaler.fit()
  • preprocessing.StandardScaler.fit_transform()
  • preprocessing.StandardScaler.get_params()
  • preprocessing.StandardScaler.inverse_transform()
  • preprocessing.StandardScaler.partial_fit()
  • preprocessing.StandardScaler.set_params()
  • preprocessing.StandardScaler.std_
  • preprocessing.StandardScaler.transform()
  • preprocessing.StandardScaler.__init__()
  • sklearn.preprocessing.add_dummy_feature()
  • sklearn.preprocessing.binarize()
  • sklearn.preprocessing.label_binarize()
  • sklearn.preprocessing.maxabs_scale()
  • sklearn.preprocessing.minmax_scale()
  • sklearn.preprocessing.normalize()
  • sklearn.preprocessing.robust_scale()
  • sklearn.preprocessing.scale()
  • svm

  • sklearn.svm.l1_min_c()
  • svm.l1_min_c()
  • svm.LinearSVC
  • svm.LinearSVC()
  • svm.LinearSVC.decision_function()
  • svm.LinearSVC.densify()
  • svm.LinearSVC.fit()
  • svm.LinearSVC.fit_transform()
  • svm.LinearSVC.get_params()
  • svm.LinearSVC.predict()
  • svm.LinearSVC.score()
  • svm.LinearSVC.set_params()
  • svm.LinearSVC.sparsify()
  • svm.LinearSVC.transform()
  • svm.LinearSVC.__init__()
  • svm.LinearSVR
  • svm.LinearSVR()
  • svm.LinearSVR.decision_function()
  • svm.LinearSVR.fit()
  • svm.LinearSVR.get_params()
  • svm.LinearSVR.predict()
  • svm.LinearSVR.score()
  • svm.LinearSVR.set_params()
  • svm.LinearSVR.__init__()
  • svm.NuSVC
  • svm.NuSVC()
  • svm.NuSVC.decision_function()
  • svm.NuSVC.fit()
  • svm.NuSVC.get_params()
  • svm.NuSVC.predict()
  • svm.NuSVC.predict_log_proba
  • svm.NuSVC.predict_proba
  • svm.NuSVC.score()
  • svm.NuSVC.set_params()
  • svm.NuSVC.__init__()
  • svm.NuSVR
  • svm.NuSVR()
  • svm.NuSVR.decision_function()
  • svm.NuSVR.fit()
  • svm.NuSVR.get_params()
  • svm.NuSVR.predict()
  • svm.NuSVR.score()
  • svm.NuSVR.set_params()
  • svm.NuSVR.__init__()
  • svm.OneClassSVM
  • svm.OneClassSVM()
  • svm.OneClassSVM.decision_function()
  • svm.OneClassSVM.fit()
  • svm.OneClassSVM.get_params()
  • svm.OneClassSVM.predict()
  • svm.OneClassSVM.set_params()
  • svm.OneClassSVM.__init__()
  • svm.SVC
  • svm.SVC()
  • svm.SVC.decision_function()
  • svm.SVC.fit()
  • svm.SVC.get_params()
  • svm.SVC.predict()
  • svm.SVC.predict_log_proba
  • svm.SVC.predict_proba
  • svm.SVC.score()
  • svm.SVC.set_params()
  • svm.SVC.__init__()
  • svm.SVR
  • svm.SVR()
  • svm.SVR.decision_function()
  • svm.SVR.fit()
  • svm.SVR.get_params()
  • svm.SVR.predict()
  • svm.SVR.score()
  • svm.SVR.set_params()
  • svm.SVR.__init__()
  • tree

  • sklearn.tree.export_graphviz()
  • tree.DecisionTreeClassifier
  • tree.DecisionTreeClassifier()
  • tree.DecisionTreeClassifier.apply()
  • tree.DecisionTreeClassifier.decision_path()
  • tree.DecisionTreeClassifier.feature_importances_
  • tree.DecisionTreeClassifier.fit()
  • tree.DecisionTreeClassifier.fit_transform()
  • tree.DecisionTreeClassifier.get_params()
  • tree.DecisionTreeClassifier.predict()
  • tree.DecisionTreeClassifier.predict_log_proba()
  • tree.DecisionTreeClassifier.predict_proba()
  • tree.DecisionTreeClassifier.score()
  • tree.DecisionTreeClassifier.set_params()
  • tree.DecisionTreeClassifier.transform()
  • tree.DecisionTreeClassifier.__init__()
  • tree.DecisionTreeRegressor
  • tree.DecisionTreeRegressor()
  • tree.DecisionTreeRegressor.apply()
  • tree.DecisionTreeRegressor.decision_path()
  • tree.DecisionTreeRegressor.feature_importances_
  • tree.DecisionTreeRegressor.fit()
  • tree.DecisionTreeRegressor.fit_transform()
  • tree.DecisionTreeRegressor.get_params()
  • tree.DecisionTreeRegressor.predict()
  • tree.DecisionTreeRegressor.score()
  • tree.DecisionTreeRegressor.set_params()
  • tree.DecisionTreeRegressor.transform()
  • tree.DecisionTreeRegressor.__init__()
  • tree.export_graphviz()
  • tree.ExtraTreeClassifier
  • tree.ExtraTreeClassifier()
  • tree.ExtraTreeClassifier.apply()
  • tree.ExtraTreeClassifier.decision_path()
  • tree.ExtraTreeClassifier.feature_importances_
  • tree.ExtraTreeClassifier.fit()
  • tree.ExtraTreeClassifier.fit_transform()
  • tree.ExtraTreeClassifier.get_params()
  • tree.ExtraTreeClassifier.predict()
  • tree.ExtraTreeClassifier.predict_log_proba()
  • tree.ExtraTreeClassifier.predict_proba()
  • tree.ExtraTreeClassifier.score()
  • tree.ExtraTreeClassifier.set_params()
  • tree.ExtraTreeClassifier.transform()
  • tree.ExtraTreeClassifier.__init__()
  • tree.ExtraTreeRegressor
  • tree.ExtraTreeRegressor()
  • tree.ExtraTreeRegressor.apply()
  • tree.ExtraTreeRegressor.decision_path()
  • tree.ExtraTreeRegressor.feature_importances_
  • tree.ExtraTreeRegressor.fit()
  • tree.ExtraTreeRegressor.fit_transform()
  • tree.ExtraTreeRegressor.get_params()
  • tree.ExtraTreeRegressor.predict()
  • tree.ExtraTreeRegressor.score()
  • tree.ExtraTreeRegressor.set_params()
  • tree.ExtraTreeRegressor.transform()
  • tree.ExtraTreeRegressor.__init__()
  • Index

  • index