Python SVC.get_params方法代码示例

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import get_params [as 别名]
def TrainModel(modelName='SvmModel_2'):
	svm_model = None
	try:
		svm_model = ReadCsvFile.ReadValueFromFile(modelName)
		logging.info("load model success")
	except:

		print "Train model"
		logging.info("Train model")
		svm_model = SVC(decision_function_shape="ovo")
		# for i in xrange(len(train_data)/1000+1):
		i = 0
		start_index = i*10000
		end_index = (i+2)*10000
		# if end_index >= len(train_data):
		# 	end_index = len(train_data)
		svm_model.fit(train_Xc[start_index:end_index],train_lab[start_index:end_index])
		print svm_model.get_params()
			# if end_index == len(train_data):
			# 	break
		print "save model"
		logging.info("save model")
		wr = WriteResult()
		wr.WriteValueToFile(svm_model,modelName)
		print "精确度为: {0}".format(svm_model.score(train_Xc[end_index-1000:end_index],train_lab[end_index-1000:end_index]))
	return svm_model

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import get_params [as 别名]
def svm(c,d):
	create_mat()
	clf = SVC(C=pow(5,c),degree=d,decision_function_shape='ovr',kernel='poly')
	print (clf.get_params())
	X_scaled = preprocessing.scale(X)
	print (X_scaled.shape)
	print (Y.shape)
	clf.fit(X_scaled,Y)
	scores = cross_validation.cross_val_score(clf,X_scaled,Y,cv=10)
	print (Y)
	print (scores)
	print("Accuracy: %0.2f (+/- %0.2f)" % (scores.mean(), scores.std() * 2))
	f = open('RecordSVM.txt','a+')
	f.write("The parameter C is %0.4f\n" % clf.get_params()['C']);
	#f.write("Accuracy: %0.2f (+/- %0.2f)\n" % (scores.mean(), scores.std() * 2))
	f.write("Error: %0.2f, %0.2f, %0.2f)\n" % (1-scores.mean(), 1-scores.mean()+scores.std(),1-scores.mean()-scores.std()))
	f.close()

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import get_params [as 别名]
class Trainer():
	def __init__(self):
		self.load_data('mysql_dump.pickle')
		self.drop_columns()
		self.loanData = self.loanData.dropna()
		self.loanData.index = range(len(self.loanData))
		self.originalLoanData.index = range(len(self.originalLoanData))
		self.drop_some_pos_samples()
		self.split_train_test()

	def load_data(self, fileName):
		print "Loading %s" %fileName
		f = open(fileName, 'rb')
		self.loanData = pickle.load(f)
		self.originalLoanData = self.loanData	#including dropped columns

	def drop_columns(self):
		self.loanData = self.loanData.drop(['Any', 
											'issue_d', 
											'last_pymnt_d',
											'unemp_rate_3mths',
											'unemp_rate_6mths',
											'unemp_rate_12mths',
											'days_active'
											], 1)

	def drop_some_pos_samples(self):
		for i in range(30000):
			if self.loanData['loan_status'][i] == 1:
				self.loanData['loan_status'].iloc[i] = 3
				self.originalLoanData['loan_status'].iloc[i] = 3
		self.loanData = self.loanData[self.loanData['loan_status'] != 3]
		self.originalLoanData = self.originalLoanData[self.originalLoanData['loan_status'] != 3]

	def split_train_test(self, test_size=0.2):

		features = self.loanData.drop(['loan_status'], 1).values
		targets = self.loanData['loan_status'].values
		self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(features, 
																	targets, 
																	test_size=test_size)
		self.X_train = self.X_train.astype(float)
		self.y_train = self.y_train.astype(float)
		self.X_test = self.X_test.astype(float)
		self.y_test = self.y_test.astype(float)

		print "Loans in training set: ", len(self.y_train)
		print "Defaults in training set: ", np.sum(self.y_train == 0)
		print "Loans in testing set: ", len(self.y_test)
		print "Defaults in testing set: ", np.sum(self.y_test == 0)


	def scale(self):
		self.scalerX = StandardScaler().fit(self.X_train)
		self.X_train, self.X_test = self.scalerX.transform(self.X_train), \
									self.scalerX.transform(self.X_test)

	def standardize_samples(self):
		##0 mean, unit variance
		self.X_train = preprocessing.scale(self.X_train)
		self.X_test = preprocessing.scale(self.X_test)

	def scale_samples_to_range(self):
		##Samples lie in range between 0 and 1
		minMaxScaler = preprocessing.MinMaxScaler()
		self.X_train = minMaxScaler.fit_transform(self.X_train)
		self.X_test = minMaxScaler.fit_transform(self.X_test)

	def run_pca(self, n_components=20):
		self.pca = PCA(n_components=n_components)
		self.X_train = self.pca.fit_transform(self.X_train)
		print "Reduced data down to ", self.pca.n_components_, " dimensions: "
		print "Transforming test data ..."
		self.X_test = self.pca.transform(self.X_test)

	def define_rfc(self, n_estimators=20):
		self.clf = RandomForestClassifier(n_estimators=n_estimators)
		print self.clf.get_params()

	def defineSVC(self, C=1.0, kernel='rbf', degree=3, gamma=0.0, coef0=0.0, shrinking=True, 
				  probability=False, tol=0.01, cache_size=200, class_weight='auto', verbose=True, 
				  max_iter=-1, random_state=None):

		print "Using a Support Vector Machine Classifier ..."
		self.clf = SVC(C=C, kernel=kernel, degree=degree, gamma=gamma, coef0=coef0, shrinking=shrinking, 
				  probability=probability, tol=tol, cache_size=cache_size, class_weight=class_weight, verbose=verbose, 
				  max_iter=max_iter, random_state=random_state)
		print self.clf.get_params()

	def train(self):
		print "training classifier"
		self.clf.fit(self.X_train, self.y_train)

	def score(self, y_actual, pred):
		print classification_report(y_actual, pred)
		print "predict 0: ", np.sum(pred == 0)
		print "predict 1: ", np.sum(pred == 1)
		print "actual 0: ", np.sum(y_actual == 0)
		print "actual 0: ", np.sum(y_actual == 1)
		#print "feature importances:"
