def main():
# Create M-LOOP optmiser interface with desired parameters
interface = LoopInterface()
# interface.daemon = True
# Instantiate experiment controller
controller = create_controller(interface, **interface.config)
# Define the M-LOOP session ID and initialise the mloop_iteration
set_globals_mloop(controller.start_datetime.strftime('%Y%m%dT%H%M%S'), 0)
# Run the optimiser using the constructed interface
controller.optimize()
# Reset the M-LOOP session and index to None
logger.info('Optimisation ended.')
set_globals_mloop()
# Set the optimisation globals to their best results
logger.info('Setting best parameters in runmanager.')
globals_dict = dict(
zip(interface.config['mloop_params'], controller.best_params))
set_globals(globals_dict)
# Return the results in a dictionary
opt_results = {}
opt_results['best_params'] = controller.best_params
opt_results['best_cost'] = controller.best_cost
opt_results['best_uncer'] = controller.best_uncer
opt_results['best_index'] = controller.best_index
return opt_results
def RunOnce(
max_allowed_runs,
tcost,
n_ab,
y_target,
noise_type="None",
noise_scale=0.0,
learner="gaussian_process",
):
"""Runs M-LOOP once and returns the cost of each run, and the number of runs
Args:
max_allowed_runs (int): Max runs for the learner
tcost (float): Target cost for the learner
n_ab (int): number of parameters / 2 (length of a,b for FS)
y_target (np.ndarray): y-values of target function
noise_type (str, optional): type of noise to combine with costs. Defaults to "None".
noise_scale (float, optional): std dev of noise to combine with costs. Defaults to 0.0.
learner (str, optional): Learner type for M-LOOP. Defaults to "gaussian_process".
Returns:
np.ndarray: costs of each run
int: number of runs taken
list: parameters of each run (list of np.ndarrays)
float: process_time of controller.optimize()
"""
if learner not in [
"gaussian_process",
"neural_net",
"differential_evolution",
"nelder_mead",
"random",
]:
raise ValueError("learner was not one of the valid choices.")
interface = _FourierInterface(n_ab, y_target, noise_type, noise_scale)
controller = mlc.create_controller(
interface,
controller_type=learner,
max_num_runs=max_allowed_runs,
target_cost=tcost,
num_params=n_ab * 2,
min_boundary=np.full(n_ab * 2, -1), # range [-1, 1]
max_boundary=np.full(n_ab * 2, 1),
no_delay=False,
controller_archive_file_type="pkl",
learner_archive_file_type="pkl",
)
t_init = perf_counter()
controller.optimize()
t_fin = perf_counter()
time_taken = t_fin - t_init
costs = controller.in_costs
runs = controller.num_in_costs
out_params = controller.out_params
return costs, runs, out_params, time_taken
def test_bad(self):
cost_list = [1., float('nan'),2.,float('nan'),-1.]
interface = CostListInterface(cost_list)
controller = mlc.create_controller(interface,
max_num_runs = 10,
target_cost = -1,
max_num_runs_without_better_params = 4)
controller.optimize()
self.assertTrue(controller.best_cost == -1.)
for x,y in zip(controller.in_costs,cost_list):
self.assertTrue(x==y or (math.isnan(x) and math.isnan(y)))
def test_target_cost(self):
cost_list = [1.,2.,-1.]
interface = CostListInterface(cost_list)
controller = mlc.create_controller(interface,
max_num_runs = 10,
target_cost = -1,
max_num_runs_without_better_params = 4)
controller.optimize()
self.assertTrue(controller.best_cost == -1.)
self.assertTrue(np.array_equiv(np.array(controller.in_costs),
np.array(cost_list)))
def main():
#M-LOOP can be run with three commands
#First create your interface
interface = CustomInterface()
#Next create the controller. Provide it with your interface and any options you want to set
n = 10
d = 25
'''
para=np.linspace(0,interface.l/2-r,n+1)
low=para[0:n]
up=para[1:n+1]
'''
low = np.array([0] * n)
up = np.array([interface.l / 2 - d / 2] * n)
'''
#z=np.array([0.003, 0.009, 0.009, 0.009, 0.019, 0.021, 0.032, 0.038, 0.043, 0.061, 0.078, 0.079, 0.1, 0.103, 0.103])
z=np.array([0.0, 0.008, 0.019, 0.034, 0.035, 0.042, 0.063, 0.089, 0.099, 0.099])
half=0.03
low=z-half
low=np.maximum(0,low)
up=z+half
up=np.minimum(interface.l/200-r,up)
'''
controller = mlc.create_controller(
interface,
#training_type='random',
controller_type='neural_net',
max_num_runs=2000,
#target_cost = 0,
num_params=n,
min_boundary=low.tolist(),
max_boundary=up.tolist(),
keep_prob=0.8)
#To run M-LOOP and find the optimal parameters just use the controller method optimize
controller.optimize()
#The results of the optimization will be saved to files and can also be accessed as attributes of the controller.
print('Best parameters found:')
print(controller.best_params)
#You can also run the default sets of visualizations for the controller with one command
mlv.show_all_default_visualizations(controller, max_parameters_per_plot=2)
'''
mlv.create_neural_net_learner_visualizations(controller.ml_learner.total_archive_filename,
file_type=controller.ml_learner.learner_archive_file_type,
plot_cross_sections=True)
plt.show()
'''
cal_grad(params=controller.best_params, l=interface.l, r=interface.r)
cal_grad(params=controller.predicted_best_parameters,
l=interface.l,
r=interface.r)
def test_bad(self):
cost_list = [1., float('nan'), 2., float('nan'), -1.]
interface = CostListInterface(cost_list)
controller = mlc.create_controller(
interface,
max_num_runs=10,
target_cost=-1,
max_num_runs_without_better_params=4)
controller.optimize()
self.assertTrue(controller.best_cost == -1.)
for x, y in zip(controller.in_costs, cost_list):
self.assertTrue(x == y or (math.isnan(x) and math.isnan(y)))
def test_target_cost(self):
cost_list = [1., 2., -1.]
interface = CostListInterface(cost_list)
controller = mlc.create_controller(
interface,
max_num_runs=10,
target_cost=-1,
max_num_runs_without_better_params=4)
controller.optimize()
self.assertTrue(controller.best_cost == -1.)
self.assertTrue(
np.array_equiv(np.array(controller.in_costs), np.array(cost_list)))
def main():
''' This is the code that excutes the machine learning online optimization
process (MLOOP). '''
#create the interface
interface = CustomInterface()
#create the controller and provide the interface and options
controller = mlc.create_controller(interface)
#run the mloop optimization
controller.optimize()
#access the optimized parameters (the results will be saved to a file
#somewhere)
print(f"Best parameters found: {controller.best_params}")
def mloop():
#First create your interface
interface = CustomInterface()
#Next create the controller, provide it with your controller and any options you want to set
controller = mlc.create_controller(interface,
max_num_runs=50,
target_cost=-100,
num_params=1,
min_boundary=[3],
max_boundary=[68])
#To run M-LOOP and find the optimal parameters just use the controller method optimize
controller.optimize()
#The results of the optimization will be saved to files and can also be accessed as attributes of the controller.
print('Best parameters found:')
print(controller.best_params)
#You can also run the default sets of visualizations for the controller with one command
mlv.show_all_default_visualizations(controller)
def main():
#M-LOOP can be run with three commands
#First create your interface
interface = CustomInterface()
#Next create the controller, provide it with your controller and any options you want to set
controller = mlc.create_controller(interface,
max_num_runs = 1000,
target_cost = -2.99,
num_params = 3,
min_boundary = [-2,-2,-2],
max_boundary = [2,2,2])
#To run M-LOOP and find the optimal parameters just use the controller method optimize
controller.optimize()
#The results of the optimization will be saved to files and can also be accessed as attributes of the controller.
print('Best parameters found:')
print(controller.best_params)
#You can also run the default sets of visualizations for the controller with one command
mlv.show_all_default_visualizations(controller)
def main():
#M-LOOP can be run with three commands
#First create your interface
interface = CustomInterface()
#Next create the controller. Provide it with your interface and any options you want to set
n = 10
para = np.linspace(0, 0.135, n + 1)
low = para[0:n]
up = para[1:n + 1]
controller = mlc.create_controller(
interface,
#training_type='random',
controller_type='neural_net',
max_num_runs=5000,
target_cost=0,
num_params=n,
min_boundary=low.tolist(),
max_boundary=up.tolist(),
keep_prob=0.9)
#To run M-LOOP and find the optimal parameters just use the controller method optimize
controller.optimize()
#The results of the optimization will be saved to files and can also be accessed as attributes of the controller.
print('Best parameters found:')
print(controller.best_params)
#You can also run the default sets of visualizations for the controller with one command
mlv.show_all_default_visualizations(controller)
mlv.create_neural_net_learner_visualizations(
controller.ml_learner.total_archive_filename,
file_type=controller.ml_learner.learner_archive_file_type,
plot_cross_sections=True)
plt.show()
cal_grad(controller.best_params)
cal_grad(controller.predicted_best_parameters)
def launch_from_file(config_filename, **kwargs):
'''
Launch M-LOOP using a configuration file. See configuration file documentation.
Args:
config_filename (str): Filename of configuration file
**kwargs : keywords that override the keywords in the file.
Returns:
controller (Controller): Controller for optimization.
'''
try:
file_kwargs = mlu.get_dict_from_file(config_filename, 'txt')
except (IOError, OSError):
print('Unable to open M-LOOP configuration file:' +
repr(config_filename))
raise
file_kwargs.update(kwargs)
#Main run sequence
#Create interface and extract unused keywords
interface = mli.create_interface(**file_kwargs)
file_kwargs = interface.remaining_kwargs
#Create controller and extract unused keywords
controller = mlc.create_controller(interface, **file_kwargs)
file_kwargs = controller.remaining_kwargs
#Extract keywords for post processing extras, and raise an error if any keywords were unused.
extras_kwargs = _pop_extras_kwargs(file_kwargs)
if file_kwargs:
logging.getLogger(__name__).error('Unused extra options provided:' +
repr(file_kwargs))
raise ValueError
#Run the actual optimization
controller.optimize()
#Launch post processing extras
launch_extras(controller, **extras_kwargs)
return controller
def main():
#M-LOOP can be run with three commands
#First create your interface
interface = CustomInterface()
#Next create the controller. Provide it with your interface and any options you want to set
controller = mlc.create_controller(interface,
max_num_runs = 10000,
controller_type='neural_net',
#target_cost = -2.99,
num_params = 3,
min_boundary = [-2,-2,-2],
max_boundary = [2,2,2])
#To run M-LOOP and find the optimal parameters just use the controller method optimize
controller.optimize()
#The results of the optimization will be saved to files and can also be accessed as attributes of the controller.
print('Best parameters found:')
print(controller.best_params)
#You can also run the default sets of visualizations for the controller with one command
mlv.show_all_default_visualizations(controller)
plt.show()
def launch_from_file(config_filename,
**kwargs):
'''
Launch M-LOOP using a configuration file. See configuration file documentation.
Args:
config_filename (str): Filename of configuration file
**kwargs : keywords that override the keywords in the file.
Returns:
controller (Controller): Controller for optimization.
'''
try:
file_kwargs = mlu.get_dict_from_file(config_filename,'txt')
except (IOError, OSError):
print('Unable to open M-LOOP configuration file:' + repr(config_filename))
raise
file_kwargs.update(kwargs)
#Main run sequence
#Create interface and extract unused keywords
interface = mli.create_interface(**file_kwargs)
file_kwargs = interface.remaining_kwargs
#Create controller and extract unused keywords
controller = mlc.create_controller(interface, **file_kwargs)
file_kwargs = controller.remaining_kwargs
#Extract keywords for post processing extras, and raise an error if any keywords were unused.
extras_kwargs = _pop_extras_kwargs(file_kwargs)
if file_kwargs:
logging.getLogger(__name__).error('Unused extra options provided:' + repr(file_kwargs))
raise ValueError
#Run the actual optimization
controller.optimize()
#Launch post processing extras
launch_extras(controller, **extras_kwargs)
return controller
def main():
# create a file folder to save today's data
today = str(datetime.date.today())
path_today = 'E:/python/code/data/' + today
if not os.path.exists(path_today):
os.makedirs(path_today)
n = 7
interface_2 = CustomInterface_2(n)
controller = mlc.create_controller(
interface_2,
#training_type='differential_evolution',
controller_type='neural_net',
max_num_runs=100,
keep_prob=0.8,
num_params=n,
min_boundary=[0.2] * n,
max_boundary=[1] * n)
# start the second optimization
controller.optimize()
# create the file folder of this optimization
start_datetime = str(controller.start_datetime)[11:19]
start_time = sf.change_colon_into_dash(start_datetime)
path_today += '/' + str(start_time)
os.makedirs(path_today)
# save the best wave
res = sf.add_zero(controller.best_params)
filename = path_today + '/best_paras_2_' + str(start_time) + '.csv'
sf.array_to_csv(filename=filename, array=res)
# save the predicted wave
res = sf.add_zero(controller.predicted_best_parameters)
filename = path_today + '/pre_best_paras_2_' + str(start_time) + '.csv'
sf.array_to_csv(filename=filename, array=res)
# save the seed light of the predicted wave
res = sf.wave_normalization(res)
filename = 'E:/python/documents/wave_opt/gausswave.csv'
sf.array_to_csv(filename=filename, array=res)
siganl = [1]
gain = sf.convey_params_get_cost(siganl)
res = res / gain * interface_2.paras_scale
filename = 'E:/python/documents/wave_opt/gausswave.csv'
sf.array_to_csv(filename=filename, array=res)
signal = [-1]
gate = sf.convey_params_get_cost(signal)
filename_SQ = 'D:/shot noise/' + sf.today_str() + '/try/SQ.csv'
filename_ASQ = 'D:/shot noise/' + sf.today_str() + '/try/ASQ.csv'
df_SQ = pd.read_csv(filename_SQ, header=None).values
df_ASQ = pd.read_csv(filename_ASQ, header=None).values
res = df_SQ - df_ASQ
df_SQ = df_SQ[np.where(np.abs(res - np.mean(res)) < 3 * gate)]
res = res[np.where(np.abs(res - np.mean(res)) < 3 * gate)]
cost = np.var(res) / np.mean(df_SQ)
print('predicted best cost_2 is:', controller.predicted_best_cost)
print('actual cost_2 is:', 10 * np.log10(cost))
filename_seedlight = 'D:/shot noise/' + sf.today_str() + '/try2/seed.csv'
filename = path_today + '/seedlight_2_' + str(start_time) + '.csv'
df = pd.read_csv(filename_seedlight, header=None)
df.to_csv(filename, header=0, index=0)
# save the excited stokes light
filename_excited = 'D:/shot noise/' + sf.today_str() + '/try/excited.csv'
filename_SQ = 'D:/shot noise/' + sf.today_str() + '/try/SQ.csv'
filename = path_today + '/excited_light_2_' + str(start_time) + '.csv'
df = pd.read_csv(filename_excited, header=None)
df.to_csv(filename, header=0, index=0)
filename_SQ = 'D:/shot noise/' + sf.today_str() + '/try/SQ.csv'
filename = path_today + '/SQ_2_' + str(start_time) + '.csv'
df = pd.read_csv(filename_SQ, header=None)
df.to_csv(filename, header=0, index=0)
# save the anti-stokes light
filename_excited = 'D:/shot noise/' + sf.today_str(
) + '/try/antistokes.csv'
filename = path_today + '/antistokes_2_' + str(start_time) + '.csv'
df = pd.read_csv(filename_excited, header=None)
df.to_csv(filename, header=0, index=0)
filename_ASQ = 'D:/shot noise/' + sf.today_str() + '/try/ASQ.csv'
filename = path_today + '/ASQ_2_' + str(start_time) + '.csv'
df = pd.read_csv(filename_ASQ, header=None)
df.to_csv(filename, header=0, index=0)
# show visualizations
mlv.show_all_default_visualizations(controller)
def main():
# create a file folder to save today's data
today = str(datetime.date.today())
path_today = 'E:/python/code/data/' + today
if not os.path.exists(path_today):
os.makedirs(path_today)
# interface to optimize gain
interface_1 = CustomInterface_1(nums_params=7)
controller = mlc.create_controller(
interface_1,
#training_type='random',
controller_type='neural_net',
max_num_runs=100,
# target_cost = -2.99,
keep_prob=0.8,
num_params=interface_1.nums_params,
min_boundary=[0.2] * interface_1.nums_params,
max_boundary=[1] * interface_1.nums_params)
# To run M-LOOP and find the optimal parameters just use the controller method optimize
controller.optimize()
# create the file folder of this optimization
start_datetime = str(controller.start_datetime)[11:19]
start_time = sf.change_colon_into_dash(start_datetime)
path_today += '/' + str(start_time)
os.makedirs(path_today)
# save the best wave
res = sf.add_zero(controller.best_params)
filename = path_today + '/best_paras_' + str(start_time) + '.csv'
sf.array_to_csv(filename=filename, array=res)
# save the predicted wave
res = sf.add_zero(controller.predicted_best_parameters)
filename = path_today + '/pre_best_paras_' + str(start_time) + '.csv'
sf.array_to_csv(filename=filename, array=res)
# save the seed light of the predicted wave
filename = 'E:/python/documents/wave_opt/gausswave.csv'
sf.array_to_csv(filename=filename, array=res)
signal = [1]
gain = sf.convey_params_get_cost(signal)
print('predicted best cost is:', controller.predicted_best_cost)
print('actual cost is:', 10 * np.log10(gain))
filename_seedlight = 'D:/shot noise/' + sf.today_str() + '/try2/seed.csv'
filename = path_today + '/seedlight_' + str(start_time) + '.csv'
df = pd.read_csv(filename_seedlight, header=None)
df.to_csv(filename, header=0, index=0)
# save the excited stokes light
filename_excited = 'D:/shot noise/' + sf.today_str() + '/try/excited.csv'
filename = path_today + '/excited_light_2_' + str(start_time) + '.csv'
df = pd.read_csv(filename_excited, header=None)
df.to_csv(filename, header=0, index=0)
filename_SQ = 'D:/shot noise/' + sf.today_str() + '/try/SQ.csv'
filename = path_today + '/SQ_2_' + str(start_time) + '.csv'
df = pd.read_csv(filename_SQ, header=None)
df.to_csv(filename, header=0, index=0)
# save the anti-stokes light
filename_excited = 'D:/shot noise/' + sf.today_str(
) + '/try/antistokes.csv'
filename = path_today + '/antistokes_2_' + str(start_time) + '.csv'
df = pd.read_csv(filename_excited, header=None)
df.to_csv(filename, header=0, index=0)
filename_ASQ = 'D:/shot noise/' + sf.today_str() + '/try/ASQ.csv'
filename = path_today + '/ASQ_2_' + str(start_time) + '.csv'
df = pd.read_csv(filename_ASQ, header=None)
df.to_csv(filename, header=0, index=0)
# show visualizations
mlv.show_all_default_visualizations(controller)
'''