-
Notifications
You must be signed in to change notification settings - Fork 0
/
nettuno_optimizer.py
149 lines (120 loc) · 6.39 KB
/
nettuno_optimizer.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
# nettuno_optimizer.py --- Main program
# Copyright (C) 2012 Sandro Bottaro, Christian Holzgraefe, Wouter Boomsma
#
# This file is part of Nettuno
#
# Nettuno is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Nettuno is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Nettuno. If not, see <http://www.gnu.org/licenses/>.
import optparse
import utils
import sys
from EnsembleCollection import EnsembleCollection
from SteepestDescentOptimizer import SteepestDescentOptimizer
from platforms.PlatformSelector import PlatformSelector
from platforms.Ensemble import Ensemble
class Nettuno:
'''Main Nettuno class containing EnsembleCollection and Optimizer objects'''
def __init__(self, optimizer, init_filename=".nettuno", log_level=0):
self.init_filename = init_filename
self.ensemble_collection = EnsembleCollection(log_level)
# self.optimizer = Optimizer()
if optimizer == "steepest_descent":
self.optimizer = SteepestDescentOptimizer(log_level)
else:
print "Unknown optimization algorithm: %s. Aborting." % optimizer
sys.exit(1)
self.read_init_file()
def read_init_file(self):
'''Reads configuration file'''
self.ensemble_collection.read_init_file(self.init_filename)
self.optimizer.read_init_file(self.init_filename)
def output_init_file(self, init_file_output):
'''Writes configuration file'''
if init_file_output == self.init_filename:
backup_name = self.init_filename + "_"+ datetime.datetime.today().isoformat("-")
shutil.copyfile(self.init_filename, backup_name)
if init_file_output == "stdout":
print "### Nettuno settings output ###\n"
print repr(self),
print "###############################"
else :
init_file = open(self.init_filename, "w")
init_file.write(repr(self))
init_file.close()
def get_ensemble_collection(self):
'''Retrieve EnsembleCollection object'''
return self.ensemble_collection
def get_optimizer(self):
'''Retrieve Optimizer object'''
return self.optimizer
def optimize(self):
'''Start optimization procedure'''
if len(self.ensemble_collection) > 0:
self.optimizer.optimize(self.ensemble_collection)
def __repr__(self):
return repr(self.optimizer) + "\n" + repr(self.ensemble_collection)
if __name__ == "__main__":
usage = '''
Nettuno - Relative Entropy Optimizer
Strategy:
1. Generate target ensemble (external).
2. Register target ensemble (using --add-target-ensemble option).
3. Generate new model ensemble (external).
4. Register new model ensemble (using --add-model-ensemble option).
5. Optimize (using --optimize option).
6. Repeat 3-6 with the parameter values found by 5.
'''
# Output for general platform options
ensemble_option_help = "\nGeneral platform options:"
ensemble_option_help += str(utils.SubOptions({'id':'ID (connects target and model ensembles)',
'directory': 'Directory containing simulation data',
'beta': 'Inverse temperature at which analysis should be done',
'iteration_range': 'Range used in analysis:\n\t[start_index, end_index, interval]'}))
# Platform specific options are retrieved from classes
ensemble_option_help += "\nPlatform specific options:\n"
for cls in Ensemble.__subclasses__():
ensemble_option_help += "\n"+cls.simulation_type + "\t" + cls.get_option_help()
# Option definitions
parser = optparse.OptionParser(usage=usage, formatter=utils.HelpFormatterInnerOptions(),
option_class=utils.CallbackHasMetaVarOption)
parser.add_option("--add_target_ensemble", dest="new_target_ensembles", action="callback", default=[],
callback=utils.vararg_callback,
help="Add new target ensemble entry." + ensemble_option_help)
parser.add_option("--add_model_ensemble", dest="new_model_ensembles", action="callback", default=[], type="string", nargs=0,
callback=utils.vararg_callback,
metavar = "simulation_type:SIMULATION_TYPE id:ID directory:DIRECTORY [platform-specific-options]",
help="Add new model ensemble entry." + ensemble_option_help)
parser.add_option("--init_file", dest="init_file", default=".nettuno",
help="File in which to read optimization settings.")
parser.add_option("--init_file_output", dest="init_file_output", default="stdout",
help="File/stream in which to write optimization settings.")
parser.add_option("--optimizer", dest="optimizer", type='choice', choices=['steepest_descent'],
default="steepest_descent",
help="Which optimization algorithm to use")
parser.add_option("--log_level", dest="log_level", default="1",
help="How much information to output to screen")
(options, args) = parser.parse_args()
# Allocate main object
nettuno = Nettuno(options.optimizer, options.init_file, int(options.log_level))
# Add ensembles specified from command line
for target_ensemble_tuple in options.new_target_ensembles:
option_dict = EnsembleCollection.option_list_to_ensemble_option_dict(target_ensemble_tuple)
nettuno.get_ensemble_collection().add_model_ensemble(**option_dict)
for model_ensemble_tuple in options.new_model_ensembles:
option_dict = EnsembleCollection.option_list_to_ensemble_option_dict(model_ensemble_tuple)
nettuno.get_ensemble_collection().add_model_ensemble(**option_dict)
# Optionally write out settings to file or stdout
if options.init_file_output != "stdout" or options.log_level >=1:
nettuno.output_init_file(options.init_file_output)
# Call optimization
nettuno.optimize()