def __call__(self, var_and_param_names_and_values={}, **kw_var_and_param_names_and_values):
var_and_param_names_and_values = combine_dict_and_kwargs(var_and_param_names_and_values,
kw_var_and_param_names_and_values)
if var_and_param_names_and_values:
if self.CompyledFunc is None:
self.compile()
return self.CompyledFunc(var_and_param_names_and_values)
elif isinstance(self.Mapping, MathDict):
return self.Mapping()
else:
return self.Mapping
def gauss_neg_log_dens(pdf, var_and_param_names_and_values={}, **kw_var_and_param_names_and_values):
var_and_param_names_and_values = combine_dict_and_kwargs(var_and_param_names_and_values,
kw_var_and_param_names_and_values)
if not pdf.PreProcessed:
pdf.preprocess()
if pdf.LogDetCov is None:
neg_log_dens = (pdf.NumDims * log(2 * pi) + log(det(pdf.Cov)) +
det(pdf.DemeanedVarVector * pdf.Cov.inverse() * pdf.DemeanedVarVector.T)) / 2
else:
neg_log_dens = (pdf.NumDims * log(2 * pi) + pdf.LogDetCov +
det(pdf.DemeanedVarVector * Matrix(pdf.InvCov) * pdf.DemeanedVarVector.T)) / 2
return sympy_xreplace(neg_log_dens, var_and_param_names_and_values)
def gauss_neg_log_dens(pdf, var_and_param_names_and_values={}, **kw_var_and_param_names_and_values):
var_and_param_names_and_values = combine_dict_and_kwargs(var_and_param_names_and_values,
kw_var_and_param_names_and_values)
if not pdf.PreProcessed:
pdf.preprocess()
if pdf.LogDetCov is None:
neg_log_dens = (pdf.NumDims * log(2 * pi) + log(det(pdf.Cov)) +
det(pdf.DemeanedVarVector * pdf.Cov.inverse() * pdf.DemeanedVarVector.T)) / 2
else:
neg_log_dens = (pdf.NumDims * log(2 * pi) + pdf.LogDetCov +
det(pdf.DemeanedVarVector * Matrix(pdf.InvCov) * pdf.DemeanedVarVector.T)) / 2
return sympy_xreplace(neg_log_dens, var_and_param_names_and_values)
def __call__(self, var_names_and_values={}, **kw_var_names_and_values):
if isinstance(self.Compyled, float):
return self.Compyled
else:
var_names_and_values = combine_dict_and_kwargs(var_names_and_values, kw_var_names_and_values)
if hasattr(self.Compyled, 'keys'):
d = self.Compyled.copy()
for k, v in d:
d[k] = v(var_names_and_values=var_names_and_values)
return d
else:
return self.Compyled(*(var_names_and_values[var] for var in self.Vars))
def cond(self, conds={}, **kw_conds):
conds = combine_dict_and_kwargs(conds, kw_conds)
mapping = {}
s0 = set(conds.items())
for vars_and_values___frozen_dict, func_value in self.Mapping().items():
s = set(vars_and_values___frozen_dict.items())
if s >= s0:
mapping[frozendict(s - s0)] = func_value
new_conds = self.Cond.copy()
new_conds.update(conds)
new_scope = self.Scope.copy()
for var in conds:
del new_scope[var]
return MathFunc(self.Vars.copy(), mapping, cond=new_conds, scope=new_scope)
def __call__(self, var_names_and_values={}, **kw_var_names_and_values):
if isinstance(self.Compyled, float):
return self.Compyled
else:
var_names_and_values = combine_dict_and_kwargs(
var_names_and_values, kw_var_names_and_values)
if hasattr(self.Compyled, 'keys'):
d = self.Compyled.copy()
for k, v in d:
d[k] = v(var_names_and_values=var_names_and_values)
return d
else:
return self.Compyled(*(var_names_and_values[var]
for var in self.Vars))
def discrete_finite_cond(pmf, cond={}, **kw_cond):
cond = combine_dict_and_kwargs(cond, kw_cond)
mappings = pmf.Param['NegLogP'].copy()
d = {}
s0 = set(cond.items())
for var_values___frozen_dict, mapping_value in list(mappings.items()):
s = set(var_values___frozen_dict.items())
if s >= s0:
d[frozendict(s - s0)] = mapping_value
new_cond = deepcopy(pmf.Cond)
new_cond.update(cond)
scope = deepcopy(pmf.Scope)
for var in cond:
del scope[var]
return DiscreteFinitePMF(pmf.Vars.copy(), d, cond=new_cond, scope=scope, p=False)
def discrete_finite_cond(pmf, cond={}, **kw_cond):
cond = combine_dict_and_kwargs(cond, kw_cond)
mappings = pmf.Param['NegLogP'].copy()
d = {}
s0 = set(cond.items())
for var_values___frozen_dict, mapping_value in mappings.items():
s = set(var_values___frozen_dict.items())
if s >= s0:
d[frozendict(s - s0)] = mapping_value
new_cond = deepcopy(pmf.Cond)
new_cond.update(cond)
scope = deepcopy(pmf.Scope)
for var in cond:
del scope[var]
return DiscreteFinitePMF(pmf.Vars.copy(), d, cond=new_cond, scope=scope, p=False)
def at(self, var_and_param_names_and_values={}, **kw_var_and_param_names_and_values):
var_and_param_names_and_values =\
combine_dict_and_kwargs(var_and_param_names_and_values, kw_var_and_param_names_and_values)
cond = deepcopy(self.Cond) # just to be careful
scope = deepcopy(self.Scope) # just to be careful
param = self.Param.copy()
syms_and_values = {}
for var, value in list(var_and_param_names_and_values.items()):
if var in self.Vars:
if var in cond:
cond[var] = value
if var in scope:
scope[var] = value
syms_and_values[self.Vars[var]] = value
if var in param:
try:
syms_and_values[param[var]] = value
except:
pass
param[var] = value
cond = sympy_xreplace(cond, syms_and_values)
scope = sympy_xreplace(scope, syms_and_values)
self.CompyledFunc = None # remove compiled version because many things can be changing
if self.is_discrete_finite():
neg_log_p = {}
s = set(var_and_param_names_and_values)
s_items = set(var_and_param_names_and_values.items())
for var_values___frozen_dict, mapping_value in list(param['NegLogP'].items()):
other_items___dict = dict(set(var_values___frozen_dict.items()) - s_items)
if not (set(other_items___dict) & s):
neg_log_p[frozendict(set(var_values___frozen_dict.items()) - set(cond.items()))] =\
sympy_xreplace(mapping_value, syms_and_values)
return DiscreteFinitePMF(var_names_and_syms=self.Vars.copy(), p_or_neg_log_p=neg_log_p, p=False,
cond=cond, scope=scope)
else:
pdf = self.copy()
pdf.Cond = cond
pdf.Scope = scope
pdf.Param = sympy_xreplace(param, syms_and_values)
#print(pdf.Mapping)
#print(syms_and_values)
#print(type(syms_and_values.keys().pop()))
pdf.Mapping = sympy_xreplace(pdf.Mapping, syms_and_values)
return pdf
def at(self, var_and_param_names_and_values={}, **kw_var_and_param_names_and_values):
var_and_param_names_and_values =\
combine_dict_and_kwargs(var_and_param_names_and_values, kw_var_and_param_names_and_values)
cond = deepcopy(self.Cond) # just to be careful
scope = deepcopy(self.Scope) # just to be careful
param = self.Param.copy()
syms_and_values = {}
for var, value in var_and_param_names_and_values.items():
if var in self.Vars:
if var in cond:
cond[var] = value
if var in scope:
scope[var] = value
syms_and_values[self.Vars[var]] = value
if var in param:
try:
syms_and_values[param[var]] = value
except:
pass
param[var] = value
cond = sympy_xreplace(cond, syms_and_values)
scope = sympy_xreplace(scope, syms_and_values)
self.CompyledFunc = None # remove compiled version because many things can be changing
if self.is_discrete_finite():
neg_log_p = {}
s = set(var_and_param_names_and_values)
s_items = set(var_and_param_names_and_values.items())
for var_values___frozen_dict, mapping_value in param['NegLogP'].items():
other_items___dict = dict(set(var_values___frozen_dict.items()) - s_items)
if not (set(other_items___dict) & s):
neg_log_p[frozendict(set(var_values___frozen_dict.items()) - set(cond.items()))] =\
sympy_xreplace(mapping_value, syms_and_values)
return DiscreteFinitePMF(var_names_and_syms=self.Vars.copy(), p_or_neg_log_p=neg_log_p, p=False,
cond=cond, scope=scope)
else:
pdf = self.copy()
pdf.Cond = cond
pdf.Scope = scope
pdf.Param = sympy_xreplace(param, syms_and_values)
#print(pdf.Mapping)
#print(syms_and_values)
#print(type(syms_and_values.keys().pop()))
pdf.Mapping = sympy_xreplace(pdf.Mapping, syms_and_values)
return pdf
def at(self, vars_and_values___dict={}, **kw_vars_and_values___dict):
vars_and_values___dict = combine_dict_and_kwargs(vars_and_values___dict, kw_vars_and_values___dict)
for var in (set(self.Vars) & set(vars_and_values___dict)):
vars_and_values___dict[self.Vars[var]] = vars_and_values___dict[var]
conds = self.Cond.copy()
scope = self.Scope.copy()
for var, value in vars_and_values___dict.items():
if var in conds:
conds.update({var: value})
if var in scope:
scope.update({var: value})
conds = sympy_xreplace(conds, vars_and_values___dict)
scope = sympy_xreplace(scope, vars_and_values___dict)
if hasattr(self.Mapping, 'keys'):
mapping = {}
for vars_and_values___frozen_dict, func_value in self.Mapping.items():
other_items___dict = dict(set(vars_and_values___frozen_dict.items()) -
set(vars_and_values___dict.items()))
if not (set(other_items___dict) and set(vars_and_values___dict)):
mapping[frozendict(set(vars_and_values___frozen_dict.items()) - set(conds.items()))] =\
sympy_xreplace(func_value, vars_and_values___dict)
else:
mapping = sympy_xreplace(self.Mapping, vars_and_values___dict)
return MathFunc(self.Vars.copy(), mapping, cond=conds, scope=scope)
def gauss_cond(pdf, cond={}, **kw_cond):
cond = combine_dict_and_kwargs(cond, kw_cond)
new_cond = pdf.Cond.copy()
new_cond.update(cond)
scope = pdf.Scope.copy()
for var in cond:
del scope[var]
point_cond = {}
for var, value in list(cond.items()):
if value is not None:
point_cond[pdf.Vars[var]] = value
cond_vars = tuple(cond)
num_cond_vars = len(cond_vars)
scope_vars = tuple(set(pdf.VarsList) - set(cond))
num_scope_vars = len(scope_vars)
x_c = BlockMatrix((tuple(pdf.Vars[cond_var] for cond_var in cond_vars),))
m_c = BlockMatrix((tuple(pdf.Param[('Mean', cond_var)] for cond_var in cond_vars),))
m_s = BlockMatrix((tuple(pdf.Param[('Mean', scope_var)] for scope_var in scope_vars),))
S_c = [num_cond_vars * [None] for _ in range(num_cond_vars)] # careful not to create same mutable object
for i in range(num_cond_vars):
for j in range(i):
if ('Cov', cond_vars[i], cond_vars[j]) in pdf.Param:
S_c[i][j] = pdf.Param[('Cov', cond_vars[i], cond_vars[j])]
S_c[j][i] = S_c[i][j].T
else:
S_c[j][i] = pdf.Param[('Cov', cond_vars[j], cond_vars[i])]
S_c[i][j] = S_c[j][i].T
S_c[i][i] = pdf.Param[('Cov', cond_vars[i])]
S_c = BlockMatrix(S_c)
S_s = [num_scope_vars * [None] for _ in range(num_scope_vars)] # careful not to create same mutable object
for i in range(num_scope_vars):
for j in range(i):
if ('Cov', scope_vars[i], scope_vars[j]) in pdf.Param:
S_s[i][j] = pdf.Param[('Cov', scope_vars[i], scope_vars[j])]
S_s[j][i] = S_s[i][j].T
else:
S_s[j][i] = pdf.Param[('Cov', scope_vars[j], scope_vars[i])]
S_s[i][j] = S_s[j][i].T
S_s[i][i] = pdf.Param[('Cov', scope_vars[i])]
S_s = BlockMatrix(S_s)
S_cs = [num_scope_vars * [None] for _ in range(num_cond_vars)] # careful not to create same mutable object
for i, j in product(list(range(num_cond_vars)), list(range(num_scope_vars))):
if ('Cov', cond_vars[i], scope_vars[j]) in pdf.Param:
S_cs[i][j] = pdf.Param[('Cov', cond_vars[i], scope_vars[j])]
else:
S_cs[i][j] = pdf.Param[('Cov', scope_vars[j], cond_vars[i])].T
S_cs = BlockMatrix(S_cs)
S_sc = S_cs.T
m = (m_s + (x_c - m_c) * S_c.inverse() * S_cs).xreplace(point_cond)
S = S_s - S_sc * S_c.inverse() * S_cs
param = {}
index_ranges_from = []
index_ranges_to = []
k = 0
for i in range(num_scope_vars):
l = k + pdf.Vars[scope_vars[i]].shape[1]
index_ranges_from += [k]
index_ranges_to += [l]
param[('Mean', scope_vars[i])] = m[0, index_ranges_from[i]:index_ranges_to[i]]
for j in range(i):
param[('Cov', scope_vars[j], scope_vars[i])] =\
S[index_ranges_from[j]:index_ranges_to[j], index_ranges_from[i]:index_ranges_to[i]]
param[('Cov', scope_vars[i])] =\
S[index_ranges_from[i]:index_ranges_to[i], index_ranges_from[i]:index_ranges_to[i]]
k = l
return GaussPDF(var_names_and_syms=pdf.Vars.copy(), param=param, cond=new_cond, scope=scope)
def cond(self, cond={}, **kw_cond):
cond = combine_dict_and_kwargs(cond, kw_cond)
return self.CondFunc(self, cond)
def gauss_cond(pdf, cond={}, **kw_cond):
cond = combine_dict_and_kwargs(cond, kw_cond)
new_cond = pdf.Cond.copy()
new_cond.update(cond)
scope = pdf.Scope.copy()
for var in cond:
del scope[var]
point_cond = {}
for var, value in cond.items():
if value is not None:
point_cond[pdf.Vars[var]] = value
cond_vars = tuple(cond)
num_cond_vars = len(cond_vars)
scope_vars = tuple(set(pdf.VarsList) - set(cond))
num_scope_vars = len(scope_vars)
x_c = BlockMatrix((tuple(pdf.Vars[cond_var] for cond_var in cond_vars),))
m_c = BlockMatrix((tuple(pdf.Param[('Mean', cond_var)] for cond_var in cond_vars),))
m_s = BlockMatrix((tuple(pdf.Param[('Mean', scope_var)] for scope_var in scope_vars),))
S_c = [num_cond_vars * [None] for _ in range(num_cond_vars)] # careful not to create same mutable object
for i in range(num_cond_vars):
for j in range(i):
if ('Cov', cond_vars[i], cond_vars[j]) in pdf.Param:
S_c[i][j] = pdf.Param[('Cov', cond_vars[i], cond_vars[j])]
S_c[j][i] = S_c[i][j].T
else:
S_c[j][i] = pdf.Param[('Cov', cond_vars[j], cond_vars[i])]
S_c[i][j] = S_c[j][i].T
S_c[i][i] = pdf.Param[('Cov', cond_vars[i])]
S_c = BlockMatrix(S_c)
S_s = [num_scope_vars * [None] for _ in range(num_scope_vars)] # careful not to create same mutable object
for i in range(num_scope_vars):
for j in range(i):
if ('Cov', scope_vars[i], scope_vars[j]) in pdf.Param:
S_s[i][j] = pdf.Param[('Cov', scope_vars[i], scope_vars[j])]
S_s[j][i] = S_s[i][j].T
else:
S_s[j][i] = pdf.Param[('Cov', scope_vars[j], scope_vars[i])]
S_s[i][j] = S_s[j][i].T
S_s[i][i] = pdf.Param[('Cov', scope_vars[i])]
S_s = BlockMatrix(S_s)
S_cs = [num_scope_vars * [None] for _ in range(num_cond_vars)] # careful not to create same mutable object
for i, j in product(range(num_cond_vars), range(num_scope_vars)):
if ('Cov', cond_vars[i], scope_vars[j]) in pdf.Param:
S_cs[i][j] = pdf.Param[('Cov', cond_vars[i], scope_vars[j])]
else:
S_cs[i][j] = pdf.Param[('Cov', scope_vars[j], cond_vars[i])].T
S_cs = BlockMatrix(S_cs)
S_sc = S_cs.T
m = (m_s + (x_c - m_c) * S_c.inverse() * S_cs).xreplace(point_cond)
S = S_s - S_sc * S_c.inverse() * S_cs
param = {}
index_ranges_from = []
index_ranges_to = []
k = 0
for i in range(num_scope_vars):
l = k + pdf.Vars[scope_vars[i]].shape[1]
index_ranges_from += [k]
index_ranges_to += [l]
param[('Mean', scope_vars[i])] = m[0, index_ranges_from[i]:index_ranges_to[i]]
for j in range(i):
param[('Cov', scope_vars[j], scope_vars[i])] =\
S[index_ranges_from[j]:index_ranges_to[j], index_ranges_from[i]:index_ranges_to[i]]
param[('Cov', scope_vars[i])] =\
S[index_ranges_from[i]:index_ranges_to[i], index_ranges_from[i]:index_ranges_to[i]]
k = l
return GaussPDF(var_names_and_syms=pdf.Vars.copy(), param=param, cond=new_cond, scope=scope)
def cond(self, cond={}, **kw_cond):
cond = combine_dict_and_kwargs(cond, kw_cond)
return self.CondFunc(self, cond)
