def convert_pot_df_to_pot(is_quantum, pot_df, ord_nodes, normalize=True): """ Returns a Potential pot with ordered nodes ord_nodes. Parameters ---------- is_quantum : bool pot_df : pandas.DataFrame a dataframe returned by learn_pot_df() ord_nodes : list[BayesNode] ordered nodes of Potential pot that is returned normalize : bool True if want pot to be normalized as a cond probability or cond amplitude, P(x|y) or A(x|y), where x is ord_nodes[-1] Returns ------- pandas.DataFrame """ pot = DiscreteCondPot(is_quantum, ord_nodes, bias=0) for row in range(len(pot_df.index)): # print([pot_df.iloc[row, col] # for col in range(len(ord_nodes)) # ]) index = [ ord_nodes[col].st_name_index(str(pot_df.iloc[row, col])) for col in range(len(ord_nodes)) ] pot.pot_arr[tuple(index)] = pot_df.loc[row, 'pot_values'] if normalize: pot.normalize_self() # print(pot) return pot
def convert_pot_df_to_pot(is_quantum, pot_df, ord_nodes, normalize=True): """ Returns a Potential pot with ordered nodes ord_nodes. Parameters ---------- is_quantum : bool pot_df : pandas.DataFrame a dataframe returned by learn_pot_df() ord_nodes : list[BayesNode] ordered nodes of Potential pot that is returned normalize : bool True if want pot to be normalized as a cond probability or cond amplitude, P(x|y) or A(x|y), where x is ord_nodes[-1] Returns ------- pandas.DataFrame """ pot = DiscreteCondPot(is_quantum, ord_nodes, bias=0) for row in range(len(pot_df.index)): # print([pot_df.iloc[row, col] # for col in range(len(ord_nodes)) # ]) index = [ ord_nodes[col].st_name_index(str(pot_df.iloc[row, col])) for col in range(len(ord_nodes)) ] pot.pot_arr[tuple(index)] = pot_df.loc[row, 'pot_values'] if normalize: pot.normalize_self() # print(pot) return pot
def convert_pot_df_to_pot(is_quantum, pot_df, ord_nodes, s_d_pair, use_int_sts=None, normalize=True): """ Returns a DiscreteCondPot pot with ordered nodes ord_nodes. Parameters ---------- is_quantum : bool pot_df : pandas.DataFrame a dataframe returned by learn_pot_df(). pot_df must have one column for each node in ord_nodes plus additioanl final column with pot values ord_nodes : list[BayesNode] ordered nodes of Potential pot that is returned. Nodes must be ordered so that pot_df[:-1].columns = [nd.name for nd in ord_nodes] s_d_pair : tuple[int|str, float] a pair consisting of a state and a degs. The state is taken directly from states_df, so it might be a digit or an actual state name, depending on whether use_int_sts was True or False when states_df was generated. The state is a state of the focus node (the last column of states_cols corresponds to the focus node). The degs is an angle in degrees. For an s_d_pair equal to (x0,ang), whenever pot(C=x| pa(C)=y) = 0 for all x, we will set pot(C=x|pa(C)=y) = exp( 1j*ang*pi/180)*delta(x, x0) in the quantum case and pot( C=x| pa(C)=y) = delta(x, x0) in the classical case. use_int_sts : bool True if states in states_df are integers, False if they are the actual state names. If the parameter use_int_sts is set to None, this function will attempt to find its bool value using the function NetStrucLner:int_sts_detector() normalize : bool True if want pot to be normalized as a cond probability or cond amplitude, P(x|y) or A(x|y), where x is ord_nodes[-1] Returns ------- DiscreteCondPot """ for k, vtx in enumerate(pot_df.columns[:-1]): assert ord_nodes[k].name == vtx focus_vtx = pot_df.columns[-2] focus_nd = ord_nodes[-1] if use_int_sts is None: use_int_sts = NetParamsLner.int_sts_detector(pot_df[:-1]) def int_state(st): if use_int_sts: return int(st) else: return focus_nd.pos_of_st_name(str(st)) pot = DiscreteCondPot(is_quantum, ord_nodes, bias=0) for row in range(len(pot_df.index)): # print([pot_df.iloc[row, col] # for col in range(len(ord_nodes)) # ]) if not use_int_sts: arr_index = [ ord_nodes[col].pos_of_st_name(str(pot_df.iloc[row, col])) for col in range(len(ord_nodes)) ] else: arr_index = [ int(pot_df.iloc[row, col]) for col in range(len(ord_nodes)) ] pot.pot_arr[tuple(arr_index)] = \ pot_df.loc[row, 'last_col_with_vals'] if normalize: try: pot.normalize_self() except UnNormalizablePot as xce: # print('caught exception') focus_index = int_state(s_d_pair[0]) arr_index = tuple(list(xce.pa_indices) + [focus_index]) # print('********************arr_index', arr_index) if is_quantum: pot.pot_arr[arr_index] = \ np.exp(1j * s_d_pair[1] * np.pi / 180) else: pot.pot_arr[arr_index] = 1.0 print('mended pot:\n', pot) # try normalizing pot again now that it is mended pot.normalize_self() return pot
def convert_pot_df_to_pot(is_quantum, pot_df, ord_nodes, s_d_pair, use_int_sts=None, normalize=True): """ Returns a DiscreteCondPot pot with ordered nodes ord_nodes. Parameters ---------- is_quantum : bool pot_df : pandas.DataFrame a dataframe returned by learn_pot_df(). pot_df must have one column for each node in ord_nodes plus additioanl final column with pot values ord_nodes : list[BayesNode] ordered nodes of Potential pot that is returned. Nodes must be ordered so that pot_df[:-1].columns = [nd.name for nd in ord_nodes] s_d_pair : tuple[int|str, float] a pair consisting of a state and a degs. The state is taken directly from states_df, so it might be a digit or an actual state name, depending on whether use_int_sts was True or False when states_df was generated. The state is a state of the focus node (the last column of states_cols corresponds to the focus node). The degs is an angle in degrees. For an s_d_pair equal to (x0,ang), whenever pot(C=x| pa(C)=y) = 0 for all x, we will set pot(C=x|pa(C)=y) = exp( 1j*ang*pi/180)*delta(x, x0) in the quantum case and pot( C=x| pa(C)=y) = delta(x, x0) in the classical case. use_int_sts : bool True if states in states_df are integers, False if they are the actual state names. If the parameter use_int_sts is set to None, this function will attempt to find its bool value using the function NetStrucLner:int_sts_detector() normalize : bool True if want pot to be normalized as a cond probability or cond amplitude, P(x|y) or A(x|y), where x is ord_nodes[-1] Returns ------- DiscreteCondPot """ for k, vtx in enumerate(pot_df.columns[:-1]): assert ord_nodes[k].name == vtx focus_vtx = pot_df.columns[-2] focus_nd = ord_nodes[-1] if use_int_sts is None: use_int_sts = NetStrucLner.int_sts_detector(pot_df[:-1]) def int_state(st): if use_int_sts: return int(st) else: return focus_nd.st_name_index(str(st)) pot = DiscreteCondPot(is_quantum, ord_nodes, bias=0) for row in range(len(pot_df.index)): # print([pot_df.iloc[row, col] # for col in range(len(ord_nodes)) # ]) if not use_int_sts: arr_index = [ ord_nodes[col].st_name_index(str(pot_df.iloc[row, col])) for col in range(len(ord_nodes))] else: arr_index = [int(pot_df.iloc[row, col]) for col in range(len(ord_nodes))] pot.pot_arr[tuple(arr_index)] = \ pot_df.loc[row, 'last_col_with_vals'] if normalize: try: pot.normalize_self() except UnNormalizablePot as xce: # print('caught exception') focus_index = int_state(s_d_pair[0]) arr_index = tuple(list(xce.pa_indices) + [focus_index]) # print('********************arr_index', arr_index) if is_quantum: pot.pot_arr[arr_index] = \ np.exp(1j * s_d_pair[1] * np.pi / 180) else: pot.pot_arr[arr_index] = 1.0 print('mended pot:\n', pot) # try normalizing pot again now that it is mended pot.normalize_self() return pot