本文整理汇总了Python中sklearn.qda.QDA类的典型用法代码示例。如果您正苦于以下问题:Python QDA类的具体用法?Python QDA怎么用?Python QDA使用的例子?那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了QDA类的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: __init__
class RegularizedQDA:
"""
Three types of regularization are possible:
- regularized the covariance of a class toward the
average variance within that class
- regularize the covariance of a class toward the
pooled covariance across all classes
- add some constant amount of variance to each feature
"""
def __init__(self, avg_weight = 0.1, pooled_weight = 0, extra_variance = 0):
self.avg_weight = avg_weight
self.pooled_weight = pooled_weight
self.extra_variance = extra_variance
self.model = QDA()
def fit(self, X, Y):
self.model.fit(X,Y)
I = np.eye(X.shape[1])
a = self.avg_weight
p = self.pooled_weight
ev = self.extra_variance
original_weight = 1.0 - a - p
scaled_pooled_cov = p * np.cov(X.T)
assert scaled_pooled_cov.shape == I.shape
assert all([C.shape == I.shape for C in self.model.rotations])
self.model.rotations = \
[original_weight * C + \
a * np.mean(np.diag(C)) * I + \
scaled_pooled_cov + ev * I \
for C in self.model.rotations]
def predict(self, X):
return self.model.predict(X)
示例2: test_all_methods
def test_all_methods(self):
x_cols = ["Lag2"]
formula = "Direction~Lag2"
# print self.df.shape[0]
train_data = self.df.ix[(self.df["Year"] >= 1990) & (self.df["Year"] <= 2008), :]
# print train_data.shape[0]
""" (d) logistic"""
model = smf.glm(formula, data=train_data, family=sm.families.Binomial())
result = model.fit()
test_data = self.df.ix[self.df["Year"] > 2008, :]
probs = Series(result.predict(sm.add_constant(test_data[["Lag2"]])))
pred_values = probs.map(lambda x: "Down" if x > 0.5 else "Up")
tp.output_table(pred_values.values, test_data[self.y_col].values)
train_X = train_data[x_cols].values
train_y = train_data[self.y_col].values
test_X = test_data[x_cols].values
test_y = test_data[self.y_col].values
""" (e) LDA """
lda_res = LDA().fit(train_X, train_y)
pred_y = lda_res.predict(test_X)
tp.output_table(pred_y, test_y)
""" (f) QDA """
qda_res = QDA().fit(train_X, train_y)
pred_y = qda_res.predict(test_X)
tp.output_table(pred_y, test_y)
""" (g) KNN """
clf = neighbors.KNeighborsClassifier(1, weights="uniform")
clf.fit(train_X, train_y)
pred_y = clf.predict(test_X)
tp.output_table(pred_y, test_y)
""" (h) logistic and LDA """
""" (i) Is the purpose of the last question going through all methods with no direction?"""
示例3: SNPForecastingStrategy
class SNPForecastingStrategy(Strategy):
def __init__(self,symbol,bars):
self.symbol=symbol
self.bars=bars
self.create_periods()
self.fit_model()
def create_periods(self):
self.start_train=datetime.datetime(2001,1,10)
self.start_test=datetime.datetime(2005,1,1)
self.end_period=datetime.datetime(2005,12,31)
def fit_model(self):
snpret=create_lagged_series(self.symbol,self.start_train,self.end_period,lags=5)
X=snpret[['Lag1','Lag2']]
Y=snpret['Direction']
X_train=X[X.index<self.start_test]
Y_train=Y[Y.index<self.start_test]
self.predictors=X[X.index>=self.start_test]
self.model=QDA()
self.model.fit(X_train,Y_train)
def generate_signals(self):
signals=pd.DataFrame(index=self.bars.index)
signals['signal']=0.0
signals['signal']=self.model.predict(self.predictors)
signals['signal'][0:5]=0.0
signals['positions']=signals['signal'].diff()
return signals
示例4: SNPForecastingStrategy
class SNPForecastingStrategy(Strategy):
"""
Requires:
symbol - A stock symbol on which to form a strategy on.
bars - A DataFrame of bars for the above symbol."""
def __init__(self, symbol, bars):
self.symbol = symbol
self.bars = bars
self.create_periods()
self.fit_model()
def create_periods(self):
"""Create training/test periods."""
self.start_train = datetime.datetime(2001,1,10)
self.start_test = datetime.datetime(2005,1,1)
self.end_period = datetime.datetime(2005,12,31)
def fit_model(self):
"""Fits a Quadratic Discriminant Analyser to the
US stock market index (^GPSC in Yahoo)."""
# Create a lagged series of the S&P500 US stock market index
snpret = create_lagged_series(self.symbol, self.start_train,
self.end_period, lags=5)
# Use the prior two days of returns as
# predictor values, with direction as the response
X = snpret[["Lag1","Lag2"]]
y = snpret["Direction"]
# Create training and test sets
X_train = X[X.index < self.start_test]
y_train = y[y.index < self.start_test]
# Create the predicting factors for use
# in direction forecasting
self.predictors = X[X.index >= self.start_test]
# Create the Quadratic Discriminant Analysis model
# and the forecasting strategy
self.model = QDA()
self.model.fit(X_train, y_train)
def generate_signals(self):
"""Returns the DataFrame of symbols containing the signals
to go long, short or hold (1, -1 or 0)."""
signals = pd.DataFrame(index=self.bars.index)
signals['signal'] = 0.0
# Predict the subsequent period with the QDA model
signals['signal'] = self.model.predict(self.predictors)
# Remove the first five signal entries to eliminate
# NaN issues with the signals DataFrame
signals['signal'][0:5] = 0.0
signals['positions'] = signals['signal'].diff()
return signals
示例5: performSVMClass
def performSVMClass(X_train, y_train, X_test, y_test, parameters, fout, savemodel):
"""
SVM binary classification
"""
clf = QDA()
clf.fit(X_train, y_train)
accuracy = clf.score(X_test, y_test)
return accuracy
示例6: performQDAClass
def performQDAClass(X_train, y_train, X_test, y_test):
"""
Gradient Tree Boosting binary Classification
"""
clf = QDA()
clf.fit(X_train, y_train)
accuracy = clf.score(X_test, y_test)
#auc = roc_auc_score(y_test, clf.predict(X_test))
return accuracy
示例7: qda
def qda(data,labels,n,v_type):
train_data,train_labels,test_data,test_labels = split_data(data,labels,v_type)
clf = QDA()
clf.fit(train_data, train_labels)
y_pred = clf.predict(test_data)
pure_accuracy_rate = len([y_pred[x] for x in range(len(y_pred)) if y_pred[x] == test_labels[x]])/float(len(test_labels))
report = classification_report(y_pred, test_labels, target_names=rock_names)
cm = confusion_matrix(test_labels, y_pred)
return pure_accuracy_rate,report,y_pred,test_labels,test_data,clf,cm,"QDA"
开发者ID:evanmosseri,项目名称:The-Classification-of-Igneous-Rocks-Through-Oxide-Components,代码行数:10,代码来源:rocksep_utils.py
示例8: QDA
def QDA(self,membership,group_labels=None,std=3,ellipses=True,dpi=300,fontsize=10,MD=False,
legend=False, numbered=False,of='pdf'):
self.type = 'QDA'
membership = membership.astype(int)
qda = QDA()
self.fit = qda.fit(self.data, membership).predict(self.data)
if ellipses:
self.getEllipses(std,membership)
self.PlotXDA(membership,group_labels=group_labels,std=std,ellipses=ellipses,dpi=dpi,
fontsize=fontsize,MD=MD,legend=legend,numbered=numbered,of=of)
self.Store()
示例9: qda_predict
def qda_predict(train_data, test_data, train_cat, xx, yy):
# QDA CLASSIFIER
qda_classifier = QDA()
qda_fit = qda_classifier.fit(train_data, train_cat)
predicted = qda_fit.predict(test_data)
contour = qda_fit.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]
contour = contour.reshape(xx.shape)
return predicted, contour
示例10: get_QDA
def get_QDA(Xtrain, Xtest, Ytrain, Ytest):
qda = QDA()
qda.fit(Xtrain,Ytrain)
# predLabels = qda.predict(Xtest)
# print("Classification Rate Test QDA: " + str(np.mean(Ytest==predLabels)*100) + " %")
scores = np.empty((4))
scores[0] = qda.score(Xtrain,Ytrain)
scores[1] = qda.score(Xtest,Ytest)
print('QDA, train: {0:.02f}% '.format(scores[0]*100))
print('QDA, test: {0:.02f}% '.format(scores[1]*100))
return qda
示例11: train_qda
def train_qda(X, y, priors=None, reg_param=0.0):
"""
Builds a quadratic discriminant analysis model
Returns:
clf: Fitted QDA model
"""
clf = QDA(priors=priors,
reg_param=reg_param)
clf = clf.fit(X,y)
print 'Quadratic Discriminant Analysis completed!'
return clf
示例12: QuadraticDiscriminantAnalysis
def QuadraticDiscriminantAnalysis(x_train, y_train, x_cv, y_cv):
"""
Quadratic Discriminant Analysis Classifier
"""
print "Quadratic Discriminant Analysis"
clfr = QDA()
clfr.fit(x_train, y_train)
#print 'Accuracy in training set: %f' % clfr.score(x_train, y_train)
#if y_cv != None:
#print 'Accuracy in cv set: %f' % clfr.score(x_cv, y_cv)
return clfr
示例13: train_classifier
def train_classifier(xTrain_s, yTrain_s, kwargs):
"""
Train a naive baise classifier on xTrain and yTrain and return the trained
classifier
"""
if type(xTrain_s) != list:
classifier_s = QDA(**kwargs)
classifier_s.fit(xTrain_s, yTrain_s)
else:
classifier_s = train_classifier_8(xTrain_s, yTrain_s, kwargs)
return classifier_s
示例14: QDA_onFullDataset
def QDA_onFullDataset():
#Parsing Full training dataset
XFull = common.parseFile('../UCI HAR Dataset/train/X_train.txt')
YFull = common.parseFile('../UCI HAR Dataset/train/y_train.txt')
#Parsing Full testing dataset
XFullTest = common.parseFile('../UCI HAR Dataset/test/X_test.txt')
YFullTest = common.parseFile('../UCI HAR Dataset/test/y_test.txt')
#Fitting data using QDA classifier
clf = QDA()
clf.fit(XFull, YFull.flatten())
#Testing the results
precision,recall,fscore = common.checkAccuracy(clf.predict(XFullTest),YFullTest,[1,2,3,4,5,6])
print fscore
示例15: fit_model
def fit_model(self):
"""Fits a Quadratic Discriminat Analyser to the US
sock market index (^GPSC in Yahoo)."""
# Create a laggged series of the S&P500 US stock market index
snpret = create_lagged_series(self.symbol, self.start_train,
self.end_period, lags=5)
# Use the prior two days of returns as
# predictor value, with direction as the response
X = snpret[["Lag1", "Lag2"]]
y = snpret["Direction"]
# Create training and test sets
X_train = X[X.index < self.start_test]
y_train = y[y.index < self.start_test]
# Create the prediciting factors for use
# in direction forecasting.
self.predictors = X[X.index >= self.start_test]
# Create the Quadractic Discriminant Analysis model
# and the forcasting strategy
self.model = QDA()
self.model.fit(X_train, y_train)