def add_XP_to_pool_folder(oil_ratios, pool_folder, n_digit=FOLDERNAME_N_DIGIT):
# save incremetaly in pool_folder
# ensure pool_folder exist and create incremetal foldername
filetools.ensure_dir(pool_folder)
xp_folder = filetools.generate_incremental_foldername(pool_folder,
n_digit=n_digit)
save_XP_to_folder(oil_ratios, xp_folder)
def get_xp_path(self):
"""
Gets the current experiment folder
"""
path = os.path.join(DATA, self.info[keys.TITLE],
str(self.info[keys.SEED]))
filetools.ensure_dir(path)
return path
def generate_xp_folder(self):
"""
Creates a root folder for the experiment
"""
path = os.path.join(DATA, self.info[keys.TITLE],
str(self.info[keys.SEED]))
filetools.ensure_dir(path)
return path
def generate_xp_path(self) -> str:
"""Generates a path to the experiment folder
Creates the flder if it doesn't exist already
Returns:
str -- Experiment path
"""
path = os.path.join(DATA, "single_experiments", self.info[keys.TITLE])
filetools.ensure_dir(path)
return path
def generate_incremental_foldername(folderpath='.', n_digit=4, create_dir=True):
folderpath = os.path.abspath(folderpath)
if create_dir:
ensure_dir(folderpath)
found_folders = list_folders(folderpath)
current_max = -1
for f in found_folders:
basename = File(f, folderpath).filebasename
if basename.isdigit():
count = int(basename)
if count > current_max:
current_max = count
fname = generate_n_digit_name(current_max + 1, n_digit)
return os.path.join(folderpath, fname)
def create_generation(self):
"""Creates the experiment folder and populates all folders with params.
Params are defined in the Info file
"""
gen_number = filetools.generate_n_digit_name(0)
gen_folder = os.path.join(self.xp_path, gen_number)
filetools.ensure_dir(gen_folder)
print(f"Creating generation: {os.path.relpath(gen_folder)}")
for xp_num in range(self.info[keys.XP]):
xp_folder_name = filetools.generate_n_digit_name(xp_num)
xp_folder = os.path.join(gen_folder, xp_folder_name)
filetools.ensure_dir(xp_folder)
params_file = os.path.join(xp_folder, fn.PARAMS_FILE)
json.write(self.params, params_file)
def create_base_folder(root_path):
"""
Creates the base folder for the entire experiment, including subdirectories
Args:
root_path (str): The base path to create the folder within
Returns:
path (str): The path to the newly created folder
"""
current_date = time.strftime('%x').replace('/', '_')
path = os.path.join(root_path, current_date)
filetools.ensure_dir(path)
filetools.ensure_dir(os.path.join(path, 'images'))
return os.path.join(path, 'images')
def create_single_experiment(self, gen_folder: str):
"""Creates a single experiment file
Args:
gen_folder (str): Generation folder
"""
single_xp = {
"silver": 2.0475021741687085,
"surfactant": 4.070063550325937,
"gold": 2.762982287687803,
"reductant": 1.0594519878175512,
"seeds": 0.06
}
xp_folder_name = "ideal_synthesis"
xp_folder = os.path.join(gen_folder, xp_folder_name)
filetools.ensure_dir(xp_folder)
params = os.path.join(xp_folder, fn.PARAMS_FILE)
json.write(single_xp, params)
def create_generation(self, n_gen):
"""
Creates a generation folder, populated with experiments
Algorithm generates parameters for each experiment
Random parameters at first then algorithmically chosen onces thereafter
Args:
n_gen (int): Current generation number
"""
# Creates a population of experiments for the generation
population = self.create_population()
# Creates the folder for the generation
gen_number = filetools.generate_n_digit_name(n_gen)
gen_folder = os.path.join(self.xp_path, gen_number)
filetools.ensure_dir(gen_folder)
print("Creating generation: {}".format(os.path.relpath(gen_folder)))
# Iterates through the population, creating a folder and params file for each xp
for pos, _ in enumerate(population):
# Creates the xp folder
xp_folder_name = filetools.generate_n_digit_name(pos)
xp_folder = os.path.join(gen_folder, xp_folder_name)
filetools.ensure_dir(xp_folder)
# Converts the population for this XP into a dictionary
params = self.convert_pop_to_dict(population[pos])
params_file = os.path.join(xp_folder, fn.PARAMS_FILE)
xp_log = os.path.join(xp_folder, fn.XP_LOG)
# Checks if a parameter file exists and checks the values for this seed number match
if os.path.exists(xp_log):
params = json.read(xp_log)["raw_params"]
json.write(params, params_file)
else:
json.write(params, params_file)
self.watch_for_fitness(gen_folder)
AVG_RESULTS['RANDOM'],
'b',
linestyle='-',
linewidth=linewidth,
marker='D',
markersize=markersize)
plt.title('Evolution of Crystallization Model Quality',
fontsize=fontsize)
plt.legend(['Algorithm', 'Human', 'Random'], fontsize=fontsize, loc=2)
plt.xlim([-1, 101])
if method_name == 'Adaboost':
plt.ylim([60, 85])
y_tick_pos = [60, 65, 70, 75, 80, 85]
else:
plt.ylim([65, 85])
y_tick_pos = [65, 70, 75, 80, 85]
plt.yticks(y_tick_pos, ['{}%'.format(i) for i in y_tick_pos])
plt.xlabel('Number of Experiments', fontsize=fontsize)
plt.ylabel('Prediction Accuracy - %', fontsize=fontsize)
#
PLOT_FOLDER = os.path.join(HERE_PATH, 'plot')
filetools.ensure_dir(PLOT_FOLDER)
plot_filename = os.path.join(
PLOT_FOLDER, 'learning_curve_unbiased_{}'.format(method_name))
save_and_close_figure(fig, plot_filename)
if __name__ == '__main__':
import sys
import filetools
if len(sys.argv) != 2:
print 'Please specify a root folder as argument'
# seed
seed = int(sys.argv[1])
random.seed(seed)
np.random.seed(seed)
#
root_folder = os.path.join(HERE_PATH, sys.argv[1])
filetools.ensure_dir(root_folder)
# load data
current_datafile = os.path.join(HERE_PATH, 'init_data.csv')
X, y = read_data(current_datafile)
# check everything is fine
np.testing.assert_array_almost_equal(np.sum(X, axis=1),
TOTAL_VOLUME_IN_ML,
decimal=N_DECIMAL_EQUAL)
#
X_selected = np.random.rand(N_GENERATED, X.shape[1])
X_selected = proba_normalize_row(X_selected)
X_selected = TOTAL_VOLUME_IN_ML * X_selected
# save new csv
#
X = proba_normalize_row(X)
#
clf = train_classifier(X, y)
X_selected, all_run_info = generate_next_samples(N_SELECTED, clf, X.shape[1], N_SAMPLING)
# save new csv
next_folder_number = filetools.generate_n_digit_name(last_folder_int + 1)
next_folder = os.path.join(root_folder, next_folder_number)
if os.path.exists(next_folder):
user_ok = False
while not user_ok:
rep = raw_input('{} already exist, you might erase stuff, continue [y, N]')
if rep in ['y', 'Y']:
user_ok = True
filetools.ensure_dir(next_folder)
# xout
X_out = np.vstack((X, X_selected))
X_out = TOTAL_VOLUME_IN_ML * X_out
# check everything is fine
np.testing.assert_array_almost_equal(np.sum(X_out, axis=1), TOTAL_VOLUME_IN_ML, decimal=N_DECIMAL_EQUAL)
# save
next_datafile = os.path.join(next_folder, 'data.csv')
write_data(next_datafile, X_out, y)
def generate_next_XP_foldername(pool_folder, n_digit=FOLDERNAME_N_DIGIT):
# save incremetaly in pool_folder
# ensure pool_folder exist and create incremetal foldername
filetools.ensure_dir(pool_folder)
return filetools.generate_incremental_foldername(pool_folder,
n_digit=n_digit)
def save_XP_dict_to_folder(XP_dict, xp_folder):
# make the XP_dict and save it there
filetools.ensure_dir(xp_folder)
XP_filename = os.path.join(xp_folder, XP_PARAMS_FILENAME)
save_to_json(XP_dict, XP_filename)
def save_XP_to_folder(oil_ratios, xp_folder):
# make the XP_dict and save it there
filetools.ensure_dir(xp_folder)
XP_filename = os.path.join(xp_folder, XP_PARAMS_FILENAME)
make_and_save_XP_dict(oil_ratios, xp_folder, XP_filename)
