def _generate_param_class_dict(fname, param_names):
"""
Generate the parameter and class dictionaries for the Model
Parameters
----------
fname: ~str
param_names: ~list of ~str
Returns
-------
"""
config = ConfigurationNameSpace.from_yaml(fname)
class_dict = {}
param_dict = {}
short_param_name_dict = _convert_param_names(param_names)
class_dict['convert_param_dict'] = short_param_name_dict
for key in short_param_name_dict:
try:
value = config.get_config_item(short_param_name_dict[key])
except KeyError:
raise ValueError('{0} is not a valid parameter'.format(key))
else:
pass
class_dict[key] = Parameter()
param_dict[key] = getattr(value, 'value', value)
return class_dict, param_dict, config
def __init__(self, config_fname, atom_data=None, log_dir='./logs/'):
self._log_dir = log_dir
self.set_logger('startup')
self._config = ConfigurationNameSpace.from_yaml(config_fname)
if atom_data is None:
self._atom_data = AtomData.from_hdf5(self._config.atom_data)
else:
self._atom_data = atom_data
def __init__(self, *args, **kwargs):
config_fname = args[0]
atom_data = kwargs.pop('atom_data', None)
self._log_dir = kwargs.pop('log_dir', './logs/')
self.set_logger('startup')
self._config = ConfigurationNameSpace.from_yaml(config_fname)
if atom_data is None:
self._atom_data = AtomData.from_hdf5(self._config.atom_data)
else:
self._atom_data = atom_data
def _load_comparison_config(self, comparison_config_fname):
comparison_config = ConfigurationNameSpace.from_yaml(
comparison_config_fname)
self.comparison_dict = OrderedDict()
for column in self.data_columns:
default_value = comparison_config.get_config_item(column)
#removing the quantity-ness
#default_value = getattr(default_value, 'value', default_value)
self.comparison_dict[column] = default_value
def from_yaml(cls, fname, resume_fit=None):
"""
Reading the fitter configuration from a yaml file
Parameters
----------
fname: ~str
filename
"""
conf_dict = yaml.load(open(fname), OrderedDictYAMLLoader)
default_config = ConfigurationNameSpace.from_yaml(
conf_dict['tardis']['default_conf'])
atom_data = AtomData.from_hdf5(conf_dict['tardis']['atom_data'])
parameter_config = ParameterConfiguration.from_conf_dict(conf_dict['fitter']['parameters'])
number_of_samples = conf_dict['fitter']['number_of_samples']
max_iterations = conf_dict['fitter']['max_iterations']
optimizer_dict = conf_dict['fitter'].pop('optimizer')
optimizer_class = all_optimizer_dict[optimizer_dict.pop('name')]
optimizer = optimizer_class(parameter_config, number_of_samples,
**optimizer_dict)
fitness_function_dict = conf_dict['fitter'].pop('fitness_function')
fitness_function_class = all_fitness_function_dict[
fitness_function_dict.pop('name')]
fitness_function = fitness_function_class(**fitness_function_dict)
resume = conf_dict['fitter'].get('resume', resume_fit)
fitter_log = conf_dict['fitter'].get('fitter_log', None)
spectral_store_dict = conf_dict['fitter'].get('spectral_store', None)
if spectral_store_dict is not None:
spectral_store_fname = spectral_store_dict['fname']
spectral_store_mode = spectral_store_dict.get('mode', 'all')
spectral_store_clobber = spectral_store_dict.get('clobber', False)
spectral_store = SpectralStore(spectral_store_fname,
mode=spectral_store_mode,
resume=resume,
clobber=spectral_store_clobber)
else:
spectral_store = None
return cls(optimizer, fitness_function,
parameter_config=parameter_config,
default_config=default_config, atom_data=atom_data,
number_of_samples=number_of_samples,
max_iterations=max_iterations, fitter_log=fitter_log,
spectral_store=spectral_store, resume=resume)
def simple_triangle_plot(dalek_log_file, truth_config=None, plot_contours=False, bins=100):
"""
Parameters
----------
dalek_log_file : ~str
path to normal dalek log file
truth_config : ~str
path to tardis config file containing the truth values [optional]
plot_contours : ~bool
plotting contours for the distributions
:return:
"""
dalek_data = pd.read_csv(dalek_log_file, index_col=0)
if truth_config is not None:
truth_config = ConfigurationNameSpace.from_yaml(truth_config)
fitness = dalek_data['dalek.fitness']
labels = []
truths = []
for column in dalek_data.columns:
if 'dalek' in column:
continue
if column.endswith('item0'):
label = '.'.join(column.split('.')[-2:])
else:
label = column.split('.')[-1]
labels.append(label)
if truth_config is not None:
default_value = truth_config.get_config_item(column)
default_value = getattr(default_value, 'value', default_value)
truths.append(default_value)
if truths == []:
truths = None
triangle.corner(dalek_data[data_columns], weights=1/fitness,
labels=labels,
plot_contours=plot_contours, normed=True, truths=truths,
bins=bins)
