def __init__( self, shape: Union[int, List[int]], weight_posterior: Type[BaseDistribution] = Deterministic, bias_posterior: Type[BaseDistribution] = Deterministic, weight_prior: BaseDistribution = Normal(0, 1), bias_prior: BaseDistribution = Normal(0, 1), weight_initializer: Dict[str, Callable] = {"loc": xavier}, bias_initializer: Dict[str, Callable] = {"loc": xavier}, name="BatchNormalization", ): # Create the parameters self.weight = Parameter( shape=shape, posterior=weight_posterior, prior=weight_prior, initializer=weight_initializer, name=name + "_weight", ) self.bias = Parameter( shape=shape, posterior=bias_posterior, prior=bias_prior, initializer=bias_initializer, name=name + "_bias", )
def __init__(self): self.a_list = [ Parameter(name="TestParam4"), Parameter(name="TestParam5"), ] self.a_dict = { "a": Parameter(name="TestParam6"), "b": Parameter(name="TestParam7"), }
def __init__(self, d: int, heteroscedastic: bool = False): self.heteroscedastic = heteroscedastic if heteroscedastic: self.weights = Parameter([d, 2], name='weights') self.bias = Parameter([1, 1], name='bias') else: self.weights = Parameter([d, 1], name='weights') self.bias = Parameter([1, 1], name='bias') self.std = ScaleParameter([1, 1], name='std')
def __init__(self, d: int, d_o: int = 1, heteroscedastic: bool = False): self.heteroscedastic = heteroscedastic if heteroscedastic: self.d_o = d_o self.weights = Parameter([d, d_o * 2], name="weights") self.bias = Parameter([1, d_o * 2], name="bias") else: self.weights = Parameter([d, d_o], name="weights") self.bias = Parameter([1, d_o], name="bias") self.std = ScaleParameter([1, d_o], name="std")
def __init__(self): self.a_list = [ Parameter(name="TestParam5"), Parameter(name="TestParam6"), TestModule1(), ] self.a_dict = { "b": Parameter(name="TestParam7"), "a": Parameter(name="TestParam8"), "c": TestModule2(), }
def __init__(self, d_in: int, d_out: int = 1, name: str = "Dense"): # Check types if d_in < 1: raise ValueError("d_in must be >0") if d_out < 1: raise ValueError("d_out must be >0") # Create the parameters self.d_in = d_in self.d_out = d_out self.weights = Parameter(shape=[d_in, d_out], name=name + "_weights") self.bias = Parameter(shape=[1, d_out], name=name + "_bias")
def __init__(self, d_in: int, d_out: int = 1, name: str = 'Dense'): # Check types if d_in < 1: raise ValueError('d_in must be >0') if d_out < 1: raise ValueError('d_out must be >0') # Create the parameters self.d_in = d_in self.d_out = d_out self.weights = Parameter(shape=[d_in, d_out], name=name+'_weights') self.bias = Parameter(shape=[1, d_out], name=name+'_bias')
def __init__( self, k: Union[int, List[int]], d: Union[int, List[int]], posterior: Type[BaseDistribution] = Deterministic, prior: BaseDistribution = Normal(0, 1), initializer: Dict[str, Callable] = {"loc": xavier}, name: str = "Embedding", ): # Convert to list if not already if isinstance(k, int): k = [k] if isinstance(d, int): d = [d] # Check values if len(k) != len(d): raise ValueError("d and k must be the same length") if any(e < 1 for e in k): raise ValueError("k must be >0") if any(e < 1 for e in d): raise ValueError("d must be >0") # Create the parameters self.embeddings = [ Parameter( shape=[k[i], d[i]], posterior=posterior, prior=prior, initializer=initializer, name=name + "_" + str(i), ) for i in range(len(d)) ]
def test_Parameter_1D(): """Tests a 1D Parameter""" # Create 1D parameter param = Parameter(shape=5) # kl_loss should still be scalar kl_loss = param.kl_loss() assert isinstance(kl_loss, tf.Tensor) assert kl_loss.ndim == 0 # posterior_mean should return mean sample1 = param.posterior_mean() sample2 = param.posterior_mean() assert sample1.ndim == 1 assert sample2.ndim == 1 assert sample1.shape[0] == 5 assert sample2.shape[0] == 5 assert np.all(sample1 == sample2) # posterior_sample should return samples sample1 = param.posterior_sample() sample2 = param.posterior_sample() assert sample1.ndim == 1 assert sample2.ndim == 1 assert sample1.shape[0] == 5 assert sample2.shape[0] == 5 assert np.all(sample1 != sample2) # posterior_sample should be able to return multiple samples sample1 = param.posterior_sample(10) sample2 = param.posterior_sample(10) assert sample1.ndim == 2 assert sample2.ndim == 2 assert sample1.shape[0] == 10 assert sample1.shape[1] == 5 assert sample2.shape[0] == 10 assert sample2.shape[1] == 5 assert np.all(sample1 != sample2) # prior_sample should still be 1D prior_sample = param.prior_sample() assert prior_sample.ndim == 0 prior_sample = param.prior_sample(n=7) assert prior_sample.ndim == 1 assert prior_sample.shape[0] == 7 # n_parameters property nparams = param.n_parameters assert isinstance(nparams, int) assert nparams == 5
def test_Parameter_no_prior(): """Tests a parameter with no prior""" # Create parameter with no prior param = Parameter(prior=None) # kl_loss should return 0 kl_loss = param.kl_loss() assert isinstance(kl_loss, tf.Tensor) assert kl_loss.ndim == 0 assert kl_loss.numpy() == 0.0 # prior_sample should return nans with prior=None prior_sample = param.prior_sample() assert prior_sample.ndim == 1 assert prior_sample.shape[0] == 1 assert np.all(np.isnan(prior_sample)) prior_sample = param.prior_sample(n=7) assert prior_sample.ndim == 1 assert prior_sample.shape[0] == 7 assert np.all(np.isnan(prior_sample))
def test_Parameter_float_initializer(): """Tests a 2D Parameter with a float initializer""" # Create 1D parameter param = Parameter(shape=[5, 4], name="lala2", initializer={ "loc": 1.0, "scale": 2.0 }) # all should have been initialized to 1 vals = param() assert np.all(vals == 1.0)
def test_Deterministic(): """Tests Deterministic distribution""" # Create the distribution dist = Deterministic() # Check default params assert dist.loc == 0 # Call should return backend obj assert isinstance(dist(), tfd.Deterministic) # Test methods assert dist.prob(0).numpy() == 1.0 assert dist.prob(1).numpy() == 0.0 assert dist.log_prob(0).numpy() == 0.0 assert dist.log_prob(1).numpy() == -np.inf assert dist.mean().numpy() == 0.0 assert dist.mode().numpy() == 0.0 assert dist.cdf(-1).numpy() == 0.0 assert dist.cdf(1).numpy() == 1.0 # Test sampling samples = dist.sample() assert isinstance(samples, tf.Tensor) assert samples.ndim == 0 samples = dist.sample(10) assert isinstance(samples, tf.Tensor) assert samples.ndim == 1 assert samples.shape[0] == 10 samples = dist.sample(tf.constant([10])) assert isinstance(samples, tf.Tensor) assert samples.ndim == 1 assert samples.shape[0] == 10 # Should be able to set params dist = Deterministic(loc=3) assert dist.loc == 3 # But only with Tensor-like objs with pytest.raises(TypeError): dist = Deterministic(loc="lalala") # Test using a parameter as an argument p = Parameter() dist = Deterministic(loc=p) dist.sample()
def __init__(self, k: int, d: int, posterior: Type[BaseDistribution] = Deterministic, prior: BaseDistribution = Normal(0, 1), initializer: Dict[str, Callable] = {'loc': xavier}, name: str = 'Embeddings'): # Check types if k < 1: raise ValueError('k must be >0') if d < 1: raise ValueError('d must be >0') # Create the parameters self.embeddings = Parameter(shape=[k, d], posterior=posterior, prior=prior, initializer=initializer, name=name)
def test_Parameter_slicing(): """Tests a slicing Parameters""" # Create 1D parameter param = Parameter(shape=[2, 3, 4, 5]) # Should be able to slice! sl = param[0].numpy() assert sl.ndim == 4 assert sl.shape[0] == 1 assert sl.shape[1] == 3 assert sl.shape[2] == 4 assert sl.shape[3] == 5 sl = param[:, :, :, :2].numpy() assert sl.ndim == 4 assert sl.shape[0] == 2 assert sl.shape[1] == 3 assert sl.shape[2] == 4 assert sl.shape[3] == 2 sl = param[1, ..., :2].numpy() assert sl.ndim == 4 assert sl.shape[0] == 1 assert sl.shape[1] == 3 assert sl.shape[2] == 4 assert sl.shape[3] == 2 sl = param[...].numpy() assert sl.ndim == 4 assert sl.shape[0] == 2 assert sl.shape[1] == 3 assert sl.shape[2] == 4 assert sl.shape[3] == 5 sl = param[tf.constant([0]), :, ::2, :].numpy() assert sl.ndim == 4 assert sl.shape[0] == 1 assert sl.shape[1] == 3 assert sl.shape[2] == 2 assert sl.shape[3] == 5
def __init__(self, shape): self.mod = TestModule() self.p3 = Parameter(name="TestParam3", shape=shape)
def test_Parameter_posterior_ci(): """Tests probflow.parameters.Parameter.posterior_ci""" # With a scalar parameter param = Parameter() lb, ub = param.posterior_ci() assert isinstance(lb, np.ndarray) assert isinstance(ub, np.ndarray) assert lb.ndim == 1 assert ub.ndim == 1 assert lb.shape[0] == 1 assert ub.shape[0] == 1 # Should error w/ invalid ci or n vals with pytest.raises(ValueError): lb, ub = param.posterior_ci(ci=-0.1) with pytest.raises(ValueError): lb, ub = param.posterior_ci(ci=1.1) with pytest.raises(ValueError): lb, ub = param.posterior_ci(n=0) # With a 1D parameter param = Parameter(shape=5) lb, ub = param.posterior_ci() assert isinstance(lb, np.ndarray) assert isinstance(ub, np.ndarray) assert lb.ndim == 1 assert ub.ndim == 1 assert lb.shape[0] == 5 assert ub.shape[0] == 5 # With a 2D parameter param = Parameter(shape=[5, 4]) lb, ub = param.posterior_ci() assert isinstance(lb, np.ndarray) assert isinstance(ub, np.ndarray) assert lb.ndim == 2 assert ub.ndim == 2 assert lb.shape[0] == 5 assert lb.shape[1] == 4 assert ub.shape[0] == 5 assert ub.shape[1] == 4
def __init__(self): self.weight = Parameter(name="Weight") self.bias = Parameter(name="Bias") self.std = ScaleParameter(name="Std")
def __init__(self, d: int): self.weights = Parameter([d, 1], name='weights') self.bias = Parameter(name='bias') self.std = ScaleParameter(name='std')
def __init__(self): self.weight = Parameter([5, 1], name="Weight") self.bias = Parameter([1, 1], name="Bias")
def __init__(self, d_in, d_out): self.weight = Parameter([d_in, d_out], name="Weight") self.bias = Parameter([1, d_out], name="Bias") self.std = ScaleParameter([1, d_out], name="Std")
def __init__(self): self.mean = Parameter([1], name="Mean") self.std = ScaleParameter([1], name="Std")
def __init__(self, cols): self.cols = cols self.weight = Parameter([len(cols), 1], name="Weight") self.bias = Parameter([1, 1], name="Bias") self.std = ScaleParameter([1, 1], name="Std")
def __init__(self): self.weight = Parameter([5, 1], name="Weight") self.bias = Parameter([1, 1], name="Bias") self.act = torch.nn.Softplus()
def __init__(self, d: int): self.weights = Parameter([d, 1], name='weights') self.bias = Parameter([1, 1], name='bias')
def __init__(self, d: int, k: int = 2): self.weights = Parameter([d, k - 1], name='weights') self.bias = Parameter([1, k - 1], name='bias')
def test_Parameter_2D(): """Tests a 2D Parameter""" # Create 1D parameter param = Parameter(shape=[5, 4], name="lala") # repr pstr = param.__repr__() assert pstr == "<pf.Parameter lala shape=[5, 4]>" # kl_loss should still be scalar kl_loss = param.kl_loss() assert isinstance(kl_loss, tf.Tensor) assert kl_loss.ndim == 0 # posterior_mean should return mean sample1 = param.posterior_mean() sample2 = param.posterior_mean() assert sample1.ndim == 2 assert sample2.ndim == 2 assert sample1.shape[0] == 5 assert sample1.shape[1] == 4 assert sample2.shape[0] == 5 assert sample2.shape[1] == 4 assert np.all(sample1 == sample2) # posterior_sample should return samples sample1 = param.posterior_sample() sample2 = param.posterior_sample() assert sample1.ndim == 2 assert sample2.ndim == 2 assert sample1.shape[0] == 5 assert sample1.shape[1] == 4 assert sample2.shape[0] == 5 assert sample2.shape[1] == 4 assert np.all(sample1 != sample2) # posterior_sample should be able to return multiple samples sample1 = param.posterior_sample(10) sample2 = param.posterior_sample(10) assert sample1.ndim == 3 assert sample2.ndim == 3 assert sample1.shape[0] == 10 assert sample1.shape[1] == 5 assert sample1.shape[2] == 4 assert sample2.shape[0] == 10 assert sample2.shape[1] == 5 assert sample2.shape[2] == 4 assert np.all(sample1 != sample2) # prior_sample should still be 1D prior_sample = param.prior_sample() assert prior_sample.ndim == 0 prior_sample = param.prior_sample(n=7) assert prior_sample.ndim == 1 assert prior_sample.shape[0] == 7 # n_parameters property nparams = param.n_parameters assert isinstance(nparams, int) assert nparams == 20
def __init__(self): self.p1 = Parameter(name="TestParam1") self.p2 = Parameter(name="TestParam2", shape=[5, 4])
def __init__(self, d: int): self.weights = Parameter([d, 1], name="weights") self.bias = Parameter([1, 1], name="bias")
def __init__(self): initializer = {"loc": 0, "scale": 0.01} self.weight = Parameter(name="Weight", initializer=initializer) self.bias = Parameter(name="Bias", initializer=initializer)
def __init__(self, d: int, k: int = 2): self.weights = Parameter([d, k - 1], name="weights") self.bias = Parameter([1, k - 1], name="bias")