class TestBernoulliClass(unittest.TestCase): def setUp(self): self.bernoulli = Bernoulli('numbers_binomial.txt') def test_readdata(self): self.assertEqual(self.bernoulli.data,\ [0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0], 'data not read in correctly') def test_meancalculation(self): mean = self.bernoulli.calculate_mean() self.assertEqual(round(mean, 1), 0.6, 'calculated mean not as expected') def test_stdevcalculation(self): stdev = self.bernoulli.calculate_stdev() self.assertEqual( round(stdev, 2), 0.49, 'calculated standard deviation \ not as expected') def test_pmf(self): self.assertEqual( round(self.bernoulli.pmf(1), 3), 0.615, 'propability\ mass function not as expected') self.assertEqual( round(self.bernoulli.pmf(0), 3), 0.385, 'propability\ mass function not as expected') def test_def(self): self.assertEqual(str(self.bernoulli), "Propability of success p {}, propability of failure q {}" .\ format(0.62, 0.38),'Parameters of the Bernoulli not as expected')
def __init__(self, obs_shape, action_space, base=None, base_kwargs=None): super(Policy, self).__init__() if base_kwargs is None: base_kwargs = {} if base is None: if len(obs_shape) == 3: base = CNNBase elif len(obs_shape) == 1: base = MLPBase else: raise NotImplementedError self.base = base(obs_shape[0], **base_kwargs) if action_space.__class__.__name__ == "Discrete": num_outputs = action_space.n num_action_outputs = 512 self.dist = Categorical(num_action_outputs,num_outputs) elif action_space.__class__.__name__ == "Box": num_outputs = action_space.shape[0] self.dist = DiagGaussian(self.base.output_size, num_outputs) elif action_space.__class__.__name__ == "MultiBinary": num_outputs = action_space.shape[0] self.dist = Bernoulli(self.base.output_size, num_outputs) else: raise NotImplementedError
def test_init_with_errors(self): params = ( None, '-3', '3', '-0.2', 'string', ) for param in params: with self.assertRaises(ValueError): Bernoulli(param)
def test_bernoulli(): bernoulli = Bernoulli(3) new_p = np.array([[0.5, 0.5, 0.5], [.9, .9, .9]], dtype=np.float32) old_p = np.array([[.9, .9, .9], [.1, .1, .1]], dtype=np.float32) x = np.array([[1, 0, 1], [1, 1, 1]], dtype=np.float32) x_sym = tf.constant(x) new_p_sym = tf.constant(new_p) old_p_sym = tf.constant(old_p) new_info = dict(p=new_p) old_info = dict(p=old_p) new_info_sym = dict(p=new_p_sym) old_info_sym = dict(p=old_p_sym) # np.testing.assert_allclose( # np.sum(bernoulli.entropy(dist_info=new_info)), # np.sum(- new_p * np.log(new_p + 1e-8) - (1 - new_p) * np.log(1 - new_p + 1e-8)), # ) # np.testing.assert_allclose( # np.sum(bernoulli.kl(old_info_sym, new_info_sym).eval()), # np.sum(old_p * (np.log(old_p + 1e-8) - np.log(new_p + 1e-8)) + (1 - old_p) * (np.log(1 - old_p + 1e-8) - # np.log(1 - new_p + 1e-8))), # ) # np.testing.assert_allclose( # np.sum(bernoulli.kl(old_info, new_info)), # np.sum(old_p * (np.log(old_p + 1e-8) - np.log(new_p + 1e-8)) + (1 - old_p) * (np.log(1 - old_p + 1e-8) - # np.log(1 - new_p + 1e-8))), # ) # np.testing.assert_allclose( # bernoulli.likelihood_ratio_sym(x_sym, old_info_sym, new_info_sym).eval(), # np.prod((x * new_p + (1 - x) * (1 - new_p)) / (x * old_p + (1 - x) * (1 - old_p) + 1e-8), axis=-1) # ) np.testing.assert_allclose( bernoulli.logli(x_sym, old_info_sym).eval(session=sess), np.sum(x * np.log(old_p + 1e-8) + (1 - x) * np.log(1 - old_p + 1e-8), axis=-1))
def __init__(self, obs_shape, action_space, base_kwargs=None): super(Policy, self).__init__() if base_kwargs is None: base_kwargs = {} base = MLPBase # print(base_kwargs) self.base = base(obs_shape[0], **base_kwargs) # ss('making policy') if action_space.__class__.__name__ == "Discrete": num_outputs = action_space.n self.dist = Categorical(self.base.output_size, num_outputs) elif action_space.__class__.__name__ == "Box": num_outputs = action_space.shape[0] self.dist = DiagGaussian(self.base.output_size, num_outputs) elif action_space.__class__.__name__ == "MultiBinary": num_outputs = action_space.shape[0] self.dist = Bernoulli(self.base.output_size, num_outputs) else: raise NotImplementedError
class TestBernoulli(unittest.TestCase): def setUp(self): self.distribution = Bernoulli(0.70) def test_init_with_errors(self): params = ( None, '-3', '3', '-0.2', 'string', ) for param in params: with self.assertRaises(ValueError): Bernoulli(param) def test_mean(self): mean = self.distribution.mean() self.assertEqual(mean, 0.69999999999999996) def test_variance(self): variance = self.distribution.variance() self.assertEqual(variance, 0.21000000000000002) def test_std(self): std = self.distribution.std() self.assertEqual(std, 0.45825756949558405) def test_cdf(self): cdf = self.distribution.cdf() self.assertEqual(cdf, 1.0) def test_pmf(self): pmf = self.distribution.pmf() self.assertEqual(pmf, 0.69999999999999996) def test_pmfs(self): t_pmfs = np.array([ 0.3, 0.7]) pmfs = self.distribution.pmfs() self.assertIsNotNone(pmfs) numpy_testing.assert_allclose(t_pmfs, pmfs)
def __construct__(self, arch): """ Construct the model from the architecture dictionary. :param arch: architecture dictionary :return None """ # these are the same across all latent levels encoding_form = arch['encoding_form'] variable_update_form = arch['variable_update_form'] const_prior_var = arch['constant_prior_variances'] posterior_form = arch['posterior_form'] latent_level_type = RecurrentLatentLevel if arch['encoder_type'] == 'recurrent' else DenseLatentLevel encoder_arch = None if arch['encoder_type'] == 'inference_model': encoder_arch = dict() encoder_arch['non_linearity'] = arch['non_linearity_enc'] encoder_arch['connection_type'] = arch['connection_type_enc'] encoder_arch['batch_norm'] = arch['batch_norm_enc'] encoder_arch['weight_norm'] = arch['weight_norm_enc'] encoder_arch['dropout'] = arch['dropout_enc'] decoder_arch = dict() decoder_arch['non_linearity'] = arch['non_linearity_dec'] decoder_arch['connection_type'] = arch['connection_type_dec'] decoder_arch['batch_norm'] = arch['batch_norm_dec'] decoder_arch['weight_norm'] = arch['weight_norm_dec'] decoder_arch['dropout'] = arch['dropout_dec'] # construct a DenseLatentLevel for each level of latent variables for level in range(len(arch['n_latent'])): # get specifications for this level's encoder and decoder if arch['encoder_type'] == 'inference_model': encoder_arch['n_in'] = self.encoder_input_size(level, arch) encoder_arch['n_units'] = arch['n_units_enc'][level] encoder_arch['n_layers'] = arch['n_layers_enc'][level] decoder_arch['n_in'] = self.decoder_input_size(level, arch) decoder_arch['n_units'] = arch['n_units_dec'][level+1] decoder_arch['n_layers'] = arch['n_layers_dec'][level+1] n_latent = arch['n_latent'][level] n_det = [arch['n_det_enc'][level], arch['n_det_dec'][level]] learn_prior = True if arch['learn_top_prior'] else (level != len(arch['n_latent'])-1) self.levels[level] = latent_level_type(self.batch_size, encoder_arch, decoder_arch, n_latent, n_det, encoding_form, const_prior_var, variable_update_form, posterior_form, learn_prior) # construct the output decoder decoder_arch['n_in'] = self.decoder_input_size(-1, arch) decoder_arch['n_units'] = arch['n_units_dec'][0] decoder_arch['n_layers'] = arch['n_layers_dec'][0] self.output_decoder = MultiLayerPerceptron(**decoder_arch) # construct the output distribution if self.output_distribution == 'bernoulli': self.output_dist = Bernoulli(self.input_size, None) self.mean_output = Dense(arch['n_units_dec'][0], self.input_size, non_linearity='sigmoid', weight_norm=arch['weight_norm_dec']) elif self.output_distribution == 'multinomial': self.output_dist = Multinomial(self.input_size, None) self.mean_output = Dense(arch['n_units_dec'][0], self.input_size, non_linearity='linear', weight_norm=arch['weight_norm_dec']) elif self.output_distribution == 'gaussian': self.output_dist = DiagonalGaussian(self.input_size, None, None) self.mean_output = Dense(arch['n_units_dec'][0], self.input_size, non_linearity='sigmoid', weight_norm=arch['weight_norm_dec']) if self.constant_variances: if arch['single_output_variance']: self.trainable_log_var = Variable(torch.zeros(1), requires_grad=True) else: self.trainable_log_var = Variable(torch.normal(torch.zeros(self.input_size), 0.25), requires_grad=True) else: self.log_var_output = Dense(arch['n_units_dec'][0], self.input_size, weight_norm=arch['weight_norm_dec']) # make the state trainable if encoder_type is EM if arch['encoder_type'] in ['em', 'EM']: self.trainable_state()
def setUp(self): self.bernoulli = Bernoulli('numbers_binomial.txt')
def setUp(self): self.distribution = Bernoulli(0.70)
print '%d: %d' % (d, image_counts[d]) print # Initialize summary image summary = Image.new('L', (28 * num_components + 65, 28 * len(num_blocks)), 255) # Do inference for varying numbers of blocks idxs = np.argsort(map(np.sum, emissions)) reps = [] for block_i, num_block in enumerate(num_blocks): # Block data blocks = np.array_split(idxs, num_block) # Run EM results = em(emissions, [ Product([Bernoulli() for i in range(28 * 28)]) for n in range(num_components) ], count_restart=3.0, blocks=blocks, gamma_seed=137, init_gamma=(init_to_labels and labels or None)) dists = results['dists'] print 'Reps: %d' % results['reps'] reps.append(results['reps']) # Produce summary image offset = 0 im = Image.new('L', (28 * len(dists), 28)) for d in results['dists']: digit = Image.new('L', (28, 28))
id, True, Gaussian(ldata['new_node_rate_mean'], ldata['new_node_rate_variance']), Uniform_Discrete(ldata['time_to_stay_min'], ldata['time_to_stay_max']))) num_left_classes = len(phase_data['left_classes']) for (id, ldata) in enumerate(phase_data['right_classes']): phase_env_classes.append( Class_Env( id + num_left_classes, False, Gaussian(ldata['new_node_rate_mean'], ldata['new_node_rate_variance']), Uniform_Discrete(ldata['time_to_stay_min'], ldata['time_to_stay_max']))) for (ids, edge_data) in phase_data['edge_data'].items(): class_edge = Class_Env_Edge(Bernoulli(edge_data['mean']), edge_data['weight']) l_class = [c for c in phase_env_classes if c.id == ids[0]][0] r_class = [ c for c in phase_env_classes if c.id == ids[1] + num_left_classes ][0] l_class.set_edge_data(r_class, class_edge) r_class.set_edge_data(l_class, class_edge) env_classes.append(phase_env_classes) environment = Environment(env_classes) # ------------------------------------ # Instantiate the main Graph