def perform_QuadraticDiscriminantAnalysis(self): QDA_clf = QuadraticDiscriminantAnalysis() QDA_clf.fit(self.data_train, self.labels_train) self.QuadraticDiscriminantAnalysis_result = {"parameters":QDA_clf.get_params(),"labels_test_data":QDA_clf.predict(self.data_test),"score":QDA_clf.score(self.data_test,self.labels_test)} print_dict(self.QuadraticDiscriminantAnalysis_result) print("f1_score:") print(f1_score(self.labels_test, self.QuadraticDiscriminantAnalysis_result["labels_test_data"], average='macro') )
def qda_training(X, y): """ Quadratic Discriminant Analysis model training. Estimates the test error and computes the training error. :param X: :param y: :return: """ estimator = QuadraticDiscriminantAnalysis() estimated_test_error = estimate_test_error(estimator, X, y) print("Estimated test error for model {} :\n\t{}".format( estimator.get_params(), estimated_test_error)) current_model = QuadraticDiscriminantAnalysis() current_model.fit(X, y) y_pred = current_model.predict(X) error = roc_auc_score(y, y_pred) print("Training error for model {} :\n\t{}".format( current_model.get_params(), error)) return current_model
class DiscriminantAnalysis(ClassicalModel): def __init__(self, input_size, output_size, labels, class_weights=None, **kwargs): super().__init__(input_size, output_size, labels, class_weights) self.model = QuadraticDiscriminantAnalysis(**kwargs) self.name = "Quadratic Discriminant Analysis: \n" + str( self.model.get_params())
class QDA(object): def __init__(self, priors=None, reg_param=0., store_covariance=False, tol=1.0e-4): """ :param priors: 分来优先级, array, 可选项, shape=[n_classes] :param reg_param: float, 可选项,将协方差估计正规化 :param store_covariance: boolean 如果为真,则计算并存储协方差矩阵到self.covariance_中 :param tol: 使用排序评估的阈值 """ self.model = QuadraticDiscriminantAnalysis( priors=priors, reg_param=reg_param, store_covariance=store_covariance, tol=tol) def fit(self, x, y): self.model.fit(X=x, y=y) def get_params(self, deep=True): return self.model.get_params(deep=deep) def predict(self, x): return self.model.predict(X=x) def predict_log_dict(self, x): return self.model.predict_log_proba(X=x) def predict_proba(self, x): return self.model.predict_proba(X=x) def score(self, x, y, sample_weight=None): return self.model.score(X=x, y=y, sample_weight=sample_weight) def set_params(self, **params): self.model.set_params(**params) def decision_function(self, x): # 将决策函数应用于样本数组。 return self.model.decision_function(X=x) def get_attribute(self): covariance = self.model.covariance_ # 每个种类的协方差矩阵, list of array-like of shape (n_features, n_features) means = self.model.means # 种类均值, array-like of shape (n_classes, n_features) priors = self.model.priors_ # 种类占比, 求和为1, array-like of shape (n_classes) rotations = self.model.rotations_ # n_k = min(n_features, number of elements in class k) list_array, # 高斯分布的旋转 scalings = self.model.scalings_ # list_array, 每个种类k,shape[n_k]的数组,包含高斯分布的缩放, # 如,旋转坐标系中的方差 classes = self.model.classes_ # array-like, shape(n_classes,), 不同种类标签 return covariance, means, priors, rotations, scalings, classes
y = diagnostic[:trainingSetLength, 1:] # target values (i.e. expected output for X) for i in range(len(y)): y[i] = int(y[i]) y = np.transpose(y).astype('int') trainingSet = extractedFeatures[:trainingSetLength] qda = QuadraticDiscriminantAnalysis() qda.fit(trainingSet, y[0]) # letting the algorithm know which sample in X belongs to which class labelled in y # save the params to disk qda_params = qda.get_params() params_qda = 'params_qda.sav' # save the model to disk filename_qda = 'qda_model.sav' pickle.dump(qda, open(filename_qda, 'wb')) #testSet=extractedFeatures[trainingSetLength:trainingSetLength+10] #prediction=qda.predict(testSet) pickle.dump(qda_params, open(params_qda, 'wb')) #%%TEST CLASSIFICATION - Naive Bayes excelAddress = 'C:\\Users\\theor\\Downloads\\Ground_truth_ISIC_1.xlsx' trainingSetLength = 500 diagnostic = preProcessing(excelAddress)
if decision_boundry_flag: mesh_x_min = np.min(X_test[:, 0]) - 1 #####Plotting decision boundry mesh_x_max = np.max(X_test[:, 0]) + 1 mesh_y_min = np.min(X_test[:, 1]) - 1 mesh_y_max = np.max(X_test[:, 1]) + 1 xx, yy = np.meshgrid(np.arange(mesh_x_min, mesh_x_max, 0.03), np.arange(mesh_y_min, mesh_y_max, 0.03)) Z = QDA_analysis.predict(np.c_[xx.ravel(), yy.ravel()]) Z = Z.reshape(xx.shape) pyplot.figure() pyplot.pcolormesh(xx, yy, Z) pyplot.scatter(X_train[:, 0], X_train[:, 1], c=y_train, edgecolors='k') pyplot.show() y_pred = QDA_analysis.predict(X_test) print metrics.classification_report(y_test, y_pred) print QDA_analysis.get_params() print QDA_analysis.covariances_ class_1_covariance = QDA_analysis.covariances_[0] class_2_covariance = QDA_analysis.covariances_[1] class_3_covariance = QDA_analysis.covariances_[2] print class_3_covariance #class_1_covariance=QDA_analysis.covariance_[] #X_train_transformed=QDA_analysis.transform(X_train) #direction=QDA_analysis.coef #direction=Princ_comp_analysis.components_; #print y_train.shape #train_dataset=np.append(X_train,y_train.reshape(y_train.shape[0],1),1) #X_test_transformed=QDA_analysis.transform(X_test);
plt.title('Confusion Matrix') plt.show() #Log loss (a.k.a. negative log likelihood) print('Log loss:', metrics.log_loss(y_test, post_lda)) #Plot ROC curve fpr, tpr, threshold = metrics.roc_curve(y_test, post_lda) roc_auc = metrics.auc(fpr, tpr) plt.plot(fpr, tpr, lw=2, label='ROC Curve (area = %0.2f)' % roc_auc) plt.legend(loc='lower right') plt.plot([0, 1], [0, 1], 'b--') #Diagonal line plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title('Receiver Operating Characteristic') plt.show() ###### #QDA #Run QDA for classification qda = QuadraticDiscriminantAnalysis() qda.fit(x_train, y_train) print(qda.get_params()) print('Priors:', qda.priors_) #Class prior probabilities print('Classification Accuracy:', qda.score(x_train, y_train)) #Look at complete correlation matrix print(corm)
class QuadraticDiscriminantAnalysis(Classifier): r"""Implementation of quadratic discriminant analysis classifier. Date: 2020 Author: Luka Pečnik License: MIT Reference: “The Elements of Statistical Learning”, Hastie T., Tibshirani R., Friedman J., Section 4.3, p.106-119, 2008. Documentation: https://scikit-learn.org/stable/modules/generated/sklearn.discriminant_analysis.QuadraticDiscriminantAnalysis.html#sklearn.discriminant_analysis.QuadraticDiscriminantAnalysis See Also: * :class:`niaaml.classifiers.Classifier` """ Name = 'Quadratic Discriminant Analysis' def __init__(self, **kwargs): r"""Initialize QuadraticDiscriminantAnalysis instance. """ warnings.filterwarnings(action='ignore', category=ChangedBehaviorWarning) warnings.filterwarnings(action='ignore', category=ConvergenceWarning) warnings.filterwarnings(action='ignore', category=DataConversionWarning) warnings.filterwarnings(action='ignore', category=DataDimensionalityWarning) warnings.filterwarnings(action='ignore', category=EfficiencyWarning) warnings.filterwarnings(action='ignore', category=FitFailedWarning) warnings.filterwarnings(action='ignore', category=NonBLASDotWarning) warnings.filterwarnings(action='ignore', category=UndefinedMetricWarning) self.__qda = QDA() super(QuadraticDiscriminantAnalysis, self).__init__() def set_parameters(self, **kwargs): r"""Set the parameters/arguments of the algorithm. """ self.__qda.set_params(**kwargs) def fit(self, x, y, **kwargs): r"""Fit QuadraticDiscriminantAnalysis. Arguments: x (pandas.core.frame.DataFrame): n samples to classify. y (pandas.core.series.Series): n classes of the samples in the x array. Returns: None """ self.__qda.fit(x, y) def predict(self, x, **kwargs): r"""Predict class for each sample (row) in x. Arguments: x (pandas.core.frame.DataFrame): n samples to classify. Returns: pandas.core.series.Series: n predicted classes. """ return self.__qda.predict(x) def to_string(self): r"""User friendly representation of the object. Returns: str: User friendly representation of the object. """ return Classifier.to_string(self).format(name=self.Name, args=self._parameters_to_string(self.__qda.get_params()))