jaquesgrobler · October 29, 2012 12:43 · jaquesgrobler · Oct 29, 2012 · jaquesgrobler · Oct 29, 2012
diff --git a/sklearn_param_attrib.py b/sklearn_param_attrib.py
 from __future__ import print_function
 import warnings

 import numpy as np

 import sklearn
 from sklearn.utils.testing import all_estimators
 from sklearn.utils.testing import assert_greater
 from sklearn.base import clone, ClassifierMixin, RegressorMixin, \
        TransformerMixin, ClusterMixin
 from sklearn.utils import shuffle
 from sklearn.preprocessing import StandardScaler, Scaler
 from sklearn.svm import SVC
 from sklearn.decomposition import PCA
 from sklearn.feature_selection import SelectKBest

 #from sklearn.cross_validation import train_test_split
 from sklearn.datasets import load_iris, load_boston, make_blobs, load_digits
 from sklearn.datasets import make_multilabel_classification
 from sklearn.metrics import zero_one_score, adjusted_rand_score
 from sklearn.lda import LDA
 from sklearn.svm.base import BaseLibSVM
 from sklearn.svm import LinearSVC
 from sklearn.feature_selection.rfe import RFE, RFECV
 from sklearn.utils import check_random_state

 # import "special" estimators
 from sklearn.grid_search import GridSearchCV
 from sklearn.decomposition import SparseCoder
 from sklearn.pipeline import Pipeline, FeatureUnion
 from sklearn.pls import _PLS, PLSCanonical, PLSRegression, CCA, PLSSVD
 from sklearn.ensemble import BaseEnsemble
 from sklearn.multiclass import OneVsOneClassifier, OneVsRestClassifier,\
        OutputCodeClassifier
 from sklearn.feature_selection import RFE, RFECV, SelectKBest
 from sklearn.naive_bayes import MultinomialNB, BernoulliNB
 from sklearn.covariance import EllipticEnvelope, EllipticEnvelop
 from sklearn.feature_extraction import DictVectorizer
 from sklearn.feature_extraction.text import TfidfTransformer, \
    CountVectorizer
 from sklearn.kernel_approximation import AdditiveChi2Sampler
 from sklearn.preprocessing import LabelBinarizer, LabelEncoder, Binarizer, \
    Normalizer
 from sklearn.cluster import WardAgglomeration, AffinityPropagation, \
        SpectralClustering
 from sklearn.linear_model import IsotonicRegression, LogisticRegression

 dont_test = [Pipeline, FeatureUnion, GridSearchCV, SparseCoder,
        EllipticEnvelope, EllipticEnvelop, DictVectorizer, LabelBinarizer,
        LabelEncoder, TfidfTransformer, IsotonicRegression]
 meta_estimators = [BaseEnsemble, OneVsOneClassifier, OutputCodeClassifier,
        OneVsRestClassifier, RFE, RFECV]

 # Create the outputfile
 f = open('sklearn_param_attrib.rst', 'w')

 def param_gather () :
    all_objects_p = []
    for C in all_estimators():
        try:
            all_objects_p.append(C[1]())
        except:
            pass
    params = [c.get_params().keys() for c in all_objects_p]
    flat = [x for c in params for x in c]
    unique_p, indices_p = np.unique(flat, return_inverse=True)
    return all_objects_p, unique_p, indices_p

 def write_param_table(unique_p, indices_p) :
    param_table = np.vstack([unique_p, np.bincount(indices_p)]).T
    max_width, _ = [max(len((x)) for x in line) for line in zip(*param_table)]
    bar_iter = 1
    bar1 = "="
    while (bar_iter < max_width):
        bar1 += "="
        bar_iter += 1
    bar1 += " ====="
    print (bar1, file=f)
    for name, count in param_table :
        print ("%s %s" % (name.ljust(max_width), count), file=f)
    print (bar1, file=f)

 def param_info(all_objects_p, unique_p) :
    print ("\nWhich parameter is used in which class and further info: \n", file=f)
    for param in unique_p:
        est = []
        str =  param + ' is used in the following classes'
        print(str, file=f)
        for c in all_objects_p:
            if param in c.get_params().keys():
                est.append(c.__module__)
        for u in np.unique(est):
            print (' * ' +  u, file=f)
        print('\n', file=f)

 #def attrib_gather() :
 #    temp_attribs = []
 #    trans_attrib_dict = {}
 #    for i in dir(trans):
 #        if i[-1] is '_' and i[-2] is not '_':
 #            temp_attribs.append(i)
 #    transformers_attribs.append(temp_attribs)
 #    trans_attrib_dict[Trans] = temp_attribs
 #    transformers_attrib_dicts.append(trans_attrib_dict)

 def attrib_gather_other(attribs, attrib_dicts, est, est_type) :
    temp_attribs = []
    temp_attrib_dict = {}
    for i in dir(est):
        if i[-1] is '_' and i[-2] is not '_':
            temp_attribs.append(i)
    attribs.append(temp_attribs)
    temp_attrib_dict[est_type] = temp_attribs
    attrib_dicts.append(temp_attrib_dict)
    return attribs, attrib_dicts

 if __name__ == "__main__":

    # Parameters
    print("\nGather all parameters\n")

    print("\n\nPARAMETERS\n=============\n", file=f)
    print("All parameters and the ammount of times they are used\n", file=f)
    all_objects_p, unique_p, indices_p = param_gather()
    write_param_table(unique_p, indices_p)
    param_info(all_objects_p, unique_p)
    print("\nParameters written to file\n")

    # Attributes
    #-----------------------------------------------------------------------------------
    estimators = all_estimators()

    # Transformers
    transformers = [(name, E) for name, E in estimators if issubclass(E,
                                                                      TransformerMixin)]
    # Generate the generic TransformerMixin data
    X, y = make_blobs(n_samples=30, centers=[[0, 0, 0], [1, 1, 1]],
                      random_state=0, n_features=2, cluster_std=0.1)
    n_samples, n_features = X.shape
    X = StandardScaler().fit_transform(X)
    X -= X.min()

    transformers_attribs = []
    transformers_attrib_dicts = []
    for name, Trans in transformers:
        if Trans in dont_test or Trans in meta_estimators:
            continue
        # these don't actually fit the data:
        if Trans in [AdditiveChi2Sampler, Binarizer, Normalizer]:
            continue
        # catch deprecation warnings
        with warnings.catch_warnings(record=True):
            trans = Trans()

        if hasattr(trans, 'compute_importances'):
            trans.compute_importances = True

        if Trans is SelectKBest:
            # SelectKBest has a default of k=10
            # which is more feature than we have.
            trans.k = 1

        if Trans in (_PLS, PLSCanonical, PLSRegression, CCA, PLSSVD):
            y_ = np.vstack([y, 2 * y + np.random.randint(2, size=len(y))])
            y_ = y_.T
        else:
            y_ = y

        try:
            trans.fit(X, y_)
        except Exception as e:
            print (trans)
            print (e)
            print ()
            succeeded = False

        transformers_attribs, transformers_attrib_dicts = attrib_gather_other(transformers_attribs,
                                                                              transformers_attrib_dicts,
                                                                              trans, Trans)

    # Clustering
    clustering = [(name, E) for name, E in estimators if issubclass(E,
                                                                    ClusterMixin)]
    iris = load_iris()
    X = iris.data

    clustering_attribs = []
    clustering_attrib_dicts = []
    for name, Alg in clustering:
        with warnings.catch_warnings(record=True):
            alg = Alg()
            if hasattr(alg, "n_clusters"):
                alg.set_params(n_clusters=3)
            if hasattr(alg, "random_state"):
                alg.set_params(random_state=1)
            if Alg is AffinityPropagation:
                alg.set_params(preference=-100)
            alg.fit(X)
        clustering_attribs, clustering_attrib_dicts = attrib_gather_other(clustering_attribs,
                                                                          clustering_attrib_dicts,
                                                                          alg, Alg)

    # Regressors
    regressors = [(name, E) for name, E in estimators if issubclass(E,
                                                                    RegressorMixin)]
    boston = load_boston()
    X, y = boston.data, boston.target
    X, y = shuffle(X, y, random_state=0)

    regressor_attribs = []
    regressor_attrib_dicts = []
    for name, Reg in regressors:
        if Reg in dont_test or Reg in meta_estimators:
            continue
        # catch deprecation warnings
        with warnings.catch_warnings(record=True):
            reg = Reg()
        try:
            if Reg in (_PLS, PLSCanonical, PLSRegression, CCA):
                y_ = np.vstack([y, 2 * y + np.random.randint(2, size=len(y))])
                y_ = y_.T
            else:
                y_ = y
            reg.fit(X, y_)
        except Exception as e:
            print(reg)
            print (e)
            print ()
            succeeded = False
        regressor_attribs, regressor_attrib_dicts = attrib_gather_other(regressor_attribs,
                                                                        regressor_attrib_dicts,
                                                                          reg, Reg)

    # Classifiers
    classifiers = [(name, E) for name, E in estimators if issubclass(E,
            ClassifierMixin)]

    iris = load_iris()
    X, y = iris.data, iris.target
    X, y = shuffle(X, y, random_state=7)
    classifier_attribs = []
    classifier_attrib_dicts = []
    for name, Clf in classifiers:
        if Clf in dont_test or Clf in meta_estimators:
            continue
        # catch deprecation warnings
        with warnings.catch_warnings(record=True):
            clf = Clf()
        clf.fit(X, y)
        classifier_attribs, classifier_attrib_dicts = attrib_gather_other(classifier_attribs,
                                                                          classifier_attrib_dicts,
                                                                          clf, Clf)

    # Obtain dont_test and meta_estimators attributes
    other_attribs = []
    other_attrib_dicts = []

    # Pipeline - attribute 'steps' should be 'steps_'
    digits = load_digits()
    X_digits = digits.data
    y_digits = digits.target
    logistic = LogisticRegression()
    item = Pipeline(steps=[('logistic', logistic)])
    item.fit(X_digits, y_digits)
    other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
                                                            other_attrib_dicts,
                                                            item, Pipeline)

    # BaseEnsemble - No attributes/no fit method

    # OneVsRestClassifier
    X, Y = make_multilabel_classification(n_classes=2, n_labels=1,
                                          allow_unlabeled=True,
                                          random_state=1)
    item = OneVsRestClassifier(SVC(kernel='linear'))
    item.fit(X, Y)
    other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
                                                            other_attrib_dicts,
                                                            item,
                                                            OneVsRestClassifier)

    # OutputCodeClassifier
    X, y = iris.data, iris.target
    item = OutputCodeClassifier(LinearSVC())
    item.fit(X, y)
    other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
                                                            other_attrib_dicts,
                                                            item,
                                                            OutputCodeClassifier)

    # OneVsOneClassifier
    item = OneVsOneClassifier(LinearSVC())
    item.fit(X, y)
    other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
                                                            other_attrib_dicts,
                                                            item,
                                                            OneVsOneClassifier)

    # FeatureUnion
    pca = PCA(n_components=2)
    selection = SelectKBest(k=1)
    item = FeatureUnion([("pca", pca), ("univ_select", selection)])
    item.fit(X, y)
    other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
                                                            other_attrib_dicts,
                                                            item,
                                                            FeatureUnion)

    # GridSearchCV
    parameters = {'kernel':('linear', 'rbf'), 'C':[1, 10]}
    svr = SVC()
    item = GridSearchCV(svr, parameters)
    item.fit(iris.data, iris.target)
    other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
                                                            other_attrib_dicts,
                                                            item,
                                                            GridSearchCV)

    # RFE
    generator = check_random_state(0)
    X = np.c_[iris.data, generator.normal(size=(len(iris.data), 6))]
    y = iris.target
    clf = SVC(kernel="linear")
    item = RFE(estimator=clf, n_features_to_select=4, step=0.1)
    item.fit(X, y)
    other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
                                                            other_attrib_dicts,
                                                            item,
                                                            RFE)

    #RFECV
    item = RFECV(estimator=SVC(kernel="linear"), step=1, cv=3)
    item.fit(X, y)
    other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
                                                            other_attrib_dicts,
                                                            item,
                                                            RFECV)

    # SparseCoder
    y = np.linspace(0, 4 - 1, 10)
    item = SparseCoder(y, transform_algorithm='lasso_lars')
    item.fit(y)
    other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
                                                            other_attrib_dicts,
                                                            item,
                                                            SparseCoder)

    # EllipticEnvelope
    X1 = load_boston()['data'][:, [8, 10]]  # two clusters
    item = EllipticEnvelope(support_fraction=1., contamination=0.261)
    item.fit(X1)
    other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
                                                            other_attrib_dicts,
                                                            item,
                                                            EllipticEnvelope)

    # DictVectorizer
    D = [{'foo': 1, 'bar': 2}, {'foo': 3, 'baz': 1}]
    item = DictVectorizer(sparse=False)
    item.fit_transform(D)
    other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
                                                            other_attrib_dicts,
                                                            item,
                                                            DictVectorizer)

    #LabelBinarizer
    item = LabelBinarizer()
    item.fit([1, 2, 6, 4, 2])
    other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
                                                            other_attrib_dicts,
                                                            item,
                                                            LabelBinarizer)

    #LabelEncoder
    item = LabelEncoder()
    item.fit([1, 2, 2, 6])
    other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
                                                            other_attrib_dicts,
                                                            item,
                                                            LabelEncoder)

    # TfidfTransformer
    JUNK_FOOD_DOCS = (
        "the pizza pizza beer copyright",
        "the pizza burger beer copyright",
    )
    what_we_like = ["pizza", "beer"]
    item = TfidfTransformer()
    pipe = Pipeline([
            ('count', CountVectorizer(vocabulary=what_we_like)),
            ('tfidf', item)])
    pipe.fit_transform(JUNK_FOOD_DOCS)
    other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
                                                            other_attrib_dicts,
                                                            item,
                                                            TfidfTransformer)

    # IsotonicRegression
    n = 100
    x = np.arange(n)
    rs = check_random_state(0)
    y = rs.randint(-50, 50, size=(n,)) + 50. * np.log(1 + np.arange(n))
    item = IsotonicRegression()
    item.fit(x, y)
    other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
                                                            other_attrib_dicts,
                                                            item,
                                                            IsotonicRegression)


    ######################
    # Process the gathered attributes

    print("\n\nATTRIBUTES\n=============\n", file=f)
    print("All parameters and the ammount of times they are used\n", file=f)

    all_attribs = transformers_attribs + clustering_attribs \
        + regressor_attribs + classifier_attribs \
        + other_attribs
    all_attrib_dicts = transformers_attrib_dicts + clustering_attrib_dicts \
        + regressor_attrib_dicts + classifier_attrib_dicts \
        + other_attrib_dicts

    flat_attrib = [x for c in all_attribs for x in c]
    unique_a, indices_a = np.unique(flat_attrib, return_inverse=True)
    attrib_table = np.vstack([unique_a, np.bincount(indices_a)]).T
    max_width, _ = [max(len((x)) for x in line) for line in zip(*attrib_table)]
    print ("================================== ====", file=f)
    for name, count in attrib_table :
        print ("%s %s" % (name.ljust(max_width), count), file=f)
    print ("================================== ====", file=f)
    print('\n', file=f)

    for attrib in unique_a:
        est = []
        str =  attrib + ' is used in the following classes'
        print(str, file=f)
        for e in all_attrib_dicts:
            if attrib in e.values()[0]:
                est.append(e.keys()[0].__name__)
        for u in np.unique(est):
            print (' * ' +  u, file=f)
        print('\n', file=f)

    print ("\nCompleted\n----------")

    #print '\n\nList of Classes that derive from the BaseEstimator:'
    #for c in np.unique(all_objects_p):
    #    print c.__class__
