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()))