#.........这里部分代码省略.........

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import get_params [as 别名]
logregCV = linear_model.LogisticRegressionCV(max_iter=5000, solver='liblinear')
print 'LogisticRegressionCV config:'
print logregCV.get_params()
logregCV.fit(smr_train.feature_matrix, smr_train.labels)
logregCV_score_train = logregCV.score(smr_train.feature_matrix, smr_train.labels)
print 'LogisticRegressionCV precision train: {}'.format(logregCV_score_train)
logregCV_score_test = logregCV.score(smr_test.feature_matrix, smr_test.labels)
print 'LogisticRegressionCV precision test: {}'.format(logregCV_score_test)
print 'RAW LogisticRegressionCV performance:'
print classification_report(smr_test.labels, logregCV.predict(smr_test.feature_matrix))
# plot_learning_curve(logregCV, 'logregCV Curve', smr_train.feature_matrix, smr_train.labels, n_jobs=4)
print ''

svc = SVC(gamma=0.001, kernel='linear')
print 'SVC config:'
print svc.get_params()
svc.fit(smr_train.feature_matrix, smr_train.labels)
svc_score_train = svc.score(smr_train.feature_matrix, smr_train.labels)
print 'SVC precision train: {}'.format(svc_score_train)
svc_score_test = svc.score(smr_test.feature_matrix, smr_test.labels)
print 'SVC precision test: {}'.format(svc_score_test)
# plot_learning_curve(svc, 'SVC Curve', smr_train.feature_matrix, smr_train.labels, n_jobs=4)
print ''

svr = SVR()
print 'SVR config:'
print svr.get_params()
svr.fit(smr_train.feature_matrix, smr_train.labels)
svr_score_train = svr.score(smr_train.feature_matrix, smr_train.labels)
print 'SVR precision train: {}'.format(svr_score_train)
svr_score_test = svr.score(smr_test.feature_matrix, smr_test.labels)

# 需要导入模块: from sklearn.svm import SVC [as 别名]
# 或者: from sklearn.svm.SVC import get_params [as 别名]
from sklearn.cross_validation import train_test_split
from sklearn.svm import SVC
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.grid_search import GridSearchCV

dataset = pd.read_csv("data/australian.data", header=None, sep=" ")
X = dataset.drop(14, axis=1)        # Features
y = dataset[14]                     # Labels

# Produces a "one hot encoding" of the data
scaler = StandardScaler()
X = scaler.fit_transform(X)
conv_X = pd.get_dummies(pd.DataFrame(X), columns=[0, 3, 4, 5, 7, 8, 10, 11])

X_train, X_test, y_train, y_test = train_test_split(conv_X, y, test_size=0.25,
                                                    random_state=888)

reg = LogisticRegression()
reg.fit(X_train, y_train)
predictions = reg.predict(X_test)
print "Accuracy score for logreg: ", accuracy_score(y_test, predictions)

parameters = {"C": [0.5, 1, 2, 3, 4, 10], "kernel": ["rbf", "poly", "linear"]}
svm = SVC()
clf = GridSearchCV(svm, parameters)
svm.fit(X_train, y_train)
predictions = svm.predict(X_test)
print "Accuracy score for svm: ", accuracy_score(y_test, predictions)
print "Parameters: ", svm.get_params()