def get_html(self, base_file_name: str, h_level: int) -> str:
sp = None # type: SingleProperty
columns = [
BOTableColumn("n", "{:5d}", lambda sp, _: sp.observations(), first),
BOTableColumn("mean", "{:10.5f}", lambda sp, _: sp.mean(), first),
BOTableColumn("mean / best mean", "{:5.5%}", lambda sp, means: sp.mean() / min(means), first),
BOTableColumn("mean / mean of first impl", "{:5.5%}", lambda sp, means: sp.mean() / means[0], first),
BOTableColumn("std / mean", "{:5.5%}", lambda sp, _: sp.std_dev_per_mean(), first),
BOTableColumn("std / best mean", "{:5.5%}", lambda sp, means: sp.std_dev() / min(means), first),
BOTableColumn("std / mean of first impl", "{:5.5%}", lambda sp, means: sp.std_dev() / means[0], first),
BOTableColumn("median", "{:5.5f}", lambda sp, _: sp.median(), first)
]
html = """
<h{h}>Input: {input}</h{h}>
The following plot shows the actual distribution of the measurements for each implementation.
{box_plot}
""".format(h=h_level, input=repr(self.input), box_plot=self.get_box_plot_html(base_file_name))
html += self.table_html_for_vals_per_impl(columns, base_file_name)
return html
python类median()的实例源码
def alt_results(self, samples, kplanets):
titles = sp.array(["Amplitude","Period","Longitude", "Phase","Eccentricity", 'Acceleration', 'Jitter', 'Offset', 'MACoefficient', 'MATimescale', 'Stellar Activity'])
namen = sp.array([])
ndim = kplanets * 5 + self.nins*2*(self.MOAV+1) + self.totcornum + 1
RESU = sp.zeros((ndim, 5))
for k in range(kplanets):
namen = sp.append(namen, [titles[i] + '_'+str(k) for i in range(5)])
namen = sp.append(namen, titles[5]) # for acc
for i in range(self.nins):
namen = sp.append(namen, [titles[ii] + '_'+str(i+1) for ii in sp.arange(2)+6])
for c in range(self.MOAV):
namen = sp.append(namen, [titles[ii] + '_'+str(i+1) + '_'+str(c+1) for ii in sp.arange(2)+8])
for h in range(self.totcornum):
namen = sp.append(namen, titles[-1]+'_'+str(h+1))
alt_res = map(lambda v: (v[2], v[3]-v[2], v[2]-v[1], v[4]-v[2], v[2]-v[0]),
zip(*np.percentile(samples, [2, 16, 50, 84, 98], axis=0)))
logdat = '\nAlternative results with uncertainties based on the 2nd, 16th, 50th, 84th and 98th percentiles of the samples in the marginalized distributions'
logdat = '\nFormat is like median +- 1-sigma, +- 2-sigma'
for res in range(ndim):
logdat += '\n'+namen[res]+' : '+str(alt_res[res][0])+' +- '+str(alt_res[res][1:3]) +' 2% +- '+str(alt_res[res][3:5])
RESU[res] = sp.percentile(samples, [2, 16, 50, 84, 98], axis=0)[:, res]
print(logdat)
return RESU
def _getMedianVals(self):
'''
@return: A scipy matrix representing the gray-scale median values of the image stack.
If you want a pyvision image, just wrap the result in pv.Image(result).
'''
self._imageStack = self._imageBuffer.asStackBW()
medians = sp.median(self._imageStack, axis=0) #median of each pixel jet in stack
return medians
def _updateMedian(self):
curImg = self._imageBuffer.getLast()
curMat = curImg.asMatrix2D()
median = self._medians
up = (curMat > median)*1.0
down = (curMat < median)*1.0
self._medians = self._medians + up - down
def property_filter_half(cur_index: int, all: t.List[Program], property_func: t.Callable[[Program], float],
remove_upper_half: bool) -> bool:
"""
Note: if the number of programs is uneven, then one program will belong to the upper and the lower half.
"""
vals = [property_func(p) for p in all]
cur_val = vals[cur_index]
median = sp.median(vals)
if (remove_upper_half and cur_val > median) or (not remove_upper_half and cur_val < median):
return False
return True
def initialize(self, sample_from_prior, distance_to_ground_truth_function):
super().initialize(sample_from_prior,
distance_to_ground_truth_function)
eps_logger.debug("calc initial epsilon")
# calculate initial epsilon if not given
if self._initial_epsilon == 'from_sample':
distances = sp.asarray([distance_to_ground_truth_function(x)
for x in sample_from_prior])
eps_t0 = sp.median(distances) * self.median_multiplier
self._look_up = {0: eps_t0}
else:
self._look_up = {0: self._initial_epsilon}
eps_logger.info("initial epsilon is {}".format(self._look_up[0]))
def __call__(self, t, history):
try:
return self._look_up[t]
except KeyError:
df_weighted = history.get_weighted_distances(None)
median = weighted_median(
df_weighted.distance.as_matrix(), df_weighted.w.as_matrix())
self._look_up[t] = median * self.median_multiplier
eps_logger.debug("new eps, t={}, eps={}"
.format(t, self._look_up[t]))
return self._look_up[t]
def __MR_final_saliency(self,integrated_sal, labels, aff):
# get binary image
if self.binary_thre == None:
thre = sp.median(integrated_sal.astype(float))
mask = integrated_sal > thre
# get indicator
ind = self.__MR_second_stage_indictor(mask,labels)
return self.__MR_saliency(aff,ind)
# read image