def test_normalization(self):
norm_X_train, norm_X_test = standardizer(self.X_train, self.X_train)
assert_allclose(norm_X_train.mean(), 0, atol=0.05)
assert_allclose(norm_X_train.std(), 1, atol=0.05)
assert_allclose(norm_X_test.mean(), 0, atol=0.05)
assert_allclose(norm_X_test.std(), 1, atol=0.05)
# test when X_t is not presented
norm_X_train = standardizer(self.X_train)
assert_allclose(norm_X_train.mean(), 0, atol=0.05)
assert_allclose(norm_X_train.std(), 1, atol=0.05)
def test_normalization(self):
# test when X_t is presented and no scalar
norm_X_train, norm_X_test = standardizer(self.X_train, self.X_test)
assert_allclose(norm_X_train.mean(), 0, atol=0.05)
assert_allclose(norm_X_train.std(), 1, atol=0.05)
assert_allclose(norm_X_test.mean(), 0, atol=0.05)
assert_allclose(norm_X_test.std(), 1, atol=0.05)
# test when X_t is not presented and no scalar
norm_X_train = standardizer(self.X_train)
assert_allclose(norm_X_train.mean(), 0, atol=0.05)
assert_allclose(norm_X_train.std(), 1, atol=0.05)
# test when X_t is presented and the scalar is kept
norm_X_train, norm_X_test, scalar = standardizer(self.X_train,
self.X_test,
keep_scalar=True)
assert_allclose(norm_X_train.mean(), 0, atol=0.05)
assert_allclose(norm_X_train.std(), 1, atol=0.05)
assert_allclose(norm_X_test.mean(), 0, atol=0.05)
assert_allclose(norm_X_test.std(), 1, atol=0.05)
if not hasattr(scalar, 'fit') or not hasattr(scalar, 'transform'):
raise AttributeError("%s is not a detector instance." % (scalar))
# test when X_t is not presented and the scalar is kept
norm_X_train, scalar = standardizer(self.X_train, keep_scalar=True)
assert_allclose(norm_X_train.mean(), 0, atol=0.05)
assert_allclose(norm_X_train.std(), 1, atol=0.05)
if not hasattr(scalar, 'fit') or not hasattr(scalar, 'transform'):
raise AttributeError("%s is not a detector instance." % (scalar))
# test shape difference
with assert_raises(ValueError):
standardizer(self.X_train, self.X_test_diff)
def test_normalization(self):
# test when X_t is presented and no scalar
norm_X_train, norm_X_test = standardizer(self.X_train, self.X_test)
assert_allclose(norm_X_train.mean(), 0, atol=0.05)
assert_allclose(norm_X_train.std(), 1, atol=0.05)
assert_allclose(norm_X_test.mean(), 0, atol=0.05)
assert_allclose(norm_X_test.std(), 1, atol=0.05)
# test when X_t is not presented and no scalar
norm_X_train = standardizer(self.X_train)
assert_allclose(norm_X_train.mean(), 0, atol=0.05)
assert_allclose(norm_X_train.std(), 1, atol=0.05)
# test when X_t is presented and the scalar is kept
norm_X_train, norm_X_test, scalar = standardizer(self.X_train,
self.X_test,
keep_scalar=True)
assert_allclose(norm_X_train.mean(), 0, atol=0.05)
assert_allclose(norm_X_train.std(), 1, atol=0.05)
assert_allclose(norm_X_test.mean(), 0, atol=0.05)
assert_allclose(norm_X_test.std(), 1, atol=0.05)
if not hasattr(scalar, 'fit') or not hasattr(scalar, 'transform'):
raise AttributeError("%s is not a detector instance." % (scalar))
# test when X_t is not presented and the scalar is kept
norm_X_train, scalar = standardizer(self.X_train, keep_scalar=True)
assert_allclose(norm_X_train.mean(), 0, atol=0.05)
assert_allclose(norm_X_train.std(), 1, atol=0.05)
if not hasattr(scalar, 'fit') or not hasattr(scalar, 'transform'):
raise AttributeError("%s is not a detector instance." % (scalar))
# test shape difference
with assert_raises(ValueError):
standardizer(self.X_train, self.X_test_diff)
for t in range(n_ite):
print('\nn_ite', t + 1, data) # print status
random_state = np.random.RandomState(t)
# split the data into training and testing
X_train, X_test, y_train, y_test = train_test_split(
X_orig, y_orig, test_size=test_size, random_state=random_state)
# in case of small datasets
if k_max > X_train.shape[0]:
k_max = X_train.shape[0]
k_list = random_state.randint(k_min, k_max, size=n_clf).tolist()
# normalized the data
X_train_norm, X_test_norm = standardizer(X_train, X_test)
train_scores = np.zeros([X_train.shape[0], n_clf])
test_scores = np.zeros([X_test.shape[0], n_clf])
# initialized the list to store the results
test_target_list = []
method_list = []
# generate a pool of detectors and predict on test instances
train_scores, test_scores = train_predict_lof(k_list, X_train_norm,
X_test_norm,
train_scores,
test_scores)
#######################################################################
def train_and_predict(data_name):
# reference pearson size:
# https://www.researchgate.net/post/What_is_the_minimum_sample_size_to_run_Pearsons_R
loc_region_size = 0
loc_region_min = 30 # min local region size
loc_region_max = 100 # max local region size
###############################################################################
# adjustable parameters
loc_region_perc = 0.1
loc_region_ite = 20 # the number of iterations in defining local region
loc_region_threshold = int(loc_region_ite /
2) # the threshold to keep a point
loc_min_features = 0.5 # the lower bound of the number of features to use
n_bins = 10
n_selected = 1 # actually not a parameter to tweak
n_clf = 50
k_min = 5
k_max = 200
# for SG_AOM and SG_MOA, choose the right number of buckets
n_buckets = 5
n_clf_bucket = int(n_clf / n_buckets)
assert (n_clf % n_buckets == 0) # in case wrong number of buckets
# flag for printing and output saving
verbose = True
# record of feature bagging detector
fb_n_neighbors = []
###############################################################################
start_time = time.time()
#data_name = 'pageblocks'
xy_data = pd.read_csv(data_name)
X_orig, y_orig = xy_data.iloc[:, :-1], xy_data.iloc[:, -1]
# initialize the matrix for storing scores
roc_mat = np.zeros([n_ite, n_baselines]) # receiver operating curve
ap_mat = np.zeros([n_ite, n_baselines]) # average precision
for t in range(n_ite):
print('\nn_ite', t + 1, data_name) # print status
random_state = np.random.RandomState()
# split the data into training and testing
X_train, X_test, y_train, y_test = train_test_split(
X_orig, y_orig, test_size=test_size, random_state=random_state)
# in case of small datasets
if k_max > X_train.shape[0]:
k_max = X_train.shape[0]
k_list = random_state.randint(k_min, k_max, size=n_clf).tolist()
k_list.sort()
# normalized the data
X_train_norm, X_test_norm = standardizer(X_train, X_test)
train_scores = np.zeros([X_train.shape[0], n_clf])
test_scores = np.zeros([X_test.shape[0], n_clf])
# initialized the list to store the results
test_target_list = []
method_list = []
# generate a pool of detectors and predict on test instances
train_scores, test_scores = train_predict_lof(k_list, X_train_norm,
X_test_norm,
train_scores,
test_scores)
#######################################################################
# fit feature bagging using median of k_list
# n_neighbors = int(np.median(k_list))
n_neighbors = random_state.randint(low=k_min, high=k_max)
clf = FeatureBagging(base_estimator=LOF(n_neighbors=n_neighbors),
n_estimators=len(k_list),
check_estimator=False)
print(clf)
fb_n_neighbors.append(n_neighbors)
clf.fit(X_train_norm)
#######################################################################
# generate normalized scores
train_scores_norm, test_scores_norm = standardizer(
train_scores, test_scores)
# generate mean and max outputs
# SG_A and SG_M
target_test_mean = np.mean(test_scores_norm, axis=1)
target_test_max = np.max(test_scores_norm, axis=1)
test_target_list.extend([target_test_mean, target_test_max])
method_list.extend(['GG_a', 'GG_m'])
# calculate every detector information entropy
info_ent_arry = calc_avg_nmi(train_scores)
# generate information entropy weighted mean
# 使用信息熵加权计算
target_test_entropy_weighted_pear = np.mean(
test_scores_norm * info_ent_arry.reshape(1, -1), axis=1)
test_target_list.append(target_test_entropy_weighted_pear)
method_list.append('GG_a_ent')
# generate weighted mean
target_test_weighted_pear_max_ent = np.max(
test_scores_norm * info_ent_arry.reshape(1, -1), axis=1)
test_target_list.append(target_test_weighted_pear_max_ent)
method_list.append('GG_m_ent')
# generate pseudo target for training -> for calculating weights
target_mean = np.mean(train_scores_norm, axis=1).reshape(-1, 1)
target_max = np.max(train_scores_norm, axis=1).reshape(-1, 1)
# 使用信息熵加权后的pseudo
target_ent_mean = np.mean(train_scores_norm *
info_ent_arry.reshape(1, -1),
axis=1).reshape(-1, 1)
target_ent_max = np.max(train_scores_norm *
info_ent_arry.reshape(1, -1),
axis=1).reshape(-1, 1)
# generate average of maximum (SG_AOM) and maximum of average (SG_MOA)
target_test_aom = aom(test_scores_norm, n_buckets, n_clf)
target_test_aom_ent = aom(
test_scores_norm * info_ent_arry.reshape(1, -1), n_buckets, n_clf)
test_target_list.extend([target_test_aom, target_test_aom_ent])
method_list.extend(['GG_aom', 'GG_aom_ent'])
##################################################################
# define the local region size
loc_region_size = int(X_train_norm.shape[0] * loc_region_perc)
if loc_region_size < loc_region_min:
loc_region_size = loc_region_min
if loc_region_size > loc_region_max:
loc_region_size = loc_region_max
# define local region
ind_arr = get_local_region(X_train_norm,
X_test_norm,
loc_region_size,
loc_region_ite=loc_region_ite,
local_region_strength=loc_region_threshold,
loc_min_features=loc_min_features,
random_state=random_state)
pred_scores_best = np.zeros([
X_test.shape[0],
])
pred_scores_ens = np.zeros([
X_test.shape[0],
])
pred_scores_best_ent = np.zeros([
X_test.shape[0],
])
pred_scores_ens_ent = np.zeros([
X_test.shape[0],
])
for i in range(X_test.shape[0]): # iterate all test instance
ind_k = ind_arr[i]
# get the pseudo target: mean
target_k = target_mean[ind_k, ].ravel()
target_ent_k = target_ent_mean[ind_k, ].ravel()
# get the current scores from all clf
curr_train_k = train_scores_norm[ind_k, :]
# initialize containers for correlation
corr_pear_n = np.zeros([
n_clf,
])
corr_pear_n_ent = np.zeros([
n_clf,
])
for d in range(n_clf):
corr_pear_n[d, ] = pearsonr(target_k, curr_train_k[:, d])
corr_pear_n_ent[d, ] = pearsonr(
target_ent_k, curr_train_k[:, d]) #*info_ent_arry[d]
#corr_pear_n_ent[d,] = calc_nmi(target_k,curr_train_k[:,d])
# pick the best one
best_clf_ind = np.nanargmax(corr_pear_n)
pred_scores_best[i, ] = test_scores_norm[i, best_clf_ind]
best_clf_ind_ent = np.nanargmax(corr_pear_n_ent)
pred_scores_best_ent[i, ] = test_scores_norm[i, best_clf_ind_ent]
test_target_list.extend([pred_scores_best, pred_scores_best_ent])
method_list.extend(['LSCP_a', 'LSCP_a_ent'])
######################################################################
pred_scores_best = np.zeros([
X_test.shape[0],
])
pred_scores_ens = np.zeros([
X_test.shape[0],
])
pred_scores_best_ent = np.zeros([
X_test.shape[0],
])
pred_scores_ens_ent = np.zeros([
X_test.shape[0],
])
for i in range(X_test.shape[0]): # iterate all test instance
# get the neighbor idx of the current point
ind_k = ind_arr[i]
# get the pseudo target: mean
target_k = target_max[ind_k, ].ravel()
target_k_ent = target_ent_max[ind_k, ].ravel()
# get the current scores from all clf
curr_train_k = train_scores_norm[ind_k, :]
# initialize containers for correlation
corr_pear_n = np.zeros([
n_clf,
])
corr_pear_n_ent = np.zeros([
n_clf,
])
for d in range(n_clf):
corr_pear_n[d, ] = pearsonr(target_k, curr_train_k[:, d])
corr_pear_n_ent[d, ] = pearsonr(
target_k_ent, curr_train_k[:, d]) #*info_ent_arry[d]
#corr_pear_n_ent[d,] = calc_nmi(target_k,curr_train_k[:,d])
# pick the best one
best_clf_ind = np.nanargmax(corr_pear_n)
pred_scores_best[i, ] = test_scores_norm[i, best_clf_ind]
pred_scores_ens[i, ] = np.mean(test_scores_norm[
i, get_competent_detectors(corr_pear_n, n_bins, n_selected)])
# 使用信息熵加权后的pseudo
best_clf_ind_ent = np.nanargmax(corr_pear_n_ent)
pred_scores_best_ent[i, ] = test_scores_norm[i, best_clf_ind_ent]
pred_scores_ens_ent[i, ] = np.mean(test_scores_norm[
i,
get_competent_detectors(corr_pear_n_ent, n_bins, n_selected)])
test_target_list.extend([
pred_scores_best, pred_scores_best_ent, pred_scores_ens,
pred_scores_ens_ent
])
method_list.extend(
['LSCP_m', 'LSCP_m_ent', 'LSCP_aom', 'LSCP_aom_ent'])
######################################################################
# store performance information and print result
for i in range(n_baselines):
roc_mat[t, i] = roc_auc_score(y_test, test_target_list[i])
ap_mat[t, i] = average_precision_score(y_test, test_target_list[i])
print(method_list[i], roc_mat[t, i])
print('local region size:', loc_region_size)
print("--- %s seconds ---" % (time.time() - start_time))
execution_time = time.time() - start_time
# save parameters
save_script(data_name,
base_detector,
timestamp,
n_ite,
test_size,
n_baselines,
loc_region_perc,
loc_region_ite,
loc_region_threshold,
loc_min_features,
loc_region_size,
loc_region_min,
loc_region_max,
n_clf,
k_min,
k_max,
n_bins,
n_selected,
n_buckets,
fb_n_neighbors,
execution_time,
res_path='results_avg_nmi')
# print and save the result
# default location is /results/***.csv
print_save_result(data_name,
base_detector,
n_baselines,
roc_mat,
ap_mat,
method_list,
timestamp,
verbose,
res_path='results_avg_nmi')