def main(): """ Main functiont to lunch the belief propagation algorithm """ M = model() M.check_model() #Belief propagation bp = BeliefPropagation(M) bp.calibrate() print("maximal cliques are:") print(bp.get_cliques()) # first query print("computing probability of B=") query1 = bp.query(variables=list('b'), show_progress=True) print(query1) #second query print("computing probability of B|C") query2 = bp.query(variables=['b', 'c']) query2.marginalize(['c']) print(query2) #Third query print("computing joint") query3 = bp.query(['a', 'b', 'c', 'd', 'e']) query3.normalize() print(query3)
def belief_propagation(evidence: dict, bn: BayesianNetwork): """ evidence: {node: evidence_value, ...} bn : our own bayesian network class """ network = convert2pgm(bn) net_infer = BeliefPropagation(network) to_infer = list(set(network.nodes()) - set(evidence.keys())) prior = {} prior_dist = net_infer.query(variables=to_infer, evidence={}, joint=False) for factor in prior_dist.values(): node = factor.variables[0] values = factor.values.tolist() prior[factor.variables[0]] = pd.DataFrame({ node: [0, 1], "prob": values }) post = {} post_dist = net_infer.query(variables=to_infer, evidence=evidence, joint=False) for factor in post_dist.values(): node = factor.variables[0] values = factor.values.tolist() post[factor.variables[0]] = pd.DataFrame({ node: [0, 1], "prob": values }) return prior, post
def test_query_multiple_variable(self): belief_propagation = BeliefPropagation(self.bayesian_model) query_result = belief_propagation.query(['Q', 'J']) np_test.assert_array_almost_equal(query_result['J'].values, np.array([0.416, 0.584])) np_test.assert_array_almost_equal(query_result['Q'].values, np.array([0.4912, 0.5088]))
def test_query_multiple_variable_with_evidence(self): belief_propagation = BeliefPropagation(self.bayesian_model) query_result = belief_propagation.query(variables=['J', 'Q'], evidence={'A': 0, 'R': 0, 'G': 0, 'L': 1}) np_test.assert_array_almost_equal(query_result['J'].values, np.array([0.818182, 0.181818])) np_test.assert_array_almost_equal(query_result['Q'].values, np.array([0.772727, 0.227273]))
def test_query_single_variable(self): belief_propagation = BeliefPropagation(self.bayesian_model) query_result = belief_propagation.query(["J"]) self.assertEqual( query_result, DiscreteFactor(variables=["J"], cardinality=[2], values=[0.416, 0.584]), )
def test_query_single_variable_with_evidence(self): belief_propagation = BeliefPropagation(self.bayesian_model) query_result = belief_propagation.query(variables=['J'], evidence={ 'A': 0, 'R': 1 }) np_test.assert_array_almost_equal(query_result['J'].values, np.array([0.60, 0.40]))
def test_query_multiple_variable(self): belief_propagation = BeliefPropagation(self.bayesian_model) query_result = belief_propagation.query(["Q", "J"]) self.assertEqual( query_result, DiscreteFactor( variables=["J", "Q"], cardinality=[2, 2], values=np.array([[0.3744, 0.0416], [0.1168, 0.4672]]), ), )
def test_query_single_variable_with_evidence(self): belief_propagation = BeliefPropagation(self.bayesian_model) query_result = belief_propagation.query(variables=["J"], evidence={ "A": 0, "R": 1 }) self.assertEqual( query_result, DiscreteFactor(variables=["J"], cardinality=[2], values=np.array([0.072, 0.048])), )
def test_query_multiple_variable_with_evidence(self): belief_propagation = BeliefPropagation(self.bayesian_model) query_result = belief_propagation.query(variables=['J', 'Q'], evidence={ 'A': 0, 'R': 0, 'G': 0, 'L': 1 }) np_test.assert_array_almost_equal(query_result['J'].values, np.array([0.818182, 0.181818])) np_test.assert_array_almost_equal(query_result['Q'].values, np.array([0.772727, 0.227273]))
def test_query_multiple_variable_with_evidence(self): belief_propagation = BeliefPropagation(self.bayesian_model) query_result = belief_propagation.query(variables=["J", "Q"], evidence={ "A": 0, "R": 0, "G": 0, "L": 1 }) self.assertEqual( query_result, DiscreteFactor( variables=["J", "Q"], cardinality=[2, 2], values=np.array([[0.003888, 0.000432], [0.000192, 0.000768]]), ), )
def step(self, adjustment, episode): print('######## Ajustes ########') print(adjustment) print('######## Episódio atual ########') print(episode) bp = BeliefPropagation(self.model) replaced_episode = {k: replacer[k][v] for k, v in episode.iteritems()} upper_bound = self.state[0] + adjustment lower_bound = self.state[1] - adjustment if not (upper_bound > 1 or upper_bound < 0): state_aware = [upper_bound, lower_bound] cpds = self._tabular_cpds_to_dict(self.model) adjustments = self.fit_probabilities(cpds, adjustment) for node in self.model.get_cpds(): if node.variable != 'Consciente': node.values = self._get_cpd_values( adjustments[node.variable]) node.normalize() else: node.values = np.array(state_aware) for node in self.model.get_cpds(): print(node) else: state_aware = [self.state] print('######## Consciente ########') bp = BeliefPropagation(self.model) print( bp.query(['Consciente'], evidence=replaced_episode)['Consciente']) reward = float(input('Recompensa entre -1 e 1: ')) next_state = [] next_state.append(np.round(state_aware, 2)) next_state.extend(list(replaced_episode.values())) return next_state, reward
def _get_ev(self, dec_instantiation: Tuple[int], row: int, bp: BeliefPropagation) -> float: """Return the expected value of a certain decision node instantiation for the agent making the decision""" macid = self.copy_without_cpds() dec_list = macid.get_valid_acyclic_dec_node_ordering() dec = dec_list[row] agent = self.whose_node[dec] # gets the agent making that decision utils = self.utility_nodes_agent[ agent] # gets the utility nodes for that agent factor = bp.query(variables=utils, evidence=dict(zip(dec_list, dec_instantiation))) ev = 0 for idx, prob in np.ndenumerate(factor.values): for i in range( len(utils) ): # account for each agent having multiple utilty nodes if prob != 0: ev += prob * idx[i] return ev
values=[[0.01], [0.99]]) cpd_do = TabularCPD(variable='dog_out', variable_card=2, values=[[0.99, 0.9, 0.97, 0.3], [0.01, 0.1, 0.03, 0.7]], evidence=['family_out', 'bowel_problem'], evidence_card=[2, 2]) cpd_lo = TabularCPD(variable='light_on', variable_card=2, values=[[0.6, 0.05], [0.4, 0.95]], evidence=['family_out'], evidence_card=[2]) cpd_hb = TabularCPD(variable='hear_bark', variable_card=2, values=[[0.7, 0.01], [0.3, 0.99]], evidence=['dog_out'], evidence_card=[2]) #integrity checking model.add_cpds(cpd_fo, cpd_bp, cpd_do, cpd_lo, cpd_hb) model.check_model() junction_tree = model.to_junction_tree() print(junction_tree.nodes()) infer_bp = BeliefPropagation(junction_tree) print( infer_bp.query(['family_out'], evidence={ 'light_on': 0, 'hear_bark': 1 })['family_out'])
def compute_pk(self, type_list, fid): assert len(type_list) == 5, print("ComputePk Error: number of type_list should be 5") constraint_name = ['m', 'r', 's', 'd', 'v'] ''' m, r, s, d, v = type_list p_m, p_r, p_s, p_d, p_v = self.p_observation p_ktox, p_xtok = self.p_implication p_ktom, p_ktor, p_ktos, p_ktod, p_ktov = p_ktox p_mtok, p_rtok, p_stok, p_dtok, p_vtok = p_xtok ''' fg = FactorGraph() fg.add_node('k') for i in range(len(type_list)): if type_list[i] == 0: fg = self.add_constraints_k2x_x2k(fg, self.p_observation[fid][i], self.p_implication[fid][0][i], self.p_implication[fid][1][i], constraint_name[i]) elif type_list[i] == 1: fg = self.add_constraints_k2x(fg, self.p_observation[fid][i], self.p_implication[fid][0][i], constraint_name[i]) elif type_list[i] == 2: fg = self.add_constraints_x2k(fg, self.p_observation[fid][i], self.p_implication[fid][1][i], constraint_name[i]) ''' if m == 0: fg = add_constraints_kv_vk(fg, p_m, p_ktom, p_mtok, 'm') elif m == 1: fg = add_constraints_kv(fg, p_m, p_mtok, 'm') elif m == 2: fg = add_constraints_vk(fg, p_m, p_mtok, 'm') if r == 0: fg = add_constraints_kv_vk(fg, p_r, p_ktor, p_rtok, 'r') elif r == 1: fg = add_constraints_kv(fg, p_r, p_ktor, 'r') elif r == 2: fg = add_constraints_vk(fg, p_r, p_rtok, 'r') if s == 0: fg = add_constraints_kv_vk(fg, p_s, p_ktos, p_stok, 's') elif s == 1: fg = add_constraints_kv(fg, p_s, p_ktos, 's') elif s == 2: fg = add_constraints_vk(fg, p_s, p_stok, 's') if d == 0: fg = add_constraints_kv_vk(fg, p_d, p_ktod, p_dtok, 'd') elif d == 1: fg = add_constraints_kv(fg, p_d, p_ktod, 'd') elif d == 2: fg = add_constraints_vk(fg, p_d, p_dtok, 'd') if v == 0: fg = add_constraints_kv_vk(fg, p_v, p_ktov, p_vtok, 'v') elif v == 1: fg = add_constraints_kv(fg, p_v, p_ktov, 'v') elif v == 2: fg = add_constraints_vk(fg, p_v, p_vtok, 'v') ''' bp = BeliefPropagation(fg) #result = bp.query(variables=['k'])['k'] #result = bp.query(variables=['k'], joint=False)['k'] result = bp.query(variables=['k']) result.normalize() #print(result) return result.values[1]
PGM.add_edges_from([('w1', 'w2'), ('w2', 'w3')]) tr_matrix = np.array([1, 10, 3, 2, 1, 5, 3, 3, 2]) tr_matrix = np.array([1, 2, 3, 10, 1, 3, 3, 5, 2]).reshape(3, 3).T.reshape(-1) phi = [DiscreteFactor(edge, [3, 3], tr_matrix) for edge in PGM.edges()] print(phi[0]) print(phi[1]) PGM.add_factors(*phi) # Calculate partition funtion Z = PGM.get_partition_function() print('The partition function is:', Z) # Calibrate the click belief_propagation = BeliefPropagation(PGM) belief_propagation.calibrate() # Output calibration result, which you should get query = belief_propagation.query(variables=['w2']) print('After calibration you should get the following mu(S):\n', query * Z) # Get marginal distribution over third word query = belief_propagation.query(variables=['w3']) print('Marginal distribution over the third word is:\n', query) #Get conditional distribution over third word query = belief_propagation.query(variables=['w3'], evidence={'w1': 0}) # 0 stays for "noun" print( 'Conditional distribution over the third word, given that the first word is noun is:\n', query)
def backward_inference(self, variables, evidence=None): """ Backward inference method using belief propagation. Parameters: ---------- variables: list list of variables for which you want to compute the probability evidence: dict a dict key, value pair as {var: state_of_var_observed} None if no evidence Examples: -------- >>> from pgmpy.factors import TabularCPD >>> from pgmpy.models import DynamicBayesianNetwork as DBN >>> from pgmpy.inference import DBNInference >>> dbnet = DBN() >>> dbnet.add_edges_from([(('Z', 0), ('X', 0)), (('X', 0), ('Y', 0)), ... (('Z', 0), ('Z', 1))]) >>> z_start_cpd = TabularCPD(('Z', 0), 2, [[0.5, 0.5]]) >>> x_i_cpd = TabularCPD(('X', 0), 2, [[0.6, 0.9], ... [0.4, 0.1]], ... evidence=[('Z', 0)], ... evidence_card=2) >>> y_i_cpd = TabularCPD(('Y', 0), 2, [[0.2, 0.3], ... [0.8, 0.7]], ... evidence=[('X', 0)], ... evidence_card=2) >>> z_trans_cpd = TabularCPD(('Z', 1), 2, [[0.4, 0.7], ... [0.6, 0.3]], ... evidence=[('Z', 0)], ... evidence_card=2) >>> dbnet.add_cpds(z_start_cpd, z_trans_cpd, x_i_cpd, y_i_cpd) >>> dbnet.initialize_initial_state() >>> dbn_inf = DBNInference(dbnet) >>> dbn_inf.backward_inference([('X', 0)], {('Y', 0):0, ('Y', 1):1, ('Y', 2):1})[('X', 0)].values array([ 0.66594382, 0.33405618]) """ variable_dict = defaultdict(list) for var in variables: variable_dict[var[1]].append(var) time_range = max(variable_dict) interface_nodes_dict = {} if evidence: evid_time_range = max([time_slice for var, time_slice in evidence.keys()]) time_range = max(time_range, evid_time_range) end_bp = BeliefPropagation(self.start_junction_tree) potential_dict = self.forward_inference(variables, evidence, 'potential') update_factor = self._shift_factor(potential_dict[time_range], 1) factor_values = {} for time_slice in range(time_range, 0, -1): evidence_time = self._get_evidence(evidence, time_slice, 1) evidence_prev_time = self._get_evidence(evidence, time_slice - 1, 0) if evidence_prev_time: interface_nodes_dict = {k: v for k, v in evidence_prev_time.items() if k in self.interface_nodes_0} if evidence_time: evidence_time.update(interface_nodes_dict) mid_bp = BeliefPropagation(self.one_and_half_junction_tree) self._update_belief(mid_bp, self.in_clique, potential_dict[time_slice - 1]) forward_factor = self._shift_factor(potential_dict[time_slice], 1) self._update_belief(mid_bp, self.out_clique, forward_factor, update_factor) if variable_dict[time_slice]: variable_time = self._shift_nodes(variable_dict[time_slice], 1) new_values = mid_bp.query(variable_time, evidence=evidence_time) changed_values = {} for key in new_values.keys(): new_key = (key[0], time_slice) new_factor = Factor([new_key], new_values[key].cardinality, new_values[key].values) changed_values[new_key] = new_factor factor_values.update(changed_values) clique_phi = self._get_factor(mid_bp, evidence_time) in_clique_phi = self._marginalize_factor(self.interface_nodes_0, clique_phi) update_factor = self._shift_factor(in_clique_phi, 1) out_clique_phi = self._shift_factor(update_factor, 0) self._update_belief(end_bp, self.start_interface_clique, potential_dict[0], out_clique_phi) evidence_0 = self._get_evidence(evidence, 0, 0) if variable_dict[0]: factor_values.update(end_bp.query(variable_dict[0], evidence_0)) return factor_values
#------------------Calculate inference using Mplp algorithm-------------------- mplp = Mplp(mark) mplp.find_triangles() mplp.map_query() #infer1 = BayesianModelSampling(mark) #evidence1 = [State('y',1)] #sample1 = infer1.forward_sample(5) #sample1 #---------Calculate inference using Belief Propagation and Variable Elimination and answer corresponding queries------------- belief_prop = BeliefPropagation(mark) bp1 = belief_prop.query(variables=['y'], evidence={'marital': 2, 'default': 0}) print(bp1['y']) infer = VariableElimination(mark) phi_query = infer.query(variables=['y'], evidence={'marital': 0, 'default': 0}) print(bp1['y']) bp2 = belief_prop.query(variables=['y'], evidence={ 'education': 2, 'housing': 1 }) print(bp2['y']) infer = VariableElimination(mark) phi_query = infer.query(variables=['y'],
columns=['A', 'B', 'C', 'D', 'E']) print(values) model = BayesianModel([('A', 'B'), ('C', 'B'), ('C', 'D'), ('B', 'E')]) model.fit(values) ve = VariableElimination(model) bp = BeliefPropagation(model) start = time.time() ve_result = ve.query(['B'], evidence={'A': 0}) #, 'B']) end = time.time() print(ve_result['B']) print("time: {}".format(end - start)) start = time.time() bp_result = bp.query(['B'], evidence={'A': 0}) ''' if 'B' in bp_result: if 'B_0' in bp_result['B']: print("yes") else: print("no") ''' print(bp_result['B'].variables) print(bp_result['B'].values) '''for key, value in bp_result.items(): print value.keys()[0] ''' ''' end = time.time()
def test_query_single_variable_with_evidence(self): belief_propagation = BeliefPropagation(self.bayesian_model) query_result = belief_propagation.query(variables=['J'], evidence={'A': 0, 'R': 1}) np_test.assert_array_almost_equal(query_result['J'].values, np.array([0.60, 0.40]))
train = data[1:600] x = Mental_health_model.fit(train, estimator=MaximumLikelihoodEstimator) #for cpd in Mental_health_model.get_cpds(): # print(cpd) # In[2]: # In[3]: belief_prop = BeliefPropagation(Mental_health_model) # In[5]: bp1 = belief_prop.query(variables=['leave', 'wellness_program'], evidence={'tech_company': 0}) print(bp1['leave']) print(bp1['wellness_program']) # In[6]: bp2 = belief_prop.query(variables=['treatment'], evidence={ 'Age': 1, 'Gender': 0, 'family_history': 1 }) print(bp2['treatment']) # In[7]:
def markov_inference(dict_of_esp_jointprob): """Calculate the markov model """ factor_mmb_cmma = Factor(variables=['money_market_bonus', 'collateral_mma'], cardinality=[2, 2], values=[dict_of_esp_jointprob['mmb0_cmma0'], dict_of_esp_jointprob['mmb0_cmma1'], dict_of_esp_jointprob['mmb1_cmma0'], dict_of_esp_jointprob['mmb1_cmma1']]) factor_mmb_cm = Factor(variables=['money_market_bonus', 'cash_management'], cardinality=[2, 2], values=[dict_of_esp_jointprob['mmb0_cm0'], dict_of_esp_jointprob['mmb0_cm1'], dict_of_esp_jointprob['mmb1_cm0'], dict_of_esp_jointprob['mmb1_cm1']]) factor_mmb_fx = Factor(variables=['money_market_bonus', 'fx_products'], cardinality=[2, 2], values=[dict_of_esp_jointprob['mmb0_fx0'], dict_of_esp_jointprob['mmb0_fx1'], dict_of_esp_jointprob['mmb1_fx0'], dict_of_esp_jointprob['mmb1_fx1']]) factor_mmb_loc = Factor(variables=['money_market_bonus', 'letters_of_credit'], cardinality=[2, 2], values=[dict_of_esp_jointprob['mmb0_loc0'], dict_of_esp_jointprob['mmb0_loc1'], dict_of_esp_jointprob['mmb1_loc0'], dict_of_esp_jointprob['mmb1_loc1']]) factor_mmb_es = Factor(variables=['money_market_bonus', 'enterprise_sweep'], cardinality=[2, 2], values=[dict_of_esp_jointprob['mmb0_es0'], dict_of_esp_jointprob['mmb0_es1'], dict_of_esp_jointprob['mmb1_es0'], dict_of_esp_jointprob['mmb1_es1']]) factor_mmb_checking = Factor(variables=['money_market_bonus', 'checking_usd'], cardinality=[2, 2], values=[dict_of_esp_jointprob['mmb0_checking0'], dict_of_esp_jointprob['mmb0_checking1'], dict_of_esp_jointprob['mmb1_checking0'], dict_of_esp_jointprob['mmb1_checking1']]) # collateral mma factor_cmma_cm = Factor(variables=['collateral_mma','cash_management'], cardinality=[2, 2], values=[dict_of_esp_jointprob['cmma0_cm0'], dict_of_esp_jointprob['cmma0_cm1'], dict_of_esp_jointprob['cmma1_cm0'], dict_of_esp_jointprob['cmma1_cm1']]) factor_cmma_fx = Factor(variables=['collateral_mma', 'fx_products'], cardinality=[2, 2], values=[dict_of_esp_jointprob['cmma0_fx0'], dict_of_esp_jointprob['cmma0_fx1'], dict_of_esp_jointprob['cmma1_fx0'], dict_of_esp_jointprob['cmma1_fx1']]) factor_cmma_loc = Factor(variables=['collateral_mma', 'letters_of_credit'], cardinality=[2, 2], values=[dict_of_esp_jointprob['cmma0_loc0'], dict_of_esp_jointprob['cmma0_loc1'], dict_of_esp_jointprob['cmma1_loc0'], dict_of_esp_jointprob['cmma1_loc1']]) factor_cmma_es= Factor(variables=['collateral_mma', 'enterprise_sweep'], cardinality=[2, 2], values=[dict_of_esp_jointprob['cmma0_es0'], dict_of_esp_jointprob['cmma0_es1'], dict_of_esp_jointprob['cmma1_es0'], dict_of_esp_jointprob['cmma1_es1']]) factor_cmma_checking = Factor(variables=['collateral_mma', 'checking_usd'], cardinality=[2, 2], values=[dict_of_esp_jointprob['cmma0_checking0'], dict_of_esp_jointprob['cmma0_checking1'], dict_of_esp_jointprob['cmma1_checking0'],dict_of_esp_jointprob['cmma1_checking1']]) # cash management factor_cm_fx = Factor(variables=['cash_management', 'fx_products'], cardinality=[2, 2], values=[dict_of_esp_jointprob['cm0_fx0'], dict_of_esp_jointprob['cm0_fx1'], dict_of_esp_jointprob['cm1_fx0'], dict_of_esp_jointprob['cm1_fx1']]) factor_cm_loc = Factor(variables=['cash_management', 'letters_of_credit'], cardinality=[2, 2], values=[dict_of_esp_jointprob['cm0_loc0'], dict_of_esp_jointprob['cm0_loc1'], dict_of_esp_jointprob['cm1_loc0'], dict_of_esp_jointprob['cm1_loc1']]) factor_cm_es= Factor(variables=['cash_management', 'enterprise_sweep'], cardinality=[2, 2], values=[dict_of_esp_jointprob['cm0_es0'], dict_of_esp_jointprob['cm0_es1'], dict_of_esp_jointprob['cm1_es0'], dict_of_esp_jointprob['cm1_es1']]) factor_cm_checking = Factor(variables=['cash_management', 'checking_usd'], cardinality=[2, 2], values=[dict_of_esp_jointprob['cm0_checking0'], dict_of_esp_jointprob['cm0_checking1'], dict_of_esp_jointprob['cm1_checking0'], dict_of_esp_jointprob['cm1_checking1']]) # FX products factor_fx_loc = Factor(variables=['fx_products', 'letters_of_credit'], cardinality=[2, 2], values=[dict_of_esp_jointprob['fx0_loc0'], dict_of_esp_jointprob['fx0_loc1'], dict_of_esp_jointprob['fx1_loc0'], dict_of_esp_jointprob['fx1_loc1']]) factor_fx_es= Factor(variables=['fx_products', 'enterprise_sweep'], cardinality=[2, 2], values=[dict_of_esp_jointprob['fx0_es0'], dict_of_esp_jointprob['fx0_es1'], dict_of_esp_jointprob['fx1_es0'], dict_of_esp_jointprob['fx1_es1']]) factor_fx_checking = Factor(variables=['fx_products', 'checking_usd'], cardinality=[2, 2], values=[dict_of_esp_jointprob['fx0_checking0'], dict_of_esp_jointprob['fx0_checking1'], dict_of_esp_jointprob['fx1_checking0'], dict_of_esp_jointprob['fx1_checking1']]) # letters of credit factor_loc_es= Factor(variables=['letters_of_credit', 'enterprise_sweep'], cardinality=[2, 2], values=[dict_of_esp_jointprob['loc0_es0'], dict_of_esp_jointprob['loc0_es1'], dict_of_esp_jointprob['loc1_es0'], dict_of_esp_jointprob['loc1_es1']]) factor_loc_checking = Factor(variables=['letters_of_credit', 'checking_usd'], cardinality=[2, 2], values=[dict_of_esp_jointprob['loc0_checking0'], dict_of_esp_jointprob['loc0_checking1'], dict_of_esp_jointprob['loc1_checking0'], dict_of_esp_jointprob['loc1_checking1']]) #enterprise sweep factor_es_checking = Factor(variables=['enterprise_sweep', 'checking_usd'], cardinality=[2, 2], values=[dict_of_esp_jointprob['es0_checking0'], dict_of_esp_jointprob['es0_checking1'], dict_of_esp_jointprob['es1_checking0'], dict_of_esp_jointprob['es1_checking1']]) # built the markov model model.add_factors(factor_mmb_cmma , factor_mmb_cm, factor_mmb_fx, factor_mmb_loc,factor_mmb_es, factor_mmb_checking, factor_cmma_cm , factor_cmma_fx, factor_cmma_loc, factor_cmma_es,factor_cmma_checking, factor_cm_fx, factor_cm_loc, factor_cm_es, factor_cm_checking , factor_fx_loc, factor_fx_es , factor_fx_checking, factor_loc_es, factor_loc_checking , factor_es_checking ) belief_propagation = BeliefPropagation(model) all_products = ['money_market_bonus','collateral_mma', 'cash_management','enterprise_sweep', 'fx_products','letters_of_credit','checking_usd'] # perform inference for all product except the one in the for loop for prod in all_products: if evidence_==None: new_evidence=evidence_ else: new_evidence = {key: value for key, value in evidence_.items() if key != prod} # perform belief inference on only one product at a time belief_inference_products = str(prod) # belief propogation on one product at a time given evidence from all other products belief = belief_propagation.query(variables=[belief_inference_products], evidence=new_evidence) try: #mmb = belief_mmb['money_market_bonus'].values[1] mmb = belief['money_market_bonus'].values[1] if mmb <0 : mmb = .0000001 elif mmb >1: mmb =1 prob_mmb.append(mmb)# one is having the product except: # can't perform inference on this product pass try: cmma = belief['collateral_mma'].values[1] if cmma <0: cmma = .0000001 elif cmma >1: cmma =1 prob_cmma.append(cmma) except:## don't have this product pass try: cm = belief['cash_management'].values[1] if cm <0: cm = .0000001 elif cm >1: cm =1 prob_cm.append(cm) except: pass try: checking = belief['checking_usd'].values[1] if checking <0: checking = .0000001 elif checking >1: checking =1 prob_checking.append(checking) except: pass try: fx = belief['fx_products'].values[1] if fx <0: fx = .0000001 elif fx >1: fx =1 prob_fx.append(fx) except: pass try: loc = belief['letters_of_credit'].values[1] if loc <0: loc = .0000001 elif loc > 1: loc = 1 prob_loc.append(loc) except: pass try: es = belief['enterprise_sweep'].values[1] if es<0: es = .0000001 elif es >1: es = 1 prob_es.append(es) except: pass
def plot_causal_influence(self, file_path): """ Computes the odds of the target variable being value 1 over value 0 (i.e. the odds ratio) by iterating through all other network variables/nodes, changing their values, and observing how the probability of the target variable changes. Belief propagation is used for inference. A forest plot is produced from this and saved to disk. Arguments: file_path: str, the absolute path to save the file to (e.g. "~/Desktop/forest_plot.png") Returns: None """ # Estimate CPTs self._estimate_CPT() if self.verbose: print(f"Calculating influence of all nodes on target node") if not self.bn_model.check_model(): print(""" There is a problem with your network structure. You have disconnected nodes or separated sub-networks. Please examine your network plot and re-learn your network structure with tweaked settings. """) return None if self.target_variable not in self.bn_model.nodes: print(""" Your target variable has no parent nodes! Can't perform inference! Please examine your network plot and re-learn your network structure with tweaked settings. """) return None # Prep for belief propagation belief_propagation = BeliefPropagation(self.bn_model) belief_propagation.calibrate() # Iterate over all intervention nodes and values, calculating odds ratios w.r.t target variable overall_dict = {} variables_to_test = list( set(list(self.bn_model.nodes)) - set(list(self.target_variable))) for node in variables_to_test: results = [] for value in self.filtered_df[node].unique(): prob = belief_propagation.query( variables=[self.target_variable], evidence={ node: value }, show_progress=False, ).values results.append([node, value, prob[0], prob[1]]) results_df = pd.DataFrame( results, columns=["node", "value", "probability_0", "probability_1"]) results_df["odds_1"] = (results_df["probability_1"] / results_df["probability_0"]) results_df = results_df.sort_values( "value", ascending=True, inplace=False).reset_index(drop=True) overall_dict[node] = results_df final_df_list = [] for node, temp_df in overall_dict.items(): first_value = temp_df["odds_1"].iloc[0] temp_df["odds_ratio"] = (temp_df["odds_1"] / first_value).round(3) final_df_list.append(temp_df) final_df = pd.concat(final_df_list)[["node", "value", "odds_ratio"]] self.odds_ratios = final_df if self.verbose: print(f"Saving forest plot to the following PNG file: {file_path}") # Clean up the dataframe of odds ratios so plot can have nice labels final_df2 = (pd.concat([ final_df, final_df.groupby("node")["value"].apply( lambda x: x.shift(-1).iloc[-1]).reset_index(), ]).sort_values(by=["node", "value"], ascending=True).reset_index(drop=True)) final_df2["node"][final_df2["value"].isnull()] = np.nan final_df2["value"] = final_df2["value"].astype("Int32").astype(str) final_df2["value"].replace({np.nan: ""}, inplace=True) final_df3 = final_df2.reset_index(drop=True).reset_index() final_df3.rename(columns={"index": "vertical_index"}, inplace=True) final_df3["y_label"] = final_df3["node"] + " = " + final_df3["value"] final_df3["y_label"][final_df3["odds_ratio"] == 1.0] = ( final_df3["y_label"] + " (ref)") final_df3["y_label"].fillna("", inplace=True) # Produce large plot plt.clf() plt.title( "Strength of Associations Between Interventions and Target Variable" ) plt.scatter( x=final_df3["odds_ratio"], y=final_df3["vertical_index"], s=70, color="b", alpha=0.5, ) plt.xlabel("Odds Ratio") plt.axvline(x=1.0, color="red", linewidth="1.5", linestyle="--") plt.yticks(final_df3["vertical_index"], final_df3["y_label"]) for _, row in final_df3.iterrows(): if not np.isnan(row["odds_ratio"]): plt.plot( [0, row["odds_ratio"]], [row["vertical_index"], row["vertical_index"]], color="black", linewidth="0.4", ) plt.xlim([0, final_df3["odds_ratio"].max() + 1]) figure = plt.gcf() figure.set_size_inches(12, 7) plt.savefig(expanduser(file_path), bbox_inches="tight", format="PNG", dpi=300)
PGM.add_nodes_from(['w1', 'w2', 'w3']) PGM.add_edges_from([('w1', 'w2'), ('w2', 'w3')]) tr_matrix = np.array([1, 2, 3, 10, 1, 3, 3, 5, 2]).reshape(3, 3).T.reshape(-1) phi = [DiscreteFactor(edge, [3, 3], tr_matrix) for edge in PGM.edges()] PGM.add_factors(*phi) # Calculate partition funtion Z = PGM.get_partition_function() print('The partition function is:', Z) # Calibrate the click belief_propagation = BeliefPropagation(PGM) belief_propagation.calibrate() # Output calibration result, which you should get query = belief_propagation.query(variables=["w2"], joint=False) print('After calibration you should get the following mu(S):', query["w2"] * Z) # Get marginal distribution over third word query = belief_propagation.query(variables=['w3'], joint=False) #, evidence = {'w2':0}) print('Marginal distribution over the third word is:\n', query["w3"]) #Get conditional distribution over third word query = belief_propagation.query(variables=['w3'], evidence={'w1': 0}, joint=False) # 0 stays for "noun" print( 'Conditional distribution over the third word, given that the first word is noun is:\n', query["w3"])
def time_query_alarm(self): infer = BeliefPropagation(self.alarm) infer.query(variables=['VENTLUNG'])
######################################################################## model = BayesianModel([('class', 'doors'), ('class', 'safety'), ('class', 'maint'), ('class', 'buying'), ('class', 'persons'), ('class', 'lug_boot')]) model.fit(df_train, estimator=MaximumLikelihoodEstimator) # print(model.get_cpds('class').values) # print(model.active_trail_nodes('doors', observed='class')) # can also use Belief propagation # inference = BeliefPropagation(model) print("Class variable prior:\n{}\n".format( inference.query(variables=['class'])['class'])) print("Class variable posterior after certain observation:\n{}\n".format( inference.query(variables=['class'], evidence={'doors': 0})['class'])) ##################### # Predict test data # ##################### predict_data = df_test.copy() predict_data.drop(['class'], axis=1, inplace=True) # y_pred = model.predict(predict_data) pred_values = [] for index, data_point in predict_data.iterrows(): prob_dist = inference.query(variables=['class'], evidence=data_point.to_dict())['class'].values
def backward_inference(self, variables, evidence=None): """ Backward inference method using belief propagation. Parameters: ---------- variables: list list of variables for which you want to compute the probability evidence: dict a dict key, value pair as {var: state_of_var_observed} None if no evidence Examples: -------- >>> from pgmpy.factors.discrete import TabularCPD >>> from pgmpy.models import DynamicBayesianNetwork as DBN >>> from pgmpy.inference import DBNInference >>> dbnet = DBN() >>> dbnet.add_edges_from([(('Z', 0), ('X', 0)), (('X', 0), ('Y', 0)), ... (('Z', 0), ('Z', 1))]) >>> z_start_cpd = TabularCPD(('Z', 0), 2, [[0.5, 0.5]]) >>> x_i_cpd = TabularCPD(('X', 0), 2, [[0.6, 0.9], ... [0.4, 0.1]], ... evidence=[('Z', 0)], ... evidence_card=[2]) >>> y_i_cpd = TabularCPD(('Y', 0), 2, [[0.2, 0.3], ... [0.8, 0.7]], ... evidence=[('X', 0)], ... evidence_card=[2]) >>> z_trans_cpd = TabularCPD(('Z', 1), 2, [[0.4, 0.7], ... [0.6, 0.3]], ... evidence=[('Z', 0)], ... evidence_card=[2]) >>> dbnet.add_cpds(z_start_cpd, z_trans_cpd, x_i_cpd, y_i_cpd) >>> dbnet.initialize_initial_state() >>> dbn_inf = DBNInference(dbnet) >>> dbn_inf.backward_inference([('X', 0)], {('Y', 0):0, ('Y', 1):1, ('Y', 2):1})[('X', 0)].values array([ 0.66594382, 0.33405618]) """ variable_dict = defaultdict(list) for var in variables: variable_dict[var[1]].append(var) time_range = max(variable_dict) interface_nodes_dict = {} if evidence: evid_time_range = max( [time_slice for var, time_slice in evidence.keys()]) time_range = max(time_range, evid_time_range) end_bp = BeliefPropagation(self.start_junction_tree) potential_dict = self.forward_inference(variables, evidence, 'potential') update_factor = self._shift_factor(potential_dict[time_range], 1) factor_values = {} for time_slice in range(time_range, 0, -1): evidence_time = self._get_evidence(evidence, time_slice, 1) evidence_prev_time = self._get_evidence(evidence, time_slice - 1, 0) if evidence_prev_time: interface_nodes_dict = { k: v for k, v in evidence_prev_time.items() if k in self.interface_nodes_0 } if evidence_time: evidence_time.update(interface_nodes_dict) mid_bp = BeliefPropagation(self.one_and_half_junction_tree) self._update_belief(mid_bp, self.in_clique, potential_dict[time_slice - 1]) forward_factor = self._shift_factor(potential_dict[time_slice], 1) self._update_belief(mid_bp, self.out_clique, forward_factor, update_factor) if variable_dict[time_slice]: variable_time = self._shift_nodes(variable_dict[time_slice], 1) new_values = mid_bp.query(variable_time, evidence=evidence_time) changed_values = {} for key in new_values.keys(): new_key = (key[0], time_slice) new_factor = DiscreteFactor([new_key], new_values[key].cardinality, new_values[key].values) changed_values[new_key] = new_factor factor_values.update(changed_values) clique_phi = self._get_factor(mid_bp, evidence_time) in_clique_phi = self._marginalize_factor(self.interface_nodes_0, clique_phi) update_factor = self._shift_factor(in_clique_phi, 1) out_clique_phi = self._shift_factor(update_factor, 0) self._update_belief(end_bp, self.start_interface_clique, potential_dict[0], out_clique_phi) evidence_0 = self._get_evidence(evidence, 0, 0) if variable_dict[0]: factor_values.update(end_bp.query(variable_dict[0], evidence_0)) return factor_values
model.add_cpds(..........) # Apply propagation belief_propagation = BeliefPropagation(model) # To calibrate the clique tree, use calibrate() method belief_propagation.calibrate() # To get cluster (or clique) beliefs use the corresponding getters belief_propagation.get_clique_beliefs() # To get the sepset beliefs use the corresponding getters belief_propagation.get_sepset_beliefs() >> # Query variables not in the same cluster belief_propagation.query(variables=['no_of_people'], evidence={'location':1, 'quality':1}) >> # Can apply MAP_Query - next belief_propagation.map_query(variables=['no_of_people'], evidence={'location':1, 'quality':1}) " {'no_of_people': 0} " -4- " MAP - Maximize A Posterior Probability " " Given the current states to find out the maximized predicted var state - prediction " " Different from Query which only care find out the distribution of target var over all states "