def runTest(self): num_vars = 5 num_vals = 10 for x in xrange(num_runs): vs = dict([('V'+str(i),range(num_vals)) for i in xrange(num_vars)]) # should get some random data with 0. f = Factor(variables = vs.keys() ,data = [abs(randint(0,20)) for i in xrange(num_vals**num_vars)] #,data = [5, 0, 1, 2] #,data = [13,0,0,20] #,data = [14,15,20,16] ,domain = Domain() ,new_domain_variables=vs ,check = True) records = [] for inst in f.insts(): records.append(inst + (f[inst],)) rawdata = (vs.keys(), vs, vs.keys(), records) #print records cf = IncrementalCompactFactor(rawdata, rmin=0) #print 'old tree:' #print cf # g = Factor(variables = vs.keys() # #,data = [13,2,0,0] # ,data = [14,15,0,0] # ,domain = Domain() # ,new_domain_variables=vs # ,check = True) g = f.copy(copy_domain=True) def swap_some(x): r = random() if x == 0: if r <= 0.5: return randint(1,5) return 0 elif r <= 0.5: return 0 return x def invert_some(x): return 5-x g.map(swap_some) #print g f += g records = [] for inst in g.insts(): records.append(inst + (g[inst],)) rawdata = (vs.keys(), vs, vs.keys(), records) cf.update(rawdata) #print 'new tree:' #print cf for variables in powerset(vs.keys()): g = f.copy(copy_domain=True) g.marginalise_away(g.variables() - frozenset(variables)) self.assert_(same_factor(g,cf.makeFactor(variables),verbose=True))
def observe(self, num_samples, skip=0): """Draw C{num_samples} observational samples, separated by C{skip} steps of the sampler. These samples are appended to any existing observational samples and then returned. @return: L{IncrementalCompactFactor} """ samples = self._pure_sampler.samples(num_samples,skip) if self._data is None: self._data = IncrementalCompactFactor(samples,domain=Domain()) else: self._data.update(samples) return self._data
def runTest(self): num_vars = 5 num_vals = 10 for i in xrange(num_runs): vs = dict([('V'+str(i),range(num_vals)) for i in xrange(num_vars)]) # should get some random data with 0. f = Factor(variables = vs.keys() ,data = [abs(randint(0,5)) for i in xrange(num_vals**num_vars)] ,domain = Domain() ,new_domain_variables=vs ,check = True) records = [] for inst in f.insts(): records.append(inst + (f[inst],)) rawdata = (vs.keys(), vs, vs.keys(), records) cf = IncrementalCompactFactor(rawdata) for variables in powerset(vs.keys()): g = f.copy(copy_domain=True) g.marginalise_away(g.variables() - frozenset(variables)) self.assert_(same_factor(g,cf.makeFactor(variables),verbose=True))
def tryModel(self, model): # generate some samples cf = [] sampler = ForwardSampler(model) samples = sampler.samples(100) cf.append(CompactFactor(samples,domain=Domain())) icf = IncrementalCompactFactor(samples, domain=Domain()) for i in xrange(10): samples = sampler.samples(100) cf.append(CompactFactor(samples,domain=Domain())) icf.update(samples) # see if the sum of the CPT Factors in cf match that of icf for child in model.variables(): family = model.adg().parents(child) | set([child]) a = icf.makeFactor(family) b = cf[0].makeFactor(family) for f in cf[1:]: b += f.makeFactor(family) self.assert_(same_factor(a,b))
def query(self, intervention, num_samples,skip=0): """Draw C{num_samples} interventional samples, separated by C{skip} steps of the sampler. These samples are appended to any existing interventional samples and then returned. The intervention made is that of C{intervention}. @param intervention: A dictionary mapping variables in the L{CBN} to a single value in the domain. @return: L{IncrementalCompactFactor} """ k = frozenset(intervention.keys()) if not self._inter_sampler.has_key(k): do_model = CBN.from_bn(self._pure_model.copy(copy_domain=True)) do_model.intervene(intervention) self._inter_sampler[k] = GibbsSampler(do_model, self._burnin) do_sampler = self._inter_sampler[k] samples = do_sampler.samples(num_samples,skip) if not self._inter_data.has_key(k): self._inter_data[k] = IncrementalCompactFactor(samples,domain=Domain()) else: self._inter_data[k].update(samples) return self._inter_data[k]