def SelectLabeled(self, labeled_data_x, labeled_data_y, unlabeled_data_x):
# just append train data to labeled data
labeled_x = np.concatenate(
(self.init_labeled_data_x, labeled_data_x
)) if len(labeled_data_x) > 0 else self.init_labeled_data_x
labeled_y = np.concatenate(
(self.init_labeled_data_y, labeled_data_y
)) if len(labeled_data_x) > 0 else self.init_labeled_data_y
#
# create model to predict with confidence and credibility
model = ClassifierAdapter(
DecisionTreeClassifier(random_state=config.random_state,
min_samples_leaf=config.min_samples_leaf))
model_bcp = BootstrapConformalClassifier(
IcpClassifier(ClassifierNc(model), smoothing=True))
model_bcp.fit(labeled_x, labeled_y)
s = model_bcp.predict(unlabeled_data_x)
# print(s)
#
# selection method
labeled_ind = [
i for i, a in enumerate(s)
if a.max() > config.confidence and 1 - a.min() > config.credibility
]
unlabeled_ind = [
i for i, a in enumerate(s)
if a.max() < config.confidence or 1 - a.min() < config.credibility
]
labeled_unlabeled_x, labeled_unlabeled_y, unlabeled_data_x = \
np.take(unlabeled_data_x, labeled_ind, axis=0), np.take(s.argmax(axis=1), labeled_ind), np.take(
unlabeled_data_x, unlabeled_ind, axis=0)
#
return labeled_unlabeled_x, labeled_unlabeled_y, unlabeled_data_x
model_name = "Tree"
framework_name = 'BCP'
# ------------------------------------------------------------------------------
# prediction with significance
error_summary = []
for sig in np.arange(0, 1.0001, 0.005):
print('sig = ' + str(sig))
s_folder = StratifiedKFold(n_splits=10, shuffle=True, random_state=1)
for k, (train, test) in enumerate(s_folder.split(X, y)):
x_train, x_test = X[train], X[test]
y_train, y_test = y[train], y[test]
truth = y_test.reshape((-1, 1))
# -----------------------------------------------
# BCP
conformal_model = BootstrapConformalClassifier(IcpClassifier(ClassifierNc(ClassifierAdapter(simple_model))),
n_models=10)
conformal_model.fit(x_train, y_train)
# ------------------------------------------
# ICP
# x_train_sp, x_cal, y_train_sp, y_cal = train_test_split(x_train, y_train, test_size=0.3, shuffle=True,
# random_state=1)
# nc = NcFactory.create_nc(model=simple_model)
# conformal_model = IcpClassifier(nc)
# conformal_model.fit(x_train_sp, y_train_sp)
# conformal_model.calibrate(x_cal, y_cal)
# ---------------------------------------------------
# CP
# nc = NcFactory.create_nc(model=simple_model)
# conformal_model = IcpClassifier(nc)
# -----------------------------------------------------------------
# force_prediction
result_summary = []
s_folder = StratifiedKFold(n_splits=10, shuffle=True)
for index, (train, test) in enumerate(s_folder.split(X, y)):
x_train_std, x_test_std = X[train], X[test]
y_train, y_test = y[train], y[test]
truth = y_test.reshape((-1, 1))
lda = LinearDiscriminantAnalysis(n_components=9)
x_train_lda = lda.fit_transform(x_train_std, y_train)
x_test_lda = lda.transform(x_test_std)
nc_fun = NcFactory.create_nc(model=simple_model)
model = BootstrapConformalClassifier(IcpClassifier(nc_fun))
model.fit(x_train_lda, y_train)
prediction = model.predict(x_test_lda, significance=None)
table = np.hstack((prediction, truth))
result = [1 - force_mean_errors(prediction, truth)]
if index == 0:
result_summary = result
else:
result_summary = np.vstack((result_summary, result))
print('\nBCP_Force')
if np.unique(truth).shape[0] == 10:
print('True')
else:
print(
'Warning!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
DecisionTreeClassifier()))), RandomSubSampler()),
'ACP-CrossSampler':
AggregatedCp(
IcpClassifier(ClassifierNc(ClassifierAdapter(
DecisionTreeClassifier()))), CrossSampler()),
'ACP-BootstrapSampler':
AggregatedCp(
IcpClassifier(ClassifierNc(ClassifierAdapter(
DecisionTreeClassifier()))), BootstrapSampler()),
'CCP':
CrossConformalClassifier(
IcpClassifier(ClassifierNc(ClassifierAdapter(
DecisionTreeClassifier())))),
'BCP':
BootstrapConformalClassifier(
IcpClassifier(ClassifierNc(ClassifierAdapter(
DecisionTreeClassifier()))))
}
# -----------------------------------------------------------------------------
# Train, predict and evaluate
# -----------------------------------------------------------------------------
for name, model in models.iteritems():
model.fit(data.data[train, :], data.target[train])
prediction = model.predict(data.data[test, :], significance=significance)
table = np.hstack((prediction, truth))
df = pd.DataFrame(table, columns=columns)
print('\n{}'.format(name))
print('Error rate: {}'.format(
class_mean_errors(prediction, truth, significance)))
print(df)
def test_acp_classification_tree(self):
# -----------------------------------------------------------------------------
# Experiment setup
# -----------------------------------------------------------------------------
data = load_iris()
idx = np.random.permutation(data.target.size)
train = idx[:int(2 * idx.size / 3)]
test = idx[int(2 * idx.size / 3):]
truth = data.target[test].reshape(-1, 1)
columns = ["C-{}".format(i)
for i in np.unique(data.target)] + ["truth"]
significance = 0.1
# -----------------------------------------------------------------------------
# Define models
# -----------------------------------------------------------------------------
models = {
"ACP-RandomSubSampler":
AggregatedCp(
IcpClassifier(
ClassifierNc(ClassifierAdapter(DecisionTreeClassifier()))),
RandomSubSampler(),
),
"ACP-CrossSampler":
AggregatedCp(
IcpClassifier(
ClassifierNc(ClassifierAdapter(DecisionTreeClassifier()))),
CrossSampler(),
),
"ACP-BootstrapSampler":
AggregatedCp(
IcpClassifier(
ClassifierNc(ClassifierAdapter(DecisionTreeClassifier()))),
BootstrapSampler(),
),
"CCP":
CrossConformalClassifier(
IcpClassifier(
ClassifierNc(ClassifierAdapter(
DecisionTreeClassifier())))),
"BCP":
BootstrapConformalClassifier(
IcpClassifier(
ClassifierNc(ClassifierAdapter(
DecisionTreeClassifier())))),
}
# -----------------------------------------------------------------------------
# Train, predict and evaluate
# -----------------------------------------------------------------------------
for name, model in models.items():
model.fit(data.data[train, :], data.target[train])
prediction = model.predict(data.data[test, :],
significance=significance)
table = np.hstack((prediction, truth))
df = pd.DataFrame(table, columns=columns)
print("\n{}".format(name))
print("Error rate: {}".format(
class_mean_errors(prediction, truth, significance)))
print(df)
self.assertTrue(True)
AggregatedCp(
IcpClassifier(ClassifierNc(ClassifierAdapter(classification_method))),
RandomSubSampler()),
'ACP-CrossSampler':
AggregatedCp(
IcpClassifier(ClassifierNc(ClassifierAdapter(classification_method))),
CrossSampler()),
'ACP-BootstrapSampler':
AggregatedCp(
IcpClassifier(ClassifierNc(ClassifierAdapter(classification_method))),
BootstrapSampler()),
'CCP':
CrossConformalClassifier(
IcpClassifier(ClassifierNc(ClassifierAdapter(classification_method)))),
'BCP':
BootstrapConformalClassifier(
IcpClassifier(ClassifierNc(ClassifierAdapter(classification_method))))
}
# ------------------------------------------------------------------------------------------------------------------
# Train_test_split method:
# ------------------------------------------------------------------------------------------------------------------
#
# X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
#
# truth = y_test.reshape(-1, 1)
# columns = ['C-{}'.format(i) for i in np.unique(y)] + ['truth']
# significance = 0.45
# classification_method = DecisionTreeClassifier()
#
#
# for name, model in models.items():
models = {
'ACP-RandomSubSampler':
AggregatedCp(IcpClassifier(ClassifierNc(ClassifierAdapter(simple_model))),
RandomSubSampler()),
'ACP-CrossSampler':
AggregatedCp(IcpClassifier(ClassifierNc(ClassifierAdapter(simple_model))),
CrossSampler()),
'ACP-BootstrapSampler':
AggregatedCp(IcpClassifier(ClassifierNc(ClassifierAdapter(simple_model))),
BootstrapSampler()),
'CCP':
CrossConformalClassifier(
IcpClassifier(ClassifierNc(ClassifierAdapter(simple_model)))),
'BCP':
BootstrapConformalClassifier(
IcpClassifier(ClassifierNc(ClassifierAdapter(simple_model)))),
}
error_summary = []
# -------------------------------------------------------------------------------
# sig_error_lda
# ----------------------------------------------------------------------------
# s_folder = StratifiedKFold(n_splits=10, shuffle=True, random_state=1)
# for framework_name, model in models.items():
# print(framework_name + ' is starting:')
# for num, (train, test) in enumerate(s_folder.split(X, y)):
# x_train, x_test = X[train], X[test]
# y_train, y_test = y[train], y[test]
# truth = y_test.reshape((-1, 1))
#
# lda = LinearDiscriminantAnalysis(n_components=9)