diff --git a/sklearn_param_attrib.rst b/sklearn_param_attrib.rst
	from __future__ import print_function
	import warnings

	import numpy as np

	import sklearn
	from sklearn.utils.testing import all_estimators
	from sklearn.utils.testing import assert_greater
	from sklearn.base import clone, ClassifierMixin, RegressorMixin, \
	TransformerMixin, ClusterMixin
	from sklearn.utils import shuffle
	from sklearn.preprocessing import StandardScaler, Scaler
	from sklearn.svm import SVC
	from sklearn.decomposition import PCA
	from sklearn.feature_selection import SelectKBest

	#from sklearn.cross_validation import train_test_split
	from sklearn.datasets import load_iris, load_boston, make_blobs, load_digits
	from sklearn.datasets import make_multilabel_classification
	from sklearn.metrics import zero_one_score, adjusted_rand_score
	from sklearn.lda import LDA
	from sklearn.svm.base import BaseLibSVM
	from sklearn.svm import LinearSVC
	from sklearn.feature_selection.rfe import RFE, RFECV
	from sklearn.utils import check_random_state

	# import "special" estimators
	from sklearn.grid_search import GridSearchCV
	from sklearn.decomposition import SparseCoder
	from sklearn.pipeline import Pipeline, FeatureUnion
	from sklearn.pls import _PLS, PLSCanonical, PLSRegression, CCA, PLSSVD
	from sklearn.ensemble import BaseEnsemble
	from sklearn.multiclass import OneVsOneClassifier, OneVsRestClassifier,\
	OutputCodeClassifier
	from sklearn.feature_selection import RFE, RFECV, SelectKBest
	from sklearn.naive_bayes import MultinomialNB, BernoulliNB
	from sklearn.covariance import EllipticEnvelope, EllipticEnvelop
	from sklearn.feature_extraction import DictVectorizer
	from sklearn.feature_extraction.text import TfidfTransformer, \
	CountVectorizer
	from sklearn.kernel_approximation import AdditiveChi2Sampler
	from sklearn.preprocessing import LabelBinarizer, LabelEncoder, Binarizer, \
	Normalizer
	from sklearn.cluster import WardAgglomeration, AffinityPropagation, \
	SpectralClustering
	from sklearn.linear_model import IsotonicRegression, LogisticRegression

	dont_test = [Pipeline, FeatureUnion, GridSearchCV, SparseCoder,
	EllipticEnvelope, EllipticEnvelop, DictVectorizer, LabelBinarizer,
	LabelEncoder, TfidfTransformer, IsotonicRegression]
	meta_estimators = [BaseEnsemble, OneVsOneClassifier, OutputCodeClassifier,
	OneVsRestClassifier, RFE, RFECV]

	# Create the outputfile
	f = open('sklearn_param_attrib.rst', 'w')

	def param_gather () :
	all_objects_p = []
	for C in all_estimators():
	try:
	all_objects_p.append(C[1]())
	except:
	pass
	params = [c.get_params().keys() for c in all_objects_p]
	flat = [x for c in params for x in c]
	unique_p, indices_p = np.unique(flat, return_inverse=True)
	return all_objects_p, unique_p, indices_p

	def write_param_table(unique_p, indices_p) :
	param_table = np.vstack([unique_p, np.bincount(indices_p)]).T
	max_width, _ = [max(len((x)) for x in line) for line in zip(*param_table)]
	bar_iter = 1
	bar1 = "="
	while (bar_iter < max_width):
	bar1 += "="
	bar_iter += 1
	bar1 += " ====="
	print (bar1, file=f)
	for name, count in param_table :
	print ("%s %s" % (name.ljust(max_width), count), file=f)
	print (bar1, file=f)

	def param_info(all_objects_p, unique_p) :
	print ("\nWhich parameter is used in which class and further info: \n", file=f)
	for param in unique_p:
	est = []
	str = param + ' is used in the following classes'
	print(str, file=f)
	for c in all_objects_p:
	if param in c.get_params().keys():
	est.append(c.__module__)
	for u in np.unique(est):
	print (' * ' + u, file=f)
	print('\n', file=f)

	#def attrib_gather() :
	# temp_attribs = []
	# trans_attrib_dict = {}
	# for i in dir(trans):
	# if i[-1] is '_' and i[-2] is not '_':
	# temp_attribs.append(i)
	# transformers_attribs.append(temp_attribs)
	# trans_attrib_dict[Trans] = temp_attribs
	# transformers_attrib_dicts.append(trans_attrib_dict)

	def attrib_gather_other(attribs, attrib_dicts, est, est_type) :
	temp_attribs = []
	temp_attrib_dict = {}
	for i in dir(est):
	if i[-1] is '_' and i[-2] is not '_':
	temp_attribs.append(i)
	attribs.append(temp_attribs)
	temp_attrib_dict[est_type] = temp_attribs
	attrib_dicts.append(temp_attrib_dict)
	return attribs, attrib_dicts

	if __name__ == "__main__":

	# Parameters
	print("\nGather all parameters\n")

	print("\n\nPARAMETERS\n=============\n", file=f)
	print("All parameters and the ammount of times they are used\n", file=f)
	all_objects_p, unique_p, indices_p = param_gather()
	write_param_table(unique_p, indices_p)
	param_info(all_objects_p, unique_p)
	print("\nParameters written to file\n")

	# Attributes
	#-----------------------------------------------------------------------------------
	estimators = all_estimators()

	# Transformers
	transformers = [(name, E) for name, E in estimators if issubclass(E,
	TransformerMixin)]
	# Generate the generic TransformerMixin data
	X, y = make_blobs(n_samples=30, centers=[[0, 0, 0], [1, 1, 1]],
	random_state=0, n_features=2, cluster_std=0.1)
	n_samples, n_features = X.shape
	X = StandardScaler().fit_transform(X)
	X -= X.min()

	transformers_attribs = []
	transformers_attrib_dicts = []
	for name, Trans in transformers:
	if Trans in dont_test or Trans in meta_estimators:
	continue
	# these don't actually fit the data:
	if Trans in [AdditiveChi2Sampler, Binarizer, Normalizer]:
	continue
	# catch deprecation warnings
	with warnings.catch_warnings(record=True):
	trans = Trans()

	if hasattr(trans, 'compute_importances'):
	trans.compute_importances = True

	if Trans is SelectKBest:
	# SelectKBest has a default of k=10
	# which is more feature than we have.
	trans.k = 1

	if Trans in (_PLS, PLSCanonical, PLSRegression, CCA, PLSSVD):
	y_ = np.vstack([y, 2 * y + np.random.randint(2, size=len(y))])
	y_ = y_.T
	else:
	y_ = y

	try:
	trans.fit(X, y_)
	except Exception as e:
	print (trans)
	print (e)
	print ()
	succeeded = False

	transformers_attribs, transformers_attrib_dicts = attrib_gather_other(transformers_attribs,
	transformers_attrib_dicts,
	trans, Trans)

	# Clustering
	clustering = [(name, E) for name, E in estimators if issubclass(E,
	ClusterMixin)]
	iris = load_iris()
	X = iris.data

	clustering_attribs = []
	clustering_attrib_dicts = []
	for name, Alg in clustering:
	with warnings.catch_warnings(record=True):
	alg = Alg()
	if hasattr(alg, "n_clusters"):
	alg.set_params(n_clusters=3)
	if hasattr(alg, "random_state"):
	alg.set_params(random_state=1)
	if Alg is AffinityPropagation:
	alg.set_params(preference=-100)
	alg.fit(X)
	clustering_attribs, clustering_attrib_dicts = attrib_gather_other(clustering_attribs,
	clustering_attrib_dicts,
	alg, Alg)

	# Regressors
	regressors = [(name, E) for name, E in estimators if issubclass(E,
	RegressorMixin)]
	boston = load_boston()
	X, y = boston.data, boston.target
	X, y = shuffle(X, y, random_state=0)

	regressor_attribs = []
	regressor_attrib_dicts = []
	for name, Reg in regressors:
	if Reg in dont_test or Reg in meta_estimators:
	continue
	# catch deprecation warnings
	with warnings.catch_warnings(record=True):
	reg = Reg()
	try:
	if Reg in (_PLS, PLSCanonical, PLSRegression, CCA):
	y_ = np.vstack([y, 2 * y + np.random.randint(2, size=len(y))])
	y_ = y_.T
	else:
	y_ = y
	reg.fit(X, y_)
	except Exception as e:
	print(reg)
	print (e)
	print ()
	succeeded = False
	regressor_attribs, regressor_attrib_dicts = attrib_gather_other(regressor_attribs,
	regressor_attrib_dicts,
	reg, Reg)

	# Classifiers
	classifiers = [(name, E) for name, E in estimators if issubclass(E,
	ClassifierMixin)]

	iris = load_iris()
	X, y = iris.data, iris.target
	X, y = shuffle(X, y, random_state=7)
	classifier_attribs = []
	classifier_attrib_dicts = []
	for name, Clf in classifiers:
	if Clf in dont_test or Clf in meta_estimators:
	continue
	# catch deprecation warnings
	with warnings.catch_warnings(record=True):
	clf = Clf()
	clf.fit(X, y)
	classifier_attribs, classifier_attrib_dicts = attrib_gather_other(classifier_attribs,
	classifier_attrib_dicts,
	clf, Clf)

	# Obtain dont_test and meta_estimators attributes
	other_attribs = []
	other_attrib_dicts = []

	# Pipeline - attribute 'steps' should be 'steps_'
	digits = load_digits()
	X_digits = digits.data
	y_digits = digits.target
	logistic = LogisticRegression()
	item = Pipeline(steps=[('logistic', logistic)])
	item.fit(X_digits, y_digits)
	other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
	other_attrib_dicts,
	item, Pipeline)

	# BaseEnsemble - No attributes/no fit method

	# OneVsRestClassifier
	X, Y = make_multilabel_classification(n_classes=2, n_labels=1,
	allow_unlabeled=True,
	random_state=1)
	item = OneVsRestClassifier(SVC(kernel='linear'))
	item.fit(X, Y)
	other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
	other_attrib_dicts,
	item,
	OneVsRestClassifier)

	# OutputCodeClassifier
	X, y = iris.data, iris.target
	item = OutputCodeClassifier(LinearSVC())
	item.fit(X, y)
	other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
	other_attrib_dicts,
	item,
	OutputCodeClassifier)

	# OneVsOneClassifier
	item = OneVsOneClassifier(LinearSVC())
	item.fit(X, y)
	other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
	other_attrib_dicts,
	item,
	OneVsOneClassifier)

	# FeatureUnion
	pca = PCA(n_components=2)
	selection = SelectKBest(k=1)
	item = FeatureUnion([("pca", pca), ("univ_select", selection)])
	item.fit(X, y)
	other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
	other_attrib_dicts,
	item,
	FeatureUnion)

	# GridSearchCV
	parameters = {'kernel':('linear', 'rbf'), 'C':[1, 10]}
	svr = SVC()
	item = GridSearchCV(svr, parameters)
	item.fit(iris.data, iris.target)
	other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
	other_attrib_dicts,
	item,
	GridSearchCV)

	# RFE
	generator = check_random_state(0)
	X = np.c_[iris.data, generator.normal(size=(len(iris.data), 6))]
	y = iris.target
	clf = SVC(kernel="linear")
	item = RFE(estimator=clf, n_features_to_select=4, step=0.1)
	item.fit(X, y)
	other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
	other_attrib_dicts,
	item,
	RFE)

	#RFECV
	item = RFECV(estimator=SVC(kernel="linear"), step=1, cv=3)
	item.fit(X, y)
	other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
	other_attrib_dicts,
	item,
	RFECV)

	# SparseCoder
	y = np.linspace(0, 4 - 1, 10)
	item = SparseCoder(y, transform_algorithm='lasso_lars')
	item.fit(y)
	other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
	other_attrib_dicts,
	item,
	SparseCoder)

	# EllipticEnvelope
	X1 = load_boston()['data'][:, [8, 10]] # two clusters
	item = EllipticEnvelope(support_fraction=1., contamination=0.261)
	item.fit(X1)
	other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
	other_attrib_dicts,
	item,
	EllipticEnvelope)

	# DictVectorizer
	D = [{'foo': 1, 'bar': 2}, {'foo': 3, 'baz': 1}]
	item = DictVectorizer(sparse=False)
	item.fit_transform(D)
	other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
	other_attrib_dicts,
	item,
	DictVectorizer)

	#LabelBinarizer
	item = LabelBinarizer()
	item.fit([1, 2, 6, 4, 2])
	other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
	other_attrib_dicts,
	item,
	LabelBinarizer)

	#LabelEncoder
	item = LabelEncoder()
	item.fit([1, 2, 2, 6])
	other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
	other_attrib_dicts,
	item,
	LabelEncoder)

	# TfidfTransformer
	JUNK_FOOD_DOCS = (
	"the pizza pizza beer copyright",
	"the pizza burger beer copyright",
	)
	what_we_like = ["pizza", "beer"]
	item = TfidfTransformer()
	pipe = Pipeline([
	('count', CountVectorizer(vocabulary=what_we_like)),
	('tfidf', item)])
	pipe.fit_transform(JUNK_FOOD_DOCS)
	other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
	other_attrib_dicts,
	item,
	TfidfTransformer)

	# IsotonicRegression
	n = 100
	x = np.arange(n)
	rs = check_random_state(0)
	y = rs.randint(-50, 50, size=(n,)) + 50. * np.log(1 + np.arange(n))
	item = IsotonicRegression()
	item.fit(x, y)
	other_attribs, other_attrib_dicts = attrib_gather_other(other_attribs,
	other_attrib_dicts,
	item,
	IsotonicRegression)


	######################
	# Process the gathered attributes

	print("\n\nATTRIBUTES\n=============\n", file=f)
	print("All parameters and the ammount of times they are used\n", file=f)

	all_attribs = transformers_attribs + clustering_attribs \
	+ regressor_attribs + classifier_attribs \
	+ other_attribs
	all_attrib_dicts = transformers_attrib_dicts + clustering_attrib_dicts \
	+ regressor_attrib_dicts + classifier_attrib_dicts \
	+ other_attrib_dicts

	flat_attrib = [x for c in all_attribs for x in c]
	unique_a, indices_a = np.unique(flat_attrib, return_inverse=True)
	attrib_table = np.vstack([unique_a, np.bincount(indices_a)]).T
	max_width, _ = [max(len((x)) for x in line) for line in zip(*attrib_table)]
	print ("================================== ====", file=f)
	for name, count in attrib_table :
	print ("%s %s" % (name.ljust(max_width), count), file=f)
	print ("================================== ====", file=f)
	print('\n', file=f)

	for attrib in unique_a:
	est = []
	str = attrib + ' is used in the following classes'
	print(str, file=f)
	for e in all_attrib_dicts:
	if attrib in e.values()[0]:
	est.append(e.keys()[0].__name__)
	for u in np.unique(est):
	print (' * ' + u, file=f)
	print('\n', file=f)

	print ("\nCompleted\n----------")

	#print '\n\nList of Classes that derive from the BaseEstimator:'
	#for c in np.unique(all_objects_p):
	# print c.__class__
