Python DecisionTreeClassifier.set_params方法代码示例

# 需要导入模块: from sklearn.tree import DecisionTreeClassifier [as 别名]
# 或者: from sklearn.tree.DecisionTreeClassifier import set_params [as 别名]
	def dtcTuning(self, pX, change=3):
		n = pX.shape[0]
		dtc = DecisionTreeClassifier()
		best_auc = 0
		best_param = None
		for i in range( change ):		
			randp = np.random.random_sample(2)
			param = {
				'min_samples_split': 8000+int(6000 * randp[1]),
				'random_state': 2016,
				'class_weight':'balanced'
			}
			dtc.set_params(**param)
			auc = cross_val_score(dtc, pX, self.y, scoring='roc_auc').mean()
			if auc > best_auc:
				best_auc = auc
				best_param = param
		print 'decision tree: ' + str(best_auc)
		return best_auc, DecisionTreeClassifier(**best_param)

# 需要导入模块: from sklearn.tree import DecisionTreeClassifier [as 别名]
# 或者: from sklearn.tree.DecisionTreeClassifier import set_params [as 别名]

#.........这里部分代码省略.........
        elif (f_select == "kbest_anova"):
            #self.selector = SelectKBest(f_classif, k=n)
            self.selector = eval("SelectKBest(" + "f_classif," + f_select_params + ")")
        elif (f_select == "lassocv"):
            self.selector = eval("SelectFromModel(LassoCV()," + f_select_params + ")")
        elif (f_select == "rfe_svm"):
            self.selector = eval("RFE(LinearSVC()," + f_select_params + ")")
        elif (f_select == "rfecv"):
            self.selector = eval("RFECV(" + f_select_params + ")")
        elif (f_select == "rlregr"):
            self.selector = eval("RandomizedLogisticRegression(" + f_select_params + ")")
        elif (f_select == "svm"):
            print "SelectFromModel(LinearSVC(" + f_select_params + "))"
            self.selector = eval("SelectFromModel(LinearSVC(" + f_select_params + "))")
        elif (f_select == "extra_trees"):
            self.selector = eval("SelectFromModel(ExtraTreesClassifier(" + f_select_params + "))")
        elif (f_select == "random_forest"):
            self.selector = eval("SelectFromModel(RandomForestClassifier(" + f_select_params + "))")
        elif (f_select == "from_model"):
            self.selector = eval("SelectFromModel(" + f_select_params + ")")

    def fit(self, X, Y):
        Xtr = X
        if (self.classification):
            Xtr = [self.transform_features(i) for i in X]
            Xtr = self.feat_transformer.fit_transform(Xtr)
            Xtr = self.var_selector.fit_transform(Xtr)
            Y = self.label_encoder.fit_transform(Y)
            Xtr = self.selector.fit_transform(Xtr, Y)
        self.model.fit(Xtr,Y)

    def transform(self, Y):
        """ For evaluation, we want transformed predicted values. """
        return self.label_encoder.transform(Y)

    def predict(self, X):
        if not isinstance(X, list) and not isinstance(X, numpy.ndarray):
            sys.stderr.write("Warning: X is not a list (type=%s)\n" % (str(type(X))))
            #raise ValueError(X)
        if (self.classification):
            Xtr = [self.transform_features(i) for i in X]
            Xtr = self.feat_transformer.transform(Xtr)
            Xtr = self.var_selector.transform(Xtr)
            Xtr = self.selector.transform(Xtr)
            return self.label_encoder.inverse_transform(self.model.predict(Xtr))
        else:
            return self.model.predict(Xtr)
    
    def predict_proba(self, X):
        if not isinstance(X, list) and not isinstance(X, numpy.ndarray):
            sys.stderr.write("Warning: X is not a list (type=%s)\n" % (str(type(X))))
            #raise ValueError(X)
        if (self.classification):
            Xtr = [self.transform_features(i) for i in X]
            Xtr = self.feat_transformer.transform(Xtr)
            Xtr = self.var_selector.transform(Xtr)
            Xtr = self.selector.transform(Xtr)
            return self.model.predict_proba(Xtr)
        else:
            return self.model.predict_proba(Xtr)

    def score(self, X, Y):
        if (self.classification):
            Xtr = [self.transform_features(i) for i in X]
            Xtr = self.feat_transformer.transform(Xtr)
            Xtr = self.var_selector.transform(Xtr)
            Xtr = self.selector.transform(Xtr)
            Y = self.label_encoder.transform(Y)
        return self.model.score(Xtr, Y)

    def get_classes(self):
        return self.label_encoder.inverse_transform(self.model.classes_)

    def set_params(self, **params):
        self.model = self.model.set_params(**params)
        return self

    def get_params(self, deep=True):
        return self.params
 
    def print_params(self, file_path):
        f = open(file_path, "w")
        if (self.model.__class__.__name__ == "DecisionTreeClassifier"):
            f = tree.export_graphviz(self.model, out_file=f)
        f.close()

    def transform_features(self, features):
        """ Transform features with string values into new sets of features. """
        transformed = dict()
        if not self.binarize:
            return features
        for name, value in features.iteritems():
            if isinstance(value, basestring):
                name = "%s_%s" % (name,value)
                value = 1.
            transformed[name] = float(value)
        return transformed

    def setVerbose(self):
        self.verbose = True

