if __name__ == "__main__":
config = tf.ConfigProto()
config.gpu_options.allow_growth = True # dynamically grow the memory used on the GPU
sess = tf.Session(config=config)
set_session(sess)
single_class_ind = 1
(x_train, y_train), (x_val, y_val), (x_test, y_test) = load_hits(n_samples_by_class=16000,
test_size=0.25,
val_size=0.125, return_val=True)
print(x_train.shape)
print(x_val.shape)
print(x_test.shape)
transformer = TransTransformer(8, 8)
# n, k = (10, 4)
#
# mdl = create_wide_residual_network(input_shape=x_train.shape[1:],
# num_classes=transformer.n_transforms,
# depth=n, widen_factor=k)
mdl = create_simple_network(input_shape=x_train.shape[1:],
num_classes=2, dropout_rate=0.5)
mdl.compile(optimizer='adam', loss='categorical_crossentropy',
metrics=['acc'])
print(mdl.summary())
sess = tf.Session(config=config)
set_session(sess)
single_class_ind = 1
(x_train, y_train), (x_val,
y_val), (x_test,
y_test) = load_hits(n_samples_by_class=16000,
test_size=0.25,
val_size=0.125,
return_val=True)
print(x_train.shape)
print(x_val.shape)
print(x_test.shape)
transformer = TransTransformer(8, 8)
# get inliers of specific class
x_train_task = x_train[y_train.flatten() == single_class_ind]
print(x_train_task.shape)
x_val_task = x_val[y_val.flatten() == single_class_ind]
print(x_val_task.shape)
# [0_i, ..., (N_transforms-1)_i, ..., ..., 0_N_samples, ...,
# (N_transforms-1)_N_samples] shape: (N_transforms*N_samples,)
transformations_inds_train = np.tile(np.arange(transformer.n_transforms),
len(x_train_task))
transformations_inds_val = np.tile(np.arange(transformer.n_transforms),
len(x_val_task))
print(len(transformations_inds_train))
print(len(transformations_inds_val))
sess = tf.Session(config=config)
set_session(sess)
single_class_ind = 1
(x_train, y_train), (x_val,
y_val), (x_test,
y_test) = load_hits(n_samples_by_class=10000,
test_size=0.20,
val_size=0.10,
return_val=True)
print(x_train.shape)
print(x_val.shape)
print(x_test.shape)
transformer = TransTransformer(8, 8)
n, k = (10, 4)
mdl = create_wide_residual_network(input_shape=x_train.shape[1:],
num_classes=transformer.n_transforms,
depth=n,
widen_factor=k)
mdl.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['acc'])
print(mdl.summary())
# get inliers of specific class
x_train_task = x_train[y_train.flatten() == single_class_ind]
print(x_train_task.shape)
def _trans_transformations_experiment(dataset_load_fn, dataset_name,
single_class_ind, gpu_q):
# gpu_to_use = gpu_q.get()
# os.environ["CUDA_VISIBLE_DEVICES"] = gpu_to_use
(x_train, y_train), (x_test, y_test) = dataset_load_fn()
if dataset_name in ['cats-vs-dogs']:
transformer = TransTransformer(16, 16)
n, k = (16, 8)
else:
transformer = TransTransformer(8, 8)
n, k = (10, 4)
mdl = create_wide_residual_network(x_train.shape[1:],
transformer.n_transforms, n, k)
mdl.compile('adam', 'categorical_crossentropy', ['acc'])
# get inliers of specific class
x_train_task = x_train[y_train.flatten() == single_class_ind]
# [0_i, ..., (N_transforms-1)_i, ..., ..., 0_N_samples, ...,
# (N_transforms-1)_N_samples] shape: (N_transforms*N_samples,)
transformations_inds = np.tile(np.arange(transformer.n_transforms),
len(x_train_task))
x_train_task_transformed = transformer.transform_batch(
np.repeat(x_train_task, transformer.n_transforms, axis=0),
transformations_inds)
batch_size = 128
mdl.fit(x=x_train_task_transformed,
y=to_categorical(transformations_inds),
batch_size=batch_size,
epochs=int(np.ceil(200 / transformer.n_transforms)))
scores = np.zeros((len(x_test), ))
matrix_evals = np.zeros(
(len(x_test), transformer.n_transforms, transformer.n_transforms))
observed_data = x_train_task
for t_ind in range(transformer.n_transforms):
observed_dirichlet = mdl.predict(transformer.transform_batch(
observed_data, [t_ind] * len(observed_data)),
batch_size=1024)
log_p_hat_train = np.log(observed_dirichlet).mean(axis=0)
alpha_sum_approx = calc_approx_alpha_sum(observed_dirichlet)
alpha_0 = observed_dirichlet.mean(axis=0) * alpha_sum_approx
mle_alpha_t = fixed_point_dirichlet_mle(alpha_0, log_p_hat_train)
x_test_p = mdl.predict(transformer.transform_batch(
x_test, [t_ind] * len(x_test)),
batch_size=1024)
matrix_evals[:, :, t_ind] += x_test_p
scores += dirichlet_normality_score(mle_alpha_t, x_test_p)
scores /= transformer.n_transforms
matrix_evals /= transformer.n_transforms
scores_simple = np.trace(matrix_evals, axis1=1, axis2=2)
scores_entropy = get_entropy(matrix_evals)
scores_xH = get_xH(transformer, matrix_evals)
labels = y_test.flatten() == single_class_ind
save_results_file(dataset_name,
single_class_ind,
scores=scores,
labels=labels,
experiment_name='trans-transformations')
save_results_file(dataset_name,
single_class_ind,
scores=scores_simple,
labels=labels,
experiment_name='trans-transformations-simple')
save_results_file(dataset_name,
single_class_ind,
scores=scores_entropy,
labels=labels,
experiment_name='trans-transformations-entropy')
save_results_file(dataset_name,
single_class_ind,
scores=scores_xH,
labels=labels,
experiment_name='trans-transformations-xH')
mdl_weights_name = '{}_trans-transformations_{}_{}_weights.h5'.format(
dataset_name, get_class_name_from_index(single_class_ind,
dataset_name),
datetime.datetime.now().strftime('%Y-%m-%d-%H%M'))
mdl_weights_path = os.path.join(RESULTS_DIR, dataset_name,
mdl_weights_name)
mdl.save_weights(mdl_weights_path)