C	14
U_init	1
V_init	1
affinity	2
algorithm	12
alpha	28
alpha_1	2
alpha_2	2
alphas	7
analyzer	2
assign_labels	1
assume_centered	7
bandwidth	1
batch_size	1
beta	2
beta0	1
bin_seeding	1
binarize	1
binary	2
block_size	1
bootstrap	4
cache_size	10
callback	1
charset	2
charset_error	2
chunk_size	2
class_weight	13
cluster_all	1
code_init	1
coef0	11
compute_full_tree	2
compute_importances	8
compute_labels	1
compute_score	2
connectivity	2
contamination	2
convergence_iter	1
convit	1
copy	17
copy_Gram	1
copy_X	18
copy_Xy	1
copy_x	1
corr	1
covariance_type	5
covars_prior	2
covars_weight	1
criterion	9
cv	8
damping	1
deflation_mode	1
degree	11
dict_init	2
dtype	3
dual	5
eig_tol	1
eigen_solver	3
eps	10
epsilon	6
eta	2
eta0	3
feature_range	1
fit_algorithm	2
fit_intercept	33
fit_inverse_transform	1
fit_path	2
fit_prior	2
fun	1
fun_args	1
fun_prime	1
gamma	15
gcv_mode	3
gmms	1
hessian_tol	1
init	6
init_params	7
init_size	1
input	2
intercept_scaling	5
iterated_power	1
k	4
kernel	13
l1_ratio	5
lambda_1	2
lambda_2	2
leaf_size	5
learn_rate	2
learning_rate	4
loss	10
loss_func	4
lowercase	2
max_depth	10
max_df	2
max_features	12
max_iter	44
max_iters	2
max_n	2
max_n_alphas	2
max_no_improvement	1
max_patches	1
means_prior	1
means_weight	1
memory	4
method	3
metric	3
min_covar	3
min_density	8
min_df	2
min_n	2
min_samples	1
min_samples_leaf	10
min_samples_split	10
mode	5
modified_tol	1
multi_class	4
n_alphas	2
n_atoms	2
n_clusters	5
n_components	32
n_estimators	6
n_init	5
n_iter	16
n_jobs	19
n_mix	1
n_neighbors	8
n_nonzero_coefs	2
n_refinements	1
n_resampling	2
neg_label	1
neighbors_algorithm	2
ngram_range	2
nls_max_iter	2
noise_variance_init	1
norm	3
norm_y_weights	1
normalize	24
nu	6
nugget	1
oob_score	4
optimizer	1
outlier_label	1
p	7
param	1
params	7
patch_size	1
path_method	1
penalty	8
percentile	1
pos_label	1
positive	2
power_t	2
pre_dispatch	2
precompute	10
precompute_distances	1
precompute_gram	1
precomputed	1
preference	1
preprocessor	2
priors	2
probability	9
radius	3
random_start	1
random_state	50
reg	1
regr	1
rho	5
ridge_alpha	2
sample_fraction	2
sample_interval	1
sample_steps	1
scale	5
scaling	2
score_func	10
seeds	1
selection_threshold	2
separator	1
shrink_threshold	1
shrinkage	1
shrinking	10
shuffle	7
skewedness	1
smooth_idf	2
solver	2
sparse	1
sparseness	2
split_sign	2
startprob	4
startprob_prior	4
stop_words	2
storage_mode	1
store_cv_values	3
store_precision	7
strip_accents	2
sublinear_tf	2
subsample	2
support_fraction	3
theta0	1
thetaL	1
thetaU	1
thresh	7
threshold	1
threshold_lambda	1
token_pattern	2
tokenizer	2
tol	46
transform_algorithm	2
transform_alpha	2
transform_n_nonzero_coefs	2
transmat	4
transmat_prior	4
use_idf	2
verbose	50
vocabulary	2
w_init	1
warm_start	9
warn_on_equidistant	3
weights	4
whiten	4
with_mean	2
with_std	2
y_max	1
y_min	1
K_fit_all_	1
K_fit_rows_	1
X_	3
X_fit_	1
_intercept_	8
active_	4
affinity_matrix_	2
all_scores_	2
alpha_	10
alphas_	8
best_estimator_	1
best_params_	1
best_score_	1
centroids_	1
children_	3
class_log_prior_	2
class_prior_	1
class_weight_	16
class_weight_label_	16
classes_	49
cluster_centers_	5
cluster_centers_indices_	1
code_book_	1
coef_	50
coef_path_	6
comp_sparseness_	2
components_	13
core_sample_indices_	1
counts_	2
covariance_	2
criterion_	1
cv_alphas_	2
cv_mse_path_	2
cv_scores_	1
data_sparseness_	2
dist_	1
dist_matrix_	1
dual_coef_	8
dual_gap_	4
embedding_	2
eps_	4
error_	2
estimator_	2
estimators_	13
explained_variance_	3
explained_variance_ratio_	3
feature_importances_	18
feature_log_prob_	2
feature_names_	1
find_split_	8
fit_status_	8
grid_scores_	1
idf_	1
inertia_	4
init_size_	2
intercept_	50
kernel_pca_	1
l1_ratio_	2
label_	8
label_binarizer_	1
label_distributions_	2
labels_	11
lambda_	1
lambdas_	1
location_	1
loglike_	1
loss_	2
mean_	6
means_	3
min_	1
mse_path_	2
multilabel_	1
n_classes_	18
n_features_	18
n_leaves_	3
n_outputs_	16
n_support_	8
nbrs_	2
noise_variance_	1
oob_score_	2
precision_	1
priors_	3
probA_	8
probB_	8
pvalues_	6
random_offset_	2
random_weights_	2
rank_	1
ranking_	2
raw_coef_	8
raw_covariance_	1
raw_location_	1
raw_support_	1
reconstruction_err_	2
reconstruction_error_	1
reduced_likelihood_function_value_	1
residues_	1
rho_	2
scale_	1
scores_	10
shape_fit_	8
sigma_	2
singular_	1
sources_	1
sparse_coef_	4
std_	2
support_	7
support_vectors_	8
t_	10
theta_	2
train_score_	2
training_data_	1
transduction_	2
tree_	8
unmixing_matrix_	1
vocabulary_	1
x_loadings_	8
x_mean_	9
x_rotations_	8
x_scores_	9
x_std_	9
x_weights_	9
xbar_	2
y_	1
y_loadings_	8
y_mean_	9
y_rotations_	8
y_scores_	9
y_std_	9
y_weights_	9