1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
function CPDpot = convert_dbn_CPDs_to_tables1(bnet, evidence)
% CONVERT_DBN_CPDS_TO_TABLES Convert CPDs of (possibly instantiated) DBN nodes to tables
% CPDpot = convert_dbn_CPDs_to_tables(bnet, evidence)
%
% CPDpot{n,t} is a table containing P(n,t|pa(n,t), ev)
% All hidden nodes are assumed to be discrete
% We assume the observed nodes are the same in every slice
%
% Evaluating the conditional likelihood of the evidence can be very slow,
% so we take pains to vectorize where possible, i.e., we try to avoid
% calling convert_to_table
[ss T] = size(evidence);
%obs_bitv = ~isemptycell(evidence(:));
obs_bitv = zeros(1, 2*ss);
obs_bitv(bnet.observed) = 1;
obs_bitv(bnet.observed+ss) = 1;
ns = bnet.node_sizes(:);
CPDpot = cell(ss,T);
for n=1:ss
% slice 1
t = 1;
ps = parents(bnet.dag, n);
e = bnet.equiv_class(n, 1);
if ~any(obs_bitv(ps))
CPDpot{n,t} = convert_CPD_to_table_hidden_ps(bnet.CPD{e}, evidence{n,t});
else
CPDpot{n,t} = convert_to_table(bnet.CPD{e}, [ps n], evidence(:,1));
end
% slices 2..T
debug = 1;
if ~obs_bitv(n)
CPDpot = helper_hidden_child(bnet, evidence, n, CPDpot, obs_bitv, debug);
else
CPDpot = helper_obs_child(bnet, evidence, n, CPDpot, obs_bitv, debug);
end
end
if 0
CPDpot2 = convert_dbn_CPDs_to_tables_slow(bnet, evidence);
for t=1:T
for n=1:ss
if ~approxeq(CPDpot{n,t}, CPDpot2{n,t})
fprintf('CPDpot n=%d, t=%d\n',n,t);
keyboard
end
end
end
end
% special cases: c=child, p=parents, d=discrete, h=hidden, 1=1slice
% if c=h=1 then c=d=1, since hidden nodes must be discrete
% c=h c=d p=h p=d p=1 method
% ---------------------------
% 1 1 1 1 - replicate CPT
% 0 1 1 1 1 dhmm
% 0 0 1 1 1 ghmm
% - 1 - 1 - evaluate CPT on evidence
% other loop
%%%%%%%
function CPDpot = helper_hidden_child(bnet, evidence, n, CPDpot, obs_bitv, debug)
[ss T] = size(evidence);
self = n+ss;
ps = parents(bnet.dag, self);
e = bnet.equiv_class(n, 2);
ns = bnet.node_sizes(:);
if ~any(obs_bitv(ps)) % all parents are hidden (hence discrete)
if debug, fprintf('node %d is hidden, all ps are hidden\n', n); end
if myismember(n, bnet.dnodes)
%CPT = CPD_to_CPT(bnet.CPD{e});
%CPT = reshape(CPT, [prod(ns(ps)) ns(self)]);
CPT = convert_CPD_to_table_hidden_ps(bnet.CPD{e}, []);
CPDpot(n,2:T) = num2cell(repmat(CPT, [1 1 T-1]), [1 2]);
else
error(['hidden cts node disallowed'])
end
else % some parents are observed - slow
if mysubset(ps, bnet.dnodes) % all parents are discrete
% given CPT(p1, p2, p3, p4, c), where p1,p3 are observed
% we create CPT([p2 p4 c], [p1 p3]).
% We then convert all observed p1,p3 into indices ndx
% and return CPT(:, ndx)
CPT = CPD_to_CPT(bnet.CPD{e});
domain = [ps self];
% if dom is [3 7 8] and 3,8 are observed, odom_rel = [1 3], hdom_rel = 2,
% odom = [3 8], hdom = 7
odom_rel = find(obs_bitv(domain));
hdom_rel = find(~obs_bitv(domain));
odom = domain(odom_rel);
hdom = domain(hdom_rel);
CPT = permute(CPT, [hdom_rel odom_rel]);
CPT = reshape(CPT, prod(ns(hdom)), prod(ns(odom)));
parents_in_same_slice = all(ps > ss);
if parents_in_same_slice
if debug, fprintf('node %d is hidden, some ps are obs, all ps discrete, 1 slice\n', n); end
data = cell2num(evidence(odom-ss,2:T)); %data(i,t) = val of i'th obs parent at t+1
else
if debug, fprintf('node %d is hidden, some ps are obs, all ps discrete, 2 slice\n', n); end
data = zeros(length(odom), T-1);
for t=2:T
ev = evidence(:,t-1:t);
data(:,t-1) = cell2num(ev(odom));
end
end
ndx = subv2ind(ns(odom), data'); % ndx(t) encodes data(:,t)
CPDpot(n,2:T) = num2cell(CPT(:, ndx), [1 2]);
else % some parents are cts - v slow
if debug, fprintf('node %d is hidden, some ps are obs, some ps cts\n', n); end
for t=2:T
CPDpot{n,t} = convert_to_table(bnet.CPD{e}, [ps self], evidence(:,t-1:t));
end
end
end
%%%%%%%
function CPDpot = helper_obs_child(bnet, evidence, n, CPDpot, obs_bitv, debug)
[ss T] = size(evidence);
self = n+ss;
ps = parents(bnet.dag, self);
e = bnet.equiv_class(n, 2);
ns = bnet.node_sizes(:);
if ~any(obs_bitv(ps)) % all parents are hidden
parents_in_same_slice = all(ps > ss);
if parents_in_same_slice
if debug, fprintf('node %d is obs, all ps are hidden, 1 slice\n', n); end
ps1 = ps - ss;
if myismember(n, bnet.dnodes)
CPT = CPD_to_CPT(bnet.CPD{e});
CPT = reshape(CPT, [prod(ns(ps)) ns(self)]); % what if no parents?
obslik = eval_pdf_cond_multinomial(cell2num(evidence(n,2:T)), CPT);
CPDpot(n,2:T) = num2cell(obslik, 1);
else
S = struct(bnet.CPD{e});
obslik = eval_pdf_cond_gauss(cell2num(evidence(n,2:T)), S.mean, S.cov);
CPDpot(n,2:T) = num2cell(obslik, 1);
end
else % parents span 2 slices - slow
if debug, fprintf('node %d is obs, all ps are hidden , 2 slice\n', n); end
for t=2:T
CPDpot{n,t} = convert_to_table(bnet.CPD{e}, [ps self], evidence(:,t-1:t));
end
end
else
if isempty(ps) % observed root
if debug, fprintf('node %d is obs, no ps\n', n); end
CPT = CPD_to_CPT(bnet.CPD{e});
data = cell2num(evidence(n,2:T));
CPDpot(n,2:T) = CPT(data);
else % some parents are observed - slow
if debug, fprintf('node %d is obs, some ps are obs\n', n); end
for t=2:T
CPDpot{n,t} = convert_to_table(bnet.CPD{e}, [ps self], evidence(:,t-1:t));
end
end
end
|
