# probFactors.py - Factors for graphical models # AIFCA Python3 code Version 0.9.0 Documentation at http://aipython.org # Artificial Intelligence: Foundations of Computational Agents # http://artint.info # Copyright David L Poole and Alan K Mackworth 2017-2020. # This work is licensed under a Creative Commons # Attribution-NonCommercial-ShareAlike 4.0 International License. # See: http://creativecommons.org/licenses/by-nc-sa/4.0/deed.en from display import Displayable import math class Factor(Displayable): nextid=0 # each factor has a unique identifier; for printing def __init__(self,variables): self.variables = variables # ordered list of variables self.id = Factor.nextid self.name = f"f{self.id}" Factor.nextid += 1 def can_evaluate(self,assignment): """True when the factor can be evaluated in the assignment assignment is a {variable:value} dict """ return all(v in assignment for v in self.variables) def get_value(self,assignment): """Returns the value of the factor given the assignment of values to variables. Needs to be defined for each subclass. """ assert self.can_evaluate(assignment) raise NotImplementedError("get_value") # abstract method def __str__(self): """returns a string representing a summary of the factor""" return f"{self.name}({','.join(str(var) for var in self.variables)})" def to_table(self, variables=None): """returns a string representation of the factor. Allows for an arbitrary variable ordering. variables is a list of the variables in the factor (can contain other variables)""" if variables==None: variables = self.variables else: #enforce ordering and allow for extra variables in ordering variables = [v for v in variables if v in self.variables] head = "\t".join(str(v) for v in variables) return head+"\n"+self.ass_to_str(variables, {}, variables) def ass_to_str(self, vars, asst, allvars): #print(f"ass_to_str({vars}, {asst}, {allvars})") if vars: return "\n".join(self.ass_to_str(vars[1:], asst | {vars[0]:val}, allvars) for val in vars[0].domain) else: return ("\t".join(str(asst[var]) for var in allvars) + "\t"+str(self.get_value(asst)) ) __repr__ = __str__ class CPD(Factor): def __init__(self, child, parents): """represents P(variable | parents) """ self.parents = parents self.child = child Factor.__init__(self, parents+[child]) def __str__(self): """A brief description of a factor using in tracing""" if self.parents: return f"P({self.child}|{','.join(str(p) for p in self.parents)})" else: return f"P({self.child})" __repr__ = __str__ from learnLinear import sigmoid class LogisticRegression(CPD): def __init__(self, child, parents, weights): """A logistic regression representation of a conditional probability. child is the Boolean (or 0/1) variable whose CPD is being defined parents is the list of parents weights is list of parameters, such that weights[i+1] is the weight for parents[i] """ assert len(weights) == 1+len(parents) CPD.__init__(self, child, parents) self.weights = weights def get_value(self,assignment): assert self.can_evaluate(assignment) prob = sigmoid(self.weights[0] + sum(self.weights[i+1]*assignment[self.parents[i]] for i in range(len(self.parents)))) if assignment[self.child]: #child is true return prob else: return (1-prob) class NoisyOR(CPD): def __init__(self, child, parents, weights): """A noisy representation of a conditional probability. variable is the Boolean (or 0/1) child variable whose CPD is being defined parents is the list of Boolean (or 0/1) parents weights is list of parameters, such that weights[i+1] is the weight for parents[i] """ assert len(weights) == 1+len(parents) CPD.__init__(self, child, parents) self.weights = weights def get_value(self,assignment): assert self.can_evaluate(assignment) probfalse = (1-self.weights[0])*math.prod(1-self.weights[i+1] for i in range(len(self.parents)) if assignment[self.parents[i]]) if assignment[self.child]: return 1-probfalse else: return probfalse from functools import reduce class TabFactor(Factor): def __init__(self, variables, values): Factor.__init__(self, variables) self.values = values def get_value(self, assignment): return self.get_val_rec(self.values, self.variables, assignment) def get_val_rec(self, value, variables, assignment): if variables == []: return value else: return self.get_val_rec(value[assignment[variables[0]]], variables[1:],assignment) class Prob(CPD,TabFactor): """A factor defined by a conditional probability table""" def __init__(self,var,pars,cpt): """Creates a factor from a conditional probability table, cpt The cpt values are assumed to be for the ordering par+[var] """ TabFactor.__init__(self,pars+[var],cpt) self.child = var self.parents = pars class FactorObserved(Factor): def __init__(self,factor,obs): Factor.__init__(self, [v for v in factor.variables if v not in obs]) self.observed = obs self.orig_factor = factor def get_value(self,assignment): ass = assignment.copy() for ob in self.observed: ass[ob]=self.observed[ob] return self.orig_factor.get_value(ass) class FactorSum(Factor): def __init__(self,var,factors): self.var_summed_out = var self.factors = factors vars = [] for fac in factors: for v in fac.variables: if v is not var and v not in vars: vars.append(v) Factor.__init__(self,vars) self.values = {} def get_value(self,assignment): """lazy implementation: if not saved, compute it. Return saved value""" asst = frozenset(assignment.items()) if asst in self.values: return self.values[asst] else: total = 0 new_asst = assignment.copy() for val in self.var_summed_out.domain: new_asst[self.var_summed_out] = val total += math.prod(fac.get_value(new_asst) for fac in self.factors) self.values[asst] = total return total def factor_times(variable, factors): """when factors are factors just on variable (or on no variables)""" prods = [] facs = [f for f in factors if variable in f.variables] for val in variable.domain: ast = {variable:val} prods.append(math.prod(f.get_value(ast) for f in facs)) return prods