def test_classification_two_classes(self):
"""Check classification works with two classes."""
iris = load_iris()
X = iris.data[:, 1:]
y = iris.target
# Only 2 classes needed
X = X[y != 0]
y = y[y != 0]
clf = RVC()
clf.fit(X, y)
self.assertGreater(clf.score(X, y), 0.95)
prob = clf.predict_proba(X[0, :])
p_target = np.array([[0.999, 5.538e-4]])
np.testing.assert_allclose(prob, p_target, rtol=1e-2, atol=1e-2)
def TrainMyClassifier(XEstimate, ClassLabels, XValidate, Parameters):
# RVM
if Parameters['algorithm'] == 'RVM':
Parameters = Parameters['parameters']
clf = RVC(alpha=Parameters.get('alpha'),
beta=Parameters.get('beta'),
n_iter=Parameters.get('n_iter'))
clf.fit(XEstimate, ClassLabels)
if np.shape(clf.classes_)[0] == 2:
Yvalidate = clf.predict_proba(XValidate)
else:
Yvalidate = predict_proba(clf, XValidate)
EstParameters = get_params(clf)
return Yvalidate, EstParameters
#SVM
elif Parameters['algorithm'] == 'SVM':
svc = get_svc(Parameters)
svc_train(svc, XEstimate, ClassLabels)
prob = svc_probability(svc, XValidate)
EstParameters = svc_get_para(svc)
prob_std = np.ndarray.std(prob, axis=1)[:, np.newaxis]
sigmoid = 1 - expit(prob_std)
Yvalidate = np.concatenate([prob, sigmoid], axis=1)
Yvalidate = Yvalidate / np.repeat(
(sigmoid + 1), axis=1, repeats=len(svc.classes_) + 1)
return Yvalidate, EstParameters
#GPR
elif Parameters["algorithm"] == "GPR":
# get the classes from the labels
classes = np.unique(ClassLabels, axis=0)
sorted(classes, reverse=True)
num_class = len(classes)
# get data and label based on classes
data = []
for cla in classes:
data.append(XEstimate[ClassLabels == cla])
target = []
for cla in classes:
target.append(ClassLabels[ClassLabels == cla])
# put data and label into a matrix, so that we could do a easier calculation for probability
# the following calculation is all based on the matrix
data_matrix = []
for i in range(num_class - 1):
data_matrix.append([])
for j in range(num_class - 1):
data_matrix[i].append(None)
target_matrix = []
for i in range(num_class - 1):
target_matrix.append([])
for j in range(num_class - 1):
target_matrix[i].append(None)
for i in range(num_class - 1):
for j in range(i, num_class - 1):
data_matrix[i][j] = np.concatenate([data[i], data[j + 1]],
axis=0)
target_matrix[i][j] = np.concatenate(
[target[i], target[j + 1]], axis=0)
classifier_matrix = []
for i in range(num_class - 1):
classifier_matrix.append([])
for j in range(num_class - 1):
classifier_matrix[i].append(None)
for i in range(num_class - 1):
for j in range(i, num_class - 1):
gpc_classifier = GaussianProcessClassifier(
kernel=Parameters["parameters"]["kernel"],
optimizer=Parameters["parameters"]["optimizer"],
n_restarts_optimizer=Parameters["parameters"]
["n_restarts_optimizer"],
max_iter_predict=Parameters["parameters"]
["max_iter_predict"],
warm_start=Parameters["parameters"]["warm_start"],
copy_X_train=Parameters["parameters"]["copy_X_train"],
random_state=Parameters["parameters"]["random_state"],
multi_class="one_vs_rest",
n_jobs=Parameters["parameters"]["n_jobs"])
gpc_classifier.fit(data_matrix[i][j], target_matrix[i][j])
classifier_matrix[i][j] = gpc_classifier
out_matrix = []
for i in range(num_class - 1):
out_matrix.append([])
for j in range(num_class - 1):
out_matrix[i].append(None)
for i in range(num_class - 1):
for j in range(i, num_class - 1):
out_matrix[i][j] = classifier_matrix[i][j].predict_proba(
XValidate)
# calculate the whole prediction prob
val_shape = XValidate.shape[0]
predict_prob_list = []
for i in range(num_class):
predict_prob_list.append(np.zeros(shape=[val_shape, 1]))
for i in range(num_class - 1):
for j in range(i, num_class - 1):
predict_prob_list[i] += out_matrix[i][j][:,
0][:, np.newaxis] / (
num_class * 2)
predict_prob_list[
j +
1] += out_matrix[i][j][:, 1][:,
np.newaxis] / (num_class * 2)
# get the result of num_class probability
result = np.concatenate(predict_prob_list, axis=1)
# calculate the probability for the one more class
std = np.std(result, axis=1)[:, np.newaxis]
other_prob = np.exp(-std) / (1 + np.exp(std * 5))
result = np.concatenate([result, other_prob], axis=1)
result = result / np.repeat(
(other_prob + 1), axis=1, repeats=num_class + 1)
# put all the parameters into a dict
estParameters = {}
estParameters["class_num"] = num_class
estParameters["parameters"] = []
for i in range(num_class - 1):
for j in range(i, num_class - 1):
estParameters["parameters"].append({
"log_marginal_likelihood_value_":
classifier_matrix[i][j].log_marginal_likelihood_value_,
"classes_":
classifier_matrix[i][j].classes_,
"n_classes_":
classifier_matrix[i][j].n_classes_,
"base_estimator_":
classifier_matrix[i][j].base_estimator_
})
return result, estParameters
NumRVs = RVs.shape[0]
SumD = 0
for RVNum in range(1,NumRVs):
d1 = RVs[RVNum-1,]
d2 = sum(numpy.ndarray.flatten(
RVs[numpy.int8(
numpy.setdiff1d(numpy.linspace(0,NumRVs-1,NumRVs),RVNum))]))
SumD = SumD + (d1/d2)
SumD = SumD/NumRVs
return SumD
RVs = RVCMod.relevance_
DVals = RVMFeatImp(RVs)
RVCPred1 = RVCMod.predict_proba(XTestResHvM)
RVCPred2 = RVCMod.predict(XTestResHvM)
# Plot Receiver Operating Characteristic (ROC) Curve
scikitplot.metrics.plot_roc(YTestResHvM,RVCPred1, title = 'HCvMCI: RVC')
# Plot the Confusion Matrix for additional insight
scikitplot.metrics.plot_confusion_matrix(YTestResHvM,RVCPred2)
#%%
# Running RLR - HCvMCI
#Testing for multicollinearity
coef1 = np.corrcoef(HCvMCI, rowvar = False)
plt.hist(coef1)
