def deep_parse(self, *args, **kwargs):
def empty_check(unic):
checked = [x for x in unic if not x == '']
return checked
def ovrflw_check(unic):
checked =\
['1000000.0' if x.count('OVRFLW') else x for x in unic]
return checked
def _all_checks_(unic):
unic = empty_check(unic)
checked = ovrflw_check(unic)
return checked
def hms_to_mins(hms):
convs = [60.0, 1.0, 1.0/60.0]
mins = [sum([float(pair[0])*pair[1] for pair
in zip(hms[x].split(':'), convs)])
for x in range(len(hms))]
return mins
def time_filter(hms):
hms0 = '0:00:00'
hms = [min_ for d, min_ in
enumerate(hms) if not
min_ == hms0 or d == 0]
mins = hms_to_mins(hms)
return mins
known_filters = OrderedDict()
known_filters['Time'] = time_filter
known_filters['_all_'] = _all_checks_
def filter_(key, dat):
kf = known_filters
dat = kf['_all_'](dat)
if key in kf.keys(): dat = kf[key](dat)
try: return np.array(dat,dtype='f')
except ValueError: pdb.set_trace()
measur = self._measurement_
weldat = self._well_data_
welkey = self._well_key_
condat = self._cond_data_
conkey = self._cond_key_
con_data = lgeo.scalars_from_labels(conkey)
for dex, key in enumerate(conkey):
con_data[dex].scalars = filter_(key, condat[:,dex])
wel_data = lgeo.scalars_from_labels(welkey)
for dex, key in enumerate(welkey):
wel_data[dex].scalars = filter_(key, weldat[:,dex])
all_data = con_data + wel_data
self._unreduced_ = lfu.data_container(data = all_data)
self._reduced_ = self.apply_reduction(self._unreduced_.data)
self.update_replicate_reduction()
def __init__(self, ensem, params = {}):
self.ensemble = ensem
#self.parameters = copy(params)
self.parameters = params
try: self.end_criteria = self.parameters['end_criteria']
except KeyError: self.end_criteria = [lc.criterion_iteration()]
try: self.capture_criteria = self.parameters['capture_criteria']
except KeyError: self.capture_criteria = []
try:
self.end_bool_expression =\
self.parameters['bool_expressions']['end']
self.capt_bool_expression =\
self.parameters['bool_expressions']['capt']
except KeyError:
self.end_bool_expression = ''
self.end_capture_expression = ''
try:
data = lgeo.scalars_from_labels(
self.parameters['plot_targets'])
except KeyError: print 'simulating with no resultant data!'
self.bAbort = False
self.time = []
self.iteration = 0
if not self.end_criteria:
self.end_criteria = [lc.criterion_iteration()]
self.determine_end_valid_data = (None, (None))
#lfu.modular_object_qt.__init__(self, label = label, data = data)
lfu.modular_object_qt.__init__(self, data = data)
def reduction(self, *args, **kwargs):
pdb.set_trace()
data = lgeo.scalars_from_labels(self.target_list)
for dex, mean_of in enumerate(self.means_of):
bin_axes, mean_axes = select_for_binning(args[0], self.function_of,
mean_of)
bins, vals = bin_scalars(bin_axes, mean_axes, self.bin_count,
self.ordered)
means = [mean(val) for val in vals]
data[dex + 1].scalars = means
data[0].scalars = bins
return data
def reduction(self, *args, **kwargs): pdb.set_trace() data = lgeo.scalars_from_labels(self.target_list) for dex, mean_of in enumerate(self.means_of): bin_axes, mean_axes = select_for_binning( args[0], self.function_of, mean_of) bins, vals = bin_scalars(bin_axes, mean_axes, self.bin_count, self.ordered) means = [mean(val) for val in vals] data[dex + 1].scalars = means data[0].scalars = bins return data
def initialize(self, *args, **kwargs): if not self.cooling_curve: self.final_iteration =\ self.fitted_criteria[0].max_iterations lam = -1.0 * np.log(self.max_temperature)/\ self.final_iteration cooling_domain = np.array(range(self.final_iteration)) cooling_codomain = self.max_temperature*np.exp( lam*cooling_domain) self.cooling_curve = lgeo.scalars( label = 'cooling curve', scalars = cooling_codomain) fit_routine.initialize(self, *args, **kwargs) self.data.extend(lgeo.scalars_from_labels( ['annealing temperature'])) self.temperature = self.cooling_curve.scalars[self.iteration] self.parameter_space.initial_factor = self.temperature
def apply_reduction(self, unred): read = self.parent.parent.read['layout'].read flat = lfu.flatten(read['table']) well_cnt = len(flat) reduced = unred[:len(unred)-well_cnt] #list of replicate averaged scalers con_offset = len(reduced) uniq = lfu.uniqfy(flat) layout = OrderedDict() for dex, key in enumerate(flat): if key in layout.keys(): layout[key].append(dex + con_offset) else: layout[key] = [dex + con_offset] new = lgeo.scalars_from_labels(layout.keys()) for ndex, key in enumerate(layout.keys()): rel_dexes = layout[key] rel_dater = [unred[d] for d in rel_dexes] zi = zip(*[r.scalars for r in rel_dater]) new[ndex].scalars = np.array([np.mean(z) for z in zi]) reduced.extend(new) red = lfu.data_container(data = reduced) return red
def initialize(self, *args, **kwargs):
self.output.flat_data = True
self.ensemble = self.parent.parent
self.worker_count =\
self.parent.parent.multiprocess_plan.worker_count
self.proginy_count = 100
if False and self.ensemble.multiprocess_plan.use_plan and\
not self.regime.endswith('magnitude'):
self.use_genetics = True
self.proginy_count = 100
else: self.use_genetics = False
#self.ensemble.data_pool = self.ensemble.set_data_scheme()
self.run_targets = self.ensemble.run_params['plot_targets']
self.data_to_fit_to = self.get_input_data(read = False)
self.target_key = [[dat.label for dat in
self.data_to_fit_to], self.run_targets]
def expo_weights(leng):
dom_weight_max = 5.0
dom_weight_x = np.linspace(dom_weight_max, 0, leng)
return np.exp(dom_weight_x)
def para_weights(leng):
dom_weight_max = 9.0
x = np.linspace(0, leng, leng)
y = x*(x - x[-1])
y_0 = min(y)
y = y - y_0
y = dom_weight_max*y/max(y) + 1
#for k in range(0, 2) + range(-3, -1): y[k] = 0.0
return y
def affi_weights(leng):
x = np.linspace(0, leng, leng)
b = 5.0
m = -4.0/x[-1]
y = m*x + b
return y
def flat_weights(leng):
y = [1.0 for val in range(leng)]
return y
fit_x_leng = len(self.data_to_fit_to[0].scalars)
#self.domain_weights = expo_weights(fit_x_leng)
self.domain_weights = para_weights(fit_x_leng)
#self.domain_weights = affi_weights(fit_x_leng)
#self.domain_weights = flat_weights(fit_x_leng)
self.iteration = 0
self.timeouts = 0
self.parameter_space =\
self.parent.parent.cartographer_plan.parameter_space
if self.regime == 'coarse-magnitude':
self.use_mean_fitting = False
self.parameter_space, valid =\
lgeo.generate_coarse_parameter_space_from_fine(
self.parameter_space, magnitudes = True)
if not valid:
traceback.print_exc(file=sys.stdout)
lgd.message_dialog(None,
'P-Spaced couldnt be coarsened!', 'Problem')
elif self.regime == 'coarse-decimate':
self.use_mean_fitting = False
self.parameter_space, valid =\
lgeo.generate_coarse_parameter_space_from_fine(
self.parameter_space, decimates = True)
if not valid:
traceback.print_exc(file=sys.stdout)
lgd.message_dialog(None,
'P-Spaced couldnt be coarsened!', 'Problem')
elif self.regime == 'fine': pass
print '\tstarted fit routine', self.label, 'regime', self.regime
self.parameter_space.set_start_position()
for metric in self.metrics:
metric.initialize(self, *args, **kwargs)
self.data = lgeo.scalars_from_labels(['fitting iteration'] +\
[met.label + ' measurement' for met in self.metrics])