# 需要导入模块: from sklearn.tree import DecisionTreeClassifier [as 别名]
# 或者: from sklearn.tree.DecisionTreeClassifier import set_params [as 别名]
# Setting the parameters to be varied
parameters = { 'criterion': ('gini', 'entropy'), 'splitter':('best', 'random'),
                'min_samples_split':(2,5,10)}
                

# Searching for the best parameters and printing them               
clf_simple = DecisionTreeClassifier()
# maximizing the recall score
search_param = GridSearchCV(clf_simple, parameters, scoring = 'recall',
                            cv = cv)
search_param.fit(features, labels)
print "\n\n Best parameters are:", search_param.best_params_

# Using the best parameters
clf = clf_simple.set_params(**search_param.best_params_)



test_classifier(clf, my_dataset, features_selected)

#print 'Feature importances of decision tree classifier:', \
 #clf.feature_importances_





### Task 6: Dump your classifier, dataset, and features_list so anyone can
### check your results. You do not need to change anything below, but make sure
### that the version of poi_id.py that you submit can be run on its own and

# 需要导入模块: from sklearn.tree import DecisionTreeClassifier [as 别名]
# 或者: from sklearn.tree.DecisionTreeClassifier import set_params [as 别名]
test =test.sort(1,ascending=False)
test.to_csv('C:/feature_selection.csv')


#most important variables based on my decision tree
data = data[['VehOdo','MMRAcquisitionAuctionAveragePrice','VehBCost','MMRCurrentAuctionAveragePrice','MMRAcquisitionRetailAveragePrice','VehicleAge','MMRAcquisitionAuctionCleanPrice','BYRNO','MMRCurrentAuctionCleanPrice','MMRCurrentRetailAveragePrice','MMRAcquisitonRetailCleanPrice','WarrantyCost','WheelTypeID','MMRCurrentRetailCleanPrice']]


#Trim Tree
x_train, x_test, y_train, y_test = cross_validation.train_test_split(data,target, test_size=.3)
model2 = clf.fit(x_train, y_train)
metrics.confusion_matrix(y_train, model2.predict(x_train))
print metrics.classification_report(y_train, model2.predict(x_train))
metrics.confusion_matrix(y_test, model2.predict(x_test))
print metrics.classification_report(y_test, model2.predict(x_test))
clf.set_params(min_samples_leaf=5)
clf.set_params(max_depth=5)
model3 = clf.fit(x_train, y_train)
metrics.confusion_matrix(y_train, model3.predict(x_train))
print metrics.classification_report(y_train, model3.predict(x_train))
metrics.confusion_matrix(y_test, model3.predict(x_test))
print metrics.classification_report(y_train, model3.predict(x_train))


#### Models
from sklearn.ensemble.forest import (RandomForestClassifier,
ExtraTreesClassifier)
from sklearn.ensemble import *
model = RandomForestClassifier()

# Train

# 需要导入模块: from sklearn.tree import DecisionTreeClassifier [as 别名]
# 或者: from sklearn.tree.DecisionTreeClassifier import set_params [as 别名]
wr.writerow(['min_sample_split', 'min_samples_leaf', 'Accuracy'])

#Arrays of C and Gamma that will be experimented with
min_splits = [2, 4, 8, 16, 32, 64, 128]
min_leafs = [1, 10, 100, 1000]

#Initialize rbf kernel
clf = DecisionTreeClassifier()

#Shuffle and split data 5 times using 10% of data to train and 3.3% of data to test each time
rs = cross_validation.ShuffleSplit(len(labels), n_iter=5, train_size=0.3, test_size=0.09)
for train_index, test_index in rs:
    features_train, features_test, labels_train, labels_test = \
        features[train_index], features[test_index], labels[train_index], labels[test_index]
    for c in min_splits:
        g = 1
        clf.set_params(min_samples_split=c)
        clf.set_params(min_samples_leaf=g)
        clf = clf.fit(features_train, labels_train)
        pred = clf.predict(features_test)
        wr.writerow([c, g, accuracy_score(labels_test, pred)])
    for g in min_leafs:
        c = 2
        clf.set_params(min_samples_split=c)
        clf.set_params(min_samples_leaf=g)
        clf = clf.fit(features_train, labels_train)
        pred = clf.predict(features_test)
        wr.writerow([c, g, accuracy_score(labels_test, pred)])
        
resultFile.close()