def run_exp_racos_for_synthetic_problem_analysis():
# parameters
sample_size = 10 # the instance number of sampling in an iteration
budget = 500 # budget in online style
positive_num = 2 # the set size of PosPop
rand_probability = 0.99 # the probability of sample in model
uncertain_bit = 1 # the dimension size that is sampled randomly
adv_threshold = 10 # advance sample size
opt_repeat = 10
dimension_size = 10
problem_name = 'sphere'
problem_num = 200
start_index = 0
bias_region = 0.2
dimension = Dimension()
dimension.set_dimension_size(dimension_size)
dimension.set_regions([[-1.0, 1.0] for _ in range(dimension_size)],
[0 for _ in range(dimension_size)])
log_buffer = []
# logging
learner_path = './ExpLearner/SyntheticProbsLearner/' + problem_name + '/dimension' + str(dimension_size)\
+ '/DirectionalModel/' + 'learner-' + problem_name + '-' + 'dim' + str(dimension_size) + '-'\
+ 'bias' + str(bias_region) + '-'
problem_path = './ExpLog/SyntheticProbsLog/' + problem_name + '/dimension' + str(dimension_size)\
+ '/DirectionalModel/' + 'bias-' + problem_name + '-' + 'dim' + str(dimension_size) + '-'\
+ 'bias' + str(bias_region) + '-'
func = DistributedFunction(dimension, bias_region=[-0.5, 0.5])
target_bias = [0.1 for _ in range(dimension_size)]
func.setBias(target_bias)
if problem_name == 'ackley':
prob_fct = func.DisAckley
else:
prob_fct = func.DisSphere
relate_error_list = []
for prob_i in range(problem_num):
print(
start_index + prob_i,
'++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
log_buffer.append(
str(start_index + prob_i) +
'++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
log_buffer.append('+++++++++++++++++++++++++++++++')
log_buffer.append('optimization parameters')
log_buffer.append('sample size: ' + str(sample_size))
log_buffer.append('budget: ' + str(budget))
log_buffer.append('positive num: ' + str(positive_num))
log_buffer.append('random probability: ' + str(rand_probability))
log_buffer.append('uncertain bits: ' + str(uncertain_bit))
log_buffer.append('advance num: ' + str(adv_threshold))
log_buffer.append('+++++++++++++++++++++++++++++++')
log_buffer.append('problem parameters')
log_buffer.append('dimension size: ' + str(dimension_size))
log_buffer.append('problem name: ' + problem_name)
log_buffer.append('bias_region: ' + str(bias_region))
log_buffer.append('+++++++++++++++++++++++++++++++')
problem_file = problem_path + str(start_index + prob_i) + '.txt'
problem_str = fo.FileReader(problem_file)[0].split(',')
problem_index = int(problem_str[0])
problem_bias = string2list(problem_str[1])
if problem_index != (start_index + prob_i):
print('problem error!')
exit(0)
print('source bias: ', problem_bias)
log_buffer.append('source bias: ' + list2string(problem_bias))
reduisal = np.array(target_bias) - np.array(problem_bias)
this_distance = reduisal * reduisal.T
learner_file = learner_path + str(start_index + prob_i) + '.pkl'
log_buffer.append('learner file: ' + learner_file)
print('learner file: ', learner_file)
net = torch.load(learner_file)
net_list = [net]
opt_error_list = []
for i in range(opt_repeat):
print('optimize ', i,
'===================================================')
log_buffer.append(
'optimize ' + str(i) +
'===================================================')
exp_racos = ExpRacosOptimization(dimension, net_list)
start_t = time.time()
exp_racos.exp_mix_opt(obj_fct=prob_fct,
ss=sample_size,
bud=budget,
pn=positive_num,
rp=rand_probability,
ub=uncertain_bit,
at=adv_threshold)
end_t = time.time()
print('total budget is ', budget)
log_buffer.append('total budget is ' + str(budget))
hour, minute, second = time_formulate(start_t, end_t)
print('spending time: ', hour, ':', minute, ':', second)
log_buffer.append('spending time: ' + str(hour) + '+' +
str(minute) + '+' + str(second))
optimal = exp_racos.get_optimal()
opt_error = optimal.get_fitness()
optimal_x = optimal.get_features()
opt_error_list.append(opt_error)
print('validation optimal value: ', opt_error)
log_buffer.append('validation optimal value: ' + str(opt_error))
print('optimal x: ', optimal_x)
log_buffer.append('optimal nn structure: ' +
list2string(optimal_x))
opt_mean = np.mean(np.array(opt_error_list))
relate_error_list.append([this_distance, opt_mean])
opt_std = np.std(np.array(opt_error_list))
print('--------------------------------------------------')
print('optimization result: ', opt_mean, '#', opt_std)
log_buffer.append('--------------------------------------------------')
log_buffer.append('optimization result: ' + str(opt_mean) + '#' +
str(opt_std))
result_path = './Results/SyntheticProbs/' + problem_name + '/dimension' + str(
dimension_size) + '/'
relate_error_file = result_path + 'relate-error-' + problem_name + '-dim' + str(dimension_size) + '-bias'\
+ str(bias_region) + '.txt'
temp_buffer = []
for i in range(len(relate_error_list)):
relate, error = relate_error_list[i]
temp_buffer.append(str(relate) + ',' + str(error))
print('relate error logging: ', relate_error_file)
log_buffer.append('relate error logging: ' + relate_error_file)
fo.FileWriter(relate_error_file, temp_buffer, style='w')
optimization_log_file = result_path + 'opt-log-' + problem_name + '-dim' + str(dimension_size) + '-bias'\
+ str(bias_region) + '.txt'
print('optimization logging: ', optimization_log_file)
fo.FileWriter(optimization_log_file, log_buffer, style='w')
def learning_data_construct():
total_path = path + '/ExpLog/SyntheticProbsLog/'
problem_name = 'ackley'
dimension_size = 10
bias_region = 0.5
start_index = 1000
is_balance = True
problem_num = 1000
for prob_i in range(problem_num):
print(problem_name, ' ', prob_i,
' ========================================')
source_data_file = total_path + problem_name + '/dimension' + str(dimension_size) + '/DataLog/' + 'data-'\
+ problem_name + '-' + 'dim' + str(dimension_size) + '-' + 'bias' + str(bias_region)\
+ '-' + str(start_index + prob_i) + '.pkl'
print('source data reading: ', source_data_file)
pos_set, neg_set, new_set, label_set = read_log(source_data_file)
print('constructing learning data')
instance_set = learning_instance_construct(pos_set=pos_set,
neg_set=neg_set,
new_set=new_set)
print('original data size: ', len(instance_set), ' - ', len(label_set))
original_data = [instance_set, label_set]
if is_balance is True:
print('balancing data...')
balance_instance_set, balance_label_set = learning_instance_balance(
tensors=copy.deepcopy(instance_set),
labels=copy.deepcopy(label_set))
print('balanced data size: ', len(balance_instance_set), ' - ',
len(balance_label_set))
balance_data = [balance_instance_set, balance_label_set]
else:
print('skipping balance data')
balance_data = None
problem_log_file = total_path + str(problem_name) + '/dimension' + str(dimension_size) + '/RecordLog/'\
+ 'bias-' + problem_name + '-' + 'dim' + str(dimension_size) + '-' + 'bias'\
+ str(bias_region) + '-' + str(start_index + prob_i) + '.txt'
strings = fo.FileReader(problem_log_file)
this_string = strings[0].split(',')
problem_index = int(this_string[0])
problem_bias = string2list(this_string[1])
if problem_index != start_index + prob_i:
print('problem index error!')
exit(0)
# learning data log
# data format:
# obj1: problem_name,problem_index: string
# obj2: bias: list
# obj3: original data: (instance, label)
# obj4: balanced data: (instance, label) or None
learning_data_file = total_path + str(problem_name) + '/dimension' + str(dimension_size) + '/LearningData/'\
+ 'learning-data-' + problem_name + '-' + 'dim' + str(dimension_size) + '-' + 'bias'\
+ str(bias_region) + '-' + str(start_index + prob_i) + '.pkl'
print('learning data logging...')
f = open(learning_data_file, 'wb')
pickle.dump(problem_name + ',' + str(start_index + prob_i),
f,
protocol=pickle.HIGHEST_PROTOCOL)
pickle.dump(problem_bias, f, protocol=pickle.HIGHEST_PROTOCOL)
pickle.dump(original_data, f, protocol=pickle.HIGHEST_PROTOCOL)
pickle.dump(balance_data, f, protocol=pickle.HIGHEST_PROTOCOL)
f.close()
return