def load_chosen_path(self):
path = []
all_msg_tree_view = self._view.all_msg_scrolled_win.get_child()
focus_segment = all_msg_tree_view.get_selection()
model, _iter = focus_segment.get_selected()
depth = model.iter_depth(_iter)
current__id = model.get_value(_iter, 0)
current_segment_lower_num = model.get_value(_iter, 1)
current_segment_upper_num = model.get_value(_iter, 2)
current_segment = FloatInterval.closed(current_segment_lower_num,
current_segment_upper_num)
path.insert(0, [current__id, current_segment])
parent_iter = _iter
for i in range(depth):
parent_iter = model.iter_parent(parent_iter)
parent_id = model.get_value(parent_iter, 0)
parent_segment_lower_num = model.get_value(parent_iter, 1)
parent_segment_upper_num = model.get_value(parent_iter, 2)
parent_segment = FloatInterval.closed(parent_segment_lower_num,
parent_segment_upper_num)
path.insert(0, [parent_id, parent_segment])
calibrate_parameter = self.load_chosen_parameter()
path.insert(0, [calibrate_parameter, None])
return path
def calculate_beta_0_interval(self, alpha=0.05, precision=5):
x_mean = self.x.mean()
delta = x_mean ** 2 / ((self.x - x_mean) ** 2).sum()
delta = math.sqrt(delta + self.x.count() ** -1)
delta = self.calculate_t_distribute().isf(alpha / 2) * delta * self.calculate_std_e()
b0 = self.calculate_Beta0()
return FloatInterval.closed(round(b0 - delta, precision), round(b0 + delta, precision))
def roleta(populacao, start, target):
#Calcula um vetor de fitness dos individuos da populacao
fitPop = []
porcFitness = []
sumFitness = 0
for individuo in populacao:
fitIndividuo = fitness(individuo, start, target)
fitPop.append(fitIndividuo)
sumFitness += fitIndividuo
#Calcula a soma total das fitness
#sumFitness = sum(fitPop)
#Calcula a porcentagem de cada fitness individual em relacao a fitness total
for fit in fitPop:
porcFitness.append(round(fit / sumFitness, 2))
# Calcula a posicao da agulha da roleta - numero entre 0 e 1 randomico
agulha = np.random.uniform(0, max(porcFitness), 1) / sumFitness
#Cria os intervalos da roleta e faz o giro
resultado = 0
a = 0
for porc in porcFitness:
b = a + porc
if float(agulha) in fInterval.closed(a, b):
break
else:
resultado += 1
a = b
return populacao[resultado]
def calculate_Var_confidence_interval_large(series, confidence_interval=0.95):
count = series.count()
var = series.var()
upper = (count - 1) * var
rv = chi2(count - 1)
alpha = 1 - confidence_interval
return FloatInterval.closed(round(upper / rv.isf(alpha / 2), 2), round(upper / rv.isf(1 - alpha / 2), 2))
def update_calibrate_parameter_interval_combobox(self, widget):
self.clear_factors_scrolled_win()
self.calibrate_parameter_interval_choose_combobox.clear()
last_segment = self._presenter.load_last_dependency_segment()
default_segment = FloatInterval.closed(2020, 2020)
if last_segment == default_segment:
self.clear_calibrate_parameter_interval_combobox()
else:
try:
parameter_segments = self._presenter.get_calibrate_parameter_segments()
except ValueError:
dialog = Gtk.MessageDialog(parent=self.main_window, flags=0, message_type=Gtk.MessageType.INFO,
buttons=Gtk.ButtonsType.OK, text="提示")
dialog.format_secondary_text("请先选择好各个依赖分段")
dialog.run()
dialog.destroy()
else:
self._parameter_segments = parameter_segments
interval_model = Gtk.ListStore(int, str)
interval_model.append([2020, '--请先选择校正参数区间--'])
count = 0
for segment in parameter_segments:
interval = segment[0]
lower_num = interval.lower
upper_num = interval.upper
interval_model.append([count, '[{}, {}]'.format(lower_num, upper_num)])
count += 1
self.calibrate_parameter_interval_choose_combobox.set_model(interval_model)
cell = Gtk.CellRendererText()
self.calibrate_parameter_interval_choose_combobox.pack_start(cell, True)
self.calibrate_parameter_interval_choose_combobox.add_attribute(cell, 'text', 1)
self.calibrate_parameter_interval_choose_combobox.set_active(0)
def calculate_mean_confidence_interval_large(series, confidence_interval=0.90):
mean = series.mean()
s = math.sqrt(series.var())
count = series.count()
z = norm.isf((1 - confidence_interval) / 2)
delta = round(z * (s / math.sqrt(count)), 1)
return FloatInterval.closed(mean - delta, mean + delta)
def link_parameter_nodes_factors(self, repeat_read):
all_factors = self._current_calibrate_msg[6]
for node in self._parameter_nodes:
for segment in node.parameter_segments:
left_num = segment[0][0]
right_num = segment[0][1]
if not repeat_read:
interval = FloatInterval.closed(left_num, right_num)
else:
try:
interval = FloatInterval.closed(left_num, right_num)
except RangeBoundsException:
interval = FloatInterval.closed(left_num, left_num + 2)
segment[0] = interval
transfer_num = segment[1]
factors = all_factors[transfer_num]
segment[1] = factors
def calculate_mean_confidence_interval_small(series, confidence_interval=0.95):
mean = series.mean()
s = math.sqrt(series.var())
count = series.count()
rv = t(count - 1)
z = rv.isf((1 - confidence_interval) / 2)
delta = round(z * (s / math.sqrt(count)), 2)
return FloatInterval.closed(mean - delta, mean + delta)
def calculate_prediction_interval(self, x, alpha=0.05, precision=5):
x_mean = self.x.mean()
n = self.x.count()
delta = (x - x_mean) ** 2 / ((self.x - x_mean) ** 2).sum()
delta = math.sqrt(1 + delta + n ** -1)
delta = self.calculate_t_distribute().isf(alpha / 2) * delta * self.calculate_std_e()
y = x * self.calculate_Beta1() + self.calculate_Beta0()
return FloatInterval.closed(round(y - delta, precision), round(y + delta, precision))
def show_two_curves_in_senior(self):
_id, lower_num, upper_num = self.load_chosen_segment()
current_interval = FloatInterval.closed(lower_num, upper_num)
current_factors_str = self.load_chosen_factors()
current_factors = eval(current_factors_str)
modified_factors = self.load_factors_entry()
modified_segment = [current_interval, modified_factors]
current_segment = [current_interval, current_factors]
self._editor.show_two_factors_curve(modified_segment, current_segment)
def load_current_entry(self):
interval_list = []
for entry in self._view.entries:
num = float(entry.get_text())
interval_list.append(num)
lower_num = interval_list[0]
upper_num = interval_list[1]
interval = FloatInterval.closed(lower_num, upper_num)
return interval
def create_dependency_node(segment, dependency_id):
dependency_node = entity.CalibrateFile.CalibrateDependencyNode()
segment_upper = segment[0][1]
segment_lower = segment[0][0]
transfer_num = segment[1]
dependency_node.parameter_id = dependency_id
dependency_node.transfer_num = transfer_num
dependency_node.parameter_segment = FloatInterval.closed(
segment_lower, segment_upper)
return dependency_node
def add_depend_segment_node(self,
parent_node,
child_id,
segment=FloatInterval.closed(
float('-inf'), float('inf'))):
# 当父节点在分支中的位置不是参数节点的前一级时，需考虑添加多级的分段
child_node = CalibrateDependencyNode()
child_node.parameter_segment = segment
child_node.parameter_id = child_id
child_node.parent = parent_node
self._child_node = child_node
def modify_depend_segment(lower_num, upper_num, depend_node):
if not isinstance(depend_node, CalibrateDependencyNode):
raise TypeError
check_lower = isinstance(lower_num, int) or isinstance(
lower_num, float)
check_upper = isinstance(upper_num, int) or isinstance(
upper_num, float)
if not check_upper and not check_lower:
raise ValueError('upper bound or lower bound type error')
new_segment = FloatInterval.closed(lower_num, upper_num)
depend_node.parameter_segment = new_segment
def add_depend_behind(self, depend_in, new_dependency):
for node in self._root_node.descendants:
if depend_in == node.parameter_id:
children_nodes = node.children
node.children = []
depend_node = CalibrateDependencyNode()
depend_node.parameter_id = new_dependency
default_segment = FloatInterval.closed(float('-inf'),
float('inf'))
depend_node.parameter_segment = default_segment
depend_node.parent = node
depend_node.children = children_nodes
def link_dependency_roots(root_node, entry_dependency):
for segment in entry_dependency[1]:
dependency_segment_node = entity.CalibrateFile.CalibrateDependencyNode(
)
parameter_id = entry_dependency[0]
dependency_segment_node.parameter_id = parameter_id
segment_upper = segment[0][1]
segment_lower = segment[0][0]
transfer_num = segment[1]
interval = FloatInterval.closed(segment_lower, segment_upper)
dependency_segment_node.parameter_segment = interval
dependency_segment_node.transfer_num = transfer_num
dependency_segment_node.parent = root_node
def modify_factors_in_senior(self):
path = self.load_chosen_path()
path = path[:-1]
calibrate_parameter_id, lower_num, upper_num = self.load_chosen_segment(
)
current_factors_str = self.load_chosen_factors()
current_factors = eval(current_factors_str)
current_interval = FloatInterval.closed(lower_num, upper_num)
segment = [current_interval, current_factors]
modified_factors = self.load_factors_entry()
self._editor.modify_parameter_factors_in_senior(
self._channel, calibrate_parameter_id, path, segment,
modified_factors)
def add_depend_before(self, depend_in, new_dependency):
parent_nodes = []
for node in self._root_node.descendants:
if depend_in == node.parameter_id:
parent_node = node.parent
if parent_node not in parent_nodes:
parent_nodes.append(parent_node)
for node_p in parent_nodes:
parent_children = list(node_p.children)
node_p.children = []
depend_node = CalibrateDependencyNode()
depend_node.parameter_id = new_dependency
default_segment = FloatInterval.closed(float('-inf'), float('inf'))
depend_node.parameter_segment = default_segment
depend_node.parent = node_p
depend_node.children = parent_children
def update_next_depend_segment(self, widget):
self.clear_calibrate_parameter_interval_combobox()
self.clear_factors_scrolled_win()
viewport = self.dependencies_segment_choose_scrolled_win.get_child()
main_box = viewport.get_child()
boxes = main_box.get_children()
focus_depend_id, focus_segment = self._presenter.load_focus_depend()
default_segment = FloatInterval.closed(2020, 2020)
focus_depend_id_index = self._depends_id.index(focus_depend_id)
if focus_depend_id_index+1 < len(self._depends_id):
next_parameter_id = self._depends_id[focus_depend_id_index+1]
next_model = Gtk.ListStore(str, str)
if focus_segment != default_segment:
depend_path = self._presenter.load_depend_path(focus_depend_id)
next_segments = self._presenter.get_depend_segments(depend_path, next_parameter_id)
next_model.append(['[2020, 2020]', '--请先选择依赖区间--'])
for segment in next_segments:
lower_num = segment.lower
upper_num = segment.upper
next_model.append(['[{}, {}]'.format(lower_num, upper_num), '[{}, {}]'.format(lower_num, upper_num)])
next_box = boxes[focus_depend_id_index+1]
next_label = next_box.get_children()[0]
next_depend_id = int(next_label.get_text())
next_combobox = next_box.get_children()[1]
next_combobox.clear()
next_combobox.set_model(next_model)
current_cell = Gtk.CellRendererText()
next_combobox.pack_start(current_cell, True)
next_combobox.add_attribute(current_cell, 'text', 1)
# next_combobox.set_active(0) # 这里的set_active又会跳回去，陷入无限循环，有毒..
if self._is_update_all_dependencies_segment_choose:
if next_depend_id == self._depends_id[-1]:
next_combobox.connect('changed', self.update_calibrate_parameter_interval_combobox)
self._is_update_all_dependencies_segment_choose = False
else:
next_combobox.connect('changed', self.update_next_depend_segment)
else:
for box in boxes[focus_depend_id_index+1:]:
combobox = box.get_children()[1]
combobox.clear()
empty_model = Gtk.ListStore()
combobox.set_model(empty_model)
def calculate_beta_1_interval(self, alpha=0.05, precision=5):
delta = math.sqrt(((self.x - self.x.mean()) ** 2).sum())
delta = self.calculate_std_e() / delta
delta = self.calculate_t_distribute().isf(alpha / 2) * delta
b1 = self.calculate_Beta1()
return FloatInterval.closed(round(b1 - delta, precision), round(b1 + delta, precision))
def calculate_percent_confidence_interval_large(p, n, confidence_interval=0.95):
z = norm.isf((1 - confidence_interval) / 2)
delta = round(z * math.sqrt(((p * (1 - p)) / n)), 4)
return FloatInterval.closed(p - delta, p + delta)
def test_interval(self):
self.assertEqual(FloatInterval.closed(4.1317,6.13001), self.target.calculate_beta_1_interval())
self.assertEqual(FloatInterval.closed(-4.9130, 554.01347), self.target.calculate_beta_0_interval())
self.assertEqual(FloatInterval.closed(260.13241, 750.745), self.target.calculate_confidence_interval(45))
self.assertEqual(FloatInterval.closed(-293.41195,1304.28935), self.target.calculate_prediction_interval(45))
def testCalculateMeanConfidenceIntervalSmall(self):
data = pandas.read_excel('mean_smaller.xlsx').age
expected = FloatInterval.closed(1476.8, 1503.2)
self.assertEqual(expected, sampler.calculate_mean_confidence_interval_small(data))
def testCalculatePercentageConfidenceIntervalLarge(self):
expected = FloatInterval.closed(0.5565, 0.7435)
self.assertEqual(expected, sampler.calculate_percent_confidence_interval_large(0.65,100))
def testCalculateMeanConfidenceIntervalLarge(self):
data = pandas.read_excel('mean_large.xlsx').age
expected = FloatInterval.closed(37.3689326757, 41.6310673243)
self.assertEqual(expected, sampler.calculate_mean_confidence_interval_large(data))
def testCalculatePercentageConfidenceIntervalLarge(self):
data = pandas.read_excel('var_test.xlsx').weight
expected = FloatInterval.closed(56.83, 180.39)
self.assertEqual(expected, sampler.calculate_Var_confidence_interval_large(data))
