Python QDA.predict方法代码示例

# 需要导入模块: from sklearn.qda import QDA [as 别名]
# 或者: from sklearn.qda.QDA import predict [as 别名]
    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?"""

# 需要导入模块: from sklearn.qda import QDA [as 别名]
# 或者: from sklearn.qda.QDA import predict [as 别名]
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

# 需要导入模块: from sklearn.qda import QDA [as 别名]
# 或者: from sklearn.qda.QDA import predict [as 别名]
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)

# 需要导入模块: from sklearn.qda import QDA [as 别名]
# 或者: from sklearn.qda.QDA import predict [as 别名]
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

# 需要导入模块: from sklearn.qda import QDA [as 别名]
# 或者: from sklearn.qda.QDA import predict [as 别名]
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"

# 需要导入模块: from sklearn.qda import QDA [as 别名]
# 或者: from sklearn.qda.QDA import predict [as 别名]
def QDA_onNonDynamicData():
    #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')

    #Getting the dataset associated with Non-Dynamic Activities on training 
    X_NonDynamic,Y_NonDynamic = common.getDataSubset(XFull,YFull.flatten(),[4,5,6])
    #Getting the dataset associated with Non-Dynamic Activities on testing
    X_NonDynamicTest,Y_NonDynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[4,5,6])

    #Fitting data using QDA classifier

    clf = QDA()
    clf.fit(X_NonDynamic, Y_NonDynamic.flatten())

    precision,recall,fscore = common.checkAccuracy(clf.predict(X_NonDynamicTest),Y_NonDynamicTest,[4,5,6])
    common.createConfusionMatrix(clf.predict(X_NonDynamicTest).flatten(),Y_NonDynamicTest.flatten(),[4,5,6])
    print fscore

    #Getting the dataset associated with Dynamic Activities on training 
    X_Dynamic,Y_Dynamic = common.getDataSubset(XFull,YFull.flatten(),[1,2,3])
    #Getting the dataset associated with Dynamic Activities on testing
    X_DynamicTest,Y_DynamicTest = common.getDataSubset(XFullTest,YFullTest.flatten(),[1,2,3])
    print len(X_DynamicTest),len(Y_DynamicTest)

    #Fitting data using QDA classifier
    clf = QDA()
    clf.fit(X_Dynamic, Y_Dynamic.flatten())

    precision,recall,fscore = common.checkAccuracy(clf.predict(X_DynamicTest),Y_DynamicTest,[1,2,3])
    common.createConfusionMatrix(clf.predict(X_DynamicTest).flatten(),Y_DynamicTest.flatten(),[1,2,3])

    print fscore

# 需要导入模块: from sklearn.qda import QDA [as 别名]
# 或者: from sklearn.qda.QDA import predict [as 别名]
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

# 需要导入模块: from sklearn.qda import QDA [as 别名]
# 或者: from sklearn.qda.QDA import predict [as 别名]
def runQDA(fileNamaParam, trainizingSizeParam):
  # what percent will you use ? 
  testSplitSize = 1.0 - trainizingSizeParam
  testAndTrainData = IO_.giveTestAndTrainingData(fileNamaParam)
  trainData = testAndTrainData[0]
  testData = testAndTrainData[1]
  ### classification   
  ## get the test and training sets 
  featureSpace_train, featureSpace_test, vScore_train, vScore_test = cross_validation.train_test_split(trainData, testData, test_size=testSplitSize, random_state=0) 
  ## fire up the model   
  theQDAModel = QDA()
  theQDAModel.fit(featureSpace_train, vScore_train)
  thePredictedScores = theQDAModel.predict(featureSpace_test)
  #print "The original vector: "
  #print vScore_test
  #print "The predicted score vector: "
  #print thePredictedScores
  evalClassifier(vScore_test, thePredictedScores) 

# 需要导入模块: from sklearn.qda import QDA [as 别名]
# 或者: from sklearn.qda.QDA import predict [as 别名]
def qda(input_file,Output,test_size):
    lvltrace.lvltrace("LVLEntree dans qda split_test")
    try:
        ncol=tools.file_col_coma(input_file)
        data = np.loadtxt(input_file, delimiter=',', usecols=range(ncol-1))
        X = data[:,1:]
        y = data[:,0]
        n_samples, n_features = X.shape
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size)
        print X_train.shape, X_test.shape
        lda=QDA()
        lda.fit(X_train,y_train)
        y_pred = lda.predict(X_test)
        print "Quadratic Discriminant Analysis Accuracy "
        print "classification accuracy:", metrics.accuracy_score(y_test, y_pred)
        print "precision:", metrics.precision_score(y_test, y_pred)
        print "recall:", metrics.recall_score(y_test, y_pred)
        print "f1 score:", metrics.f1_score(y_test, y_pred)
        #LVLprint "\n"
        results = Output+"QDA_metrics_test.txt"
        file = open(results, "w")
        file.write("Quadratic Discriminant Analaysis estimator accuracy\n")
        file.write("Classification Accuracy Score: %f\n"%metrics.accuracy_score(y_test, y_pred))
        file.write("Precision Score: %f\n"%metrics.precision_score(y_test, y_pred))
        file.write("Recall Score: %f\n"%metrics.recall_score(y_test, y_pred))
        file.write("F1 Score: %f\n"%metrics.f1_score(y_test, y_pred))
        file.write("\n")
        file.write("True Value, Predicted Value, Iteration\n")
        for n in xrange(len(y_test)):
            file.write("%f,%f,%i\n"%(y_test[n],y_pred[n],(n+1)))
        file.close()
        title = "QDA %f"%test_size
        save = Output + "QDA_confusion_matrix"+"_%s.png"%test_size
        plot_confusion_matrix(y_test, y_pred,title,save)
    except (AttributeError):
        if configuration.normalization == 'normalize':
            results = Output+"Multinomial_NB_metrics_test.txt"
            file = open(results, "w")
            file.write("In configuration.py file, normalization='normalize' -- Input Values must be superior to 0\n")
            file.close()
    lvltrace.lvltrace("LVLSortie dans qda split_test")

# 需要导入模块: from sklearn.qda import QDA [as 别名]
# 或者: from sklearn.qda.QDA import predict [as 别名]
class QDAClassifier(Classifier):
    '''Quadratic Discriminant analysis classifier'''
    def __init__(self):
        super(QDAClassifier, self).__init__()
        self.fig = 20
        self.is_trainable = True
        self.is_trained = False

    def train(self, classification_data, indices=None, settings_name=None, **kwargs):
        super(QDAClassifier, self).train(classification_data, indices, settings_name, **kwargs)
        indices = self.settings['indices']

        self.qda = QDA(**self.classifier_kwargs)

        self.qda.fit(classification_data.data[:, indices], classification_data.are_hurr_actual)
        return self

    def classify(self, classification_data):
        super(QDAClassifier, self).classify(classification_data)
        indices = self.settings['indices']

        self.are_hurr_pred = self.qda.predict(classification_data.data[:, indices])
        return self.are_hurr_pred

# 需要导入模块: from sklearn.qda import QDA [as 别名]
# 或者: from sklearn.qda.QDA import predict [as 别名]
error(y_test, y_predict_g, 'Gaussian Naive Bayes')
error6(y_test, y_predict_g, 'Gaussian Naive Bayes')

###############################################################################
# 3 LDA  
LDA = LDA()
LDA.fit(X_train, y_train)
y_predict_lda = LDA.predict(X_test)
error(y_test, y_predict_lda, 'LDA')
error6(y_test, y_predict_lda, 'LDA')

###############################################################################
# 4 QDA  
QDA = QDA()
QDA.fit(X_train, y_train)
y_predict_qda = QDA.predict(X_test)
error(y_test, y_predict_qda, 'QDA')
error6(y_test, y_predict_qda, 'QDA')

###############################################################################
# 5 Logistic Regression 
LR = LogisticRegression()
LR.fit(X_train, y_train)
y_predict_lr = LR.predict(X_test)
error(y_test, y_predict_lr, 'Logistic Regression')
error6(y_test, y_predict_lr, 'Logistic Regression')

###############################################################################
# 6 K-Neighbors Classifier 
KNC = KNeighborsClassifier(8)
KNC.fit(X_train, y_train)

# 需要导入模块: from sklearn.qda import QDA [as 别名]
# 或者: from sklearn.qda.QDA import predict [as 别名]
# classifier regularization parameter
p_best = 0
count_best = 0

# begin training model
print 'Training model in progress...'

for j in range(200):
    p = 0.02*j
    clf = QDA(reg_param=p)
    clf.fit(X_train, y_train)
    count = 0
    
    # fit in the test set
    for i in range(len(y_cross)):
        a = clf.predict(X_cross[i])
        b = y_cross[i]
        if (a == b):
            count += 1
            
    # update the regularization parameter
    if count > count_best:
        count_best = count
        p_best = p
        
    print "Progress at %.1f%%" %(j/2)

print 'Training model completed' 

# test the model
clf = QDA(reg_param=p_best)

# 需要导入模块: from sklearn.qda import QDA [as 别名]
# 或者: from sklearn.qda.QDA import predict [as 别名]
        remove = remove.union(redundant)
    
    print("For correlation coefficient = ", coefficient)
    #print(remove)
    #print(add)

    train_data = pd.DataFrame(data=train_data_g, columns = df.columns)[df.columns- remove].values
    test_data = pd.DataFrame(data=test_data_g, columns = df.columns)[df.columns- remove].values
    print("num of featurs = ", train_data.shape[1])

    clf = QDA();

    # This gets the time in ipython shell.
    print("Modelling time:")
    %time clf.fit(train_data, train_labels)
    print("Modelling time ends")

    print("prediction time starts:")
    %time predicted_labels = clf.predict(test_data)
    print("prediction time ends")
    #print(classification_report(test_labels, clf.predict(test_data)))
    print(classification_report(test_labels, predicted_labels))

    print("num of featurs = ", train_data.shape[1])
    y_true = test_labels;
    y_pred_proba = clf.predict_proba(test_data);
    fpr, tpr, thresholds = roc_curve(y_true, y_pred_proba[:, 1])
    roc_auc = auc(fpr, tpr)
    print("ROC AUC =", roc_auc)
    print("\n\n\n")

# 需要导入模块: from sklearn.qda import QDA [as 别名]
# 或者: from sklearn.qda.QDA import predict [as 别名]
recall_lda_50 = pre_rec(cmatrix_lda_50, y_test_count)
precision_lda_50 = pre_rec(cmatrix_lda_50, y_pred_count_lda_50)
accuracy_lda_50 = overall_accuracy(cmatrix_lda_50, y_test)

print precision_lda_50
print recall_lda_50
print accuracy_lda_50
print "####################################################################"
                
###############################################################################
###############################################################################
# 3 QDA

qda = QDA()
qda.fit(X_train, y_train)
y_predict_qda = qda.predict(X_test)

y_pred_count_qda = total_count(y_predict_qda)
cmatrix_qda = confusion_matrix(y_test, y_predict_qda)

print "\nQDA:"
print cmatrix_qda
print ""

recall_qda = pre_rec(cmatrix_qda, y_test_count)
precision_qda = pre_rec(cmatrix_qda, y_pred_count_qda)
accuracy_qda = overall_accuracy(cmatrix_qda, y_test)

print precision_qda
print recall_qda
print accuracy_qda

# 需要导入模块: from sklearn.qda import QDA [as 别名]
# 或者: from sklearn.qda.QDA import predict [as 别名]
			Test.append(1)
		if(i.split(',')[4]=='Iris-virginica'):
			Test.append(2)
	except:
		pass
h=0.02
Y=Test
X=numpy.transpose(Data)
#clf=LDA()
#clf=QDA()
clf=QDA(reg_param=0.3)
x=clf.fit(Data,Test)
x_min, x_max = X[0].min() - .5, X[0].max() + .5
y_min, y_max = X[1].min() - .5, X[1].max() + .5
xx, yy = numpy.meshgrid(numpy.arange(x_min, x_max, h), numpy.arange(y_min, y_max, h))
Z = clf.predict(numpy.c_[xx.ravel(), yy.ravel()])

# Put the result into a color plot
Z = Z.reshape(xx.shape)
plt.figure(1, figsize=(4, 3))
plt.pcolormesh(xx, yy, Z, cmap=plt.cm.Paired)

# Plot also the training points
plt.scatter(X[0], X[1], c=Y, edgecolors='k', cmap=plt.cm.Paired)
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')

plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.xticks(())
plt.yticks(())