Mercurial > hg > camir-aes2014
comparison toolboxes/FullBNT-1.0.7/bnt/inference/static/@pearl_inf_engine/enter_evidence.m @ 0:e9a9cd732c1e tip
first hg version after svn
author | wolffd |
---|---|
date | Tue, 10 Feb 2015 15:05:51 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:e9a9cd732c1e |
---|---|
1 function [engine, loglik, niter] = enter_evidence(engine, evidence, varargin) | |
2 % ENTER_EVIDENCE Add the specified evidence to the network (pearl) | |
3 % [engine, loglik, num_iter] = enter_evidence(engine, evidence, ...) | |
4 % evidence{i} = [] if if X(i) is hidden, and otherwise contains its observed value (scalar or column vector) | |
5 % | |
6 % The following optional arguments can be specified in the form of name/value pa irs: | |
7 % [default value in brackets] | |
8 % | |
9 % maximize - if 1, does max-product instead of sum-product [0] | |
10 % 'filename' - msgs will be printed to this file, so you can assess convergence while it runs [engine.filename] | |
11 % | |
12 % e.g., engine = enter_evidence(engine, ev, 'maximize', 1) | |
13 % | |
14 % For discrete nodes, loglik is the negative Bethe free energy evaluated at the final beliefs. | |
15 % For Gaussian nodes, loglik is currently always 0. | |
16 % | |
17 % 'num_iter' returns the number of iterations used. | |
18 | |
19 maximize = 0; | |
20 filename = engine.filename; | |
21 | |
22 % parse optional params | |
23 args = varargin; | |
24 nargs = length(args); | |
25 if nargs > 0 | |
26 for i=1:2:nargs | |
27 switch args{i}, | |
28 case 'maximize', maximize = args{i+1}; | |
29 case 'filename', filename = args{i+1}; | |
30 otherwise, | |
31 error(['invalid argument name ' args{i}]); | |
32 end | |
33 end | |
34 end | |
35 | |
36 | |
37 if maximize | |
38 error('can''t handle max-prop yet') | |
39 end | |
40 | |
41 engine.maximize = maximize; | |
42 engine.filename = filename; | |
43 engine.bel = []; % reset if necessary | |
44 | |
45 bnet = bnet_from_engine(engine); | |
46 N = length(bnet.dag); | |
47 ns = bnet.node_sizes(:); | |
48 | |
49 observed_bitv = ~isemptycell(evidence); | |
50 disconnected = find(engine.disconnected_nodes_bitv); | |
51 if ~all(observed_bitv(disconnected)) | |
52 error(['The following discrete nodes must be observed: ' num2str(disconnected)]) | |
53 end | |
54 msg = init_pearl_msgs(engine.msg_type, engine.msg_dag, ns, evidence); | |
55 | |
56 niter = 1; | |
57 switch engine.protocol | |
58 case 'parallel', [msg, niter] = parallel_protocol(engine, evidence, msg); | |
59 case 'tree', msg = tree_protocol(engine, evidence, msg); | |
60 otherwise, | |
61 error(['unrecognized protocol ' engine.protocol]) | |
62 end | |
63 engine.niter = niter; | |
64 | |
65 engine.marginal = cell(1,N); | |
66 nodes = find(~engine.disconnected_nodes_bitv); | |
67 for n=nodes(:)' | |
68 engine.marginal{n} = compute_bel(engine.msg_type, msg{n}.pi, msg{n}.lambda); | |
69 end | |
70 | |
71 engine.evidence = evidence; % needed by marginal_nodes and marginal_family | |
72 engine.msg = msg; % needed by marginal_family | |
73 | |
74 if (nargout >= 2) | |
75 if (engine.msg_type == 'd') | |
76 loglik = bethe_free_energy(engine, evidence); | |
77 else | |
78 loglik = 0; | |
79 end | |
80 end | |
81 | |
82 | |
83 | |
84 %%%%%%%%%%% | |
85 | |
86 function msg = init_pearl_msgs(msg_type, dag, ns, evidence) | |
87 % INIT_MSGS Initialize the lambda/pi message and state vectors | |
88 % msg = init_msgs(dag, ns, evidence) | |
89 % | |
90 | |
91 N = length(dag); | |
92 msg = cell(1,N); | |
93 observed = ~isemptycell(evidence); | |
94 lam_msg = 1; | |
95 | |
96 for n=1:N | |
97 ps = parents(dag, n); | |
98 msg{n}.pi_from_parent = cell(1, length(ps)); | |
99 for i=1:length(ps) | |
100 p = ps(i); | |
101 msg{n}.pi_from_parent{i} = mk_msg(msg_type, ns(p)); | |
102 end | |
103 | |
104 cs = children(dag, n); | |
105 msg{n}.lambda_from_child = cell(1, length(cs)); | |
106 for i=1:length(cs) | |
107 c = cs(i); | |
108 msg{n}.lambda_from_child{i} = mk_msg(msg_type, ns(n), lam_msg); | |
109 end | |
110 | |
111 msg{n}.lambda = mk_msg(msg_type, ns(n), lam_msg); | |
112 msg{n}.pi = mk_msg(msg_type, ns(n)); | |
113 | |
114 if observed(n) | |
115 msg{n}.lambda_from_self = mk_msg_with_evidence(msg_type, ns(n), evidence{n}); | |
116 else | |
117 msg{n}.lambda_from_self = mk_msg(msg_type, ns(n), lam_msg); | |
118 end | |
119 end | |
120 | |
121 | |
122 | |
123 %%%%%%%%% | |
124 | |
125 function msg = mk_msg(msg_type, sz, is_lambda_msg) | |
126 | |
127 if nargin < 3, is_lambda_msg = 0; end | |
128 | |
129 switch msg_type | |
130 case 'd', msg = ones(sz, 1); | |
131 case 'g', | |
132 if is_lambda_msg | |
133 msg.precision = zeros(sz, sz); | |
134 msg.info_state = zeros(sz, 1); | |
135 else | |
136 msg.Sigma = zeros(sz, sz); | |
137 msg.mu = zeros(sz,1); | |
138 end | |
139 end | |
140 | |
141 %%%%%%%%%%%% | |
142 | |
143 function msg = mk_msg_with_evidence(msg_type, sz, val) | |
144 | |
145 switch msg_type | |
146 case 'd', | |
147 msg = zeros(sz, 1); | |
148 msg(val) = 1; | |
149 case 'g', | |
150 %msg.observed_val = val(:); | |
151 msg.precision = inf; | |
152 msg.mu = val(:); | |
153 end |