class UniformMask(parameter.Parameter): _size = len(mask) #size _prior = parameter.Function(UniformMaskPrior, pmin=pmin, pmax=pmax, mask=mask) _sampler = staticmethod(UniformMaskSampler) _typename = parameter._argrepr("UniformMask", pmin=pmin, pmax=pmax, mask=mask)
class InvGamma(parameter.Parameter): _size = size _prior = parameter.Function(InvGammaPrior, alpha=alpha, gamma=gamma) _sampler = staticmethod(InvGammaSampler) _alpha = alpha _gamma = gamma def __repr__(self): return '"{}": InvGamma({},{})'.format(self.name, alpha, gamma) + ( "" if self._size is None else "[{}]".format(self._size) )
def test_powerlaw(self): def powerlaw(f, log10_A=-15): return (10**log10_A) * f**2 pl = parameter.Function(powerlaw, log10_A=parameter.Uniform(0, 5)) pl1 = pl('pl1') repr_A = 'pl1(pl1_log10_A:Uniform(pmin=0, pmax=5))' repr_B = 'pl1(pl1_log10_A:Uniform(pmax=5, pmin=0))' assert str(pl1) == repr_A or str(pl1) == repr_B fs = np.array([1, 2, 3]) assert np.allclose(pl1(fs), np.array([1e-15, 4e-15, 9e-15])) assert np.allclose(pl1(fs, log10_A=-16), np.array([1e-16, 4e-16, 9e-16])) assert np.allclose(pl1(fs, params={'pl1_log10_A': -17}), np.array([1e-16, 4e-16, 9e-16])) def log10(A=10**-16): return np.log10(A) log10f = parameter.Function(log10, A=parameter.Uniform(10**-17, 10**-14)) pm = parameter.Function(powerlaw, log10_A=log10f) pm1 = pm('pm1') repr_A = 'pm1(pm1_log10_A_A:Uniform(pmin=1e-17, pmax=1e-14))' repr_B = 'pm1(pm1_log10_A_A:Uniform(pmax=1e-14, pmin=1e-17))' assert str(pm1) == repr_A or str(pm1) == repr_B assert np.allclose(pm1(fs, log10_A=-13), np.array([1e-13, 4e-13, 9e-13])) assert np.allclose(pm1(fs, params={'pm1_log10_A_A': 10**-19}), np.array([1e-19, 4e-19, 9e-19]))
def test_Function_of_Function(self): def doub(x): return 2 * x f = parameter.Function(doub, x=parameter.Uniform(0, 1)) def mult(a, w=2, z=1): return a * w * z g = parameter.Function(mult, w=parameter.Uniform(2, 3), z=f) g1 = g('g1') repr_A = 'g1_w:Uniform(pmin=2, pmax=3)' repr_B = 'g1_w:Uniform(pmax=3, pmin=2)' assert isinstance(g1, parameter.FunctionBase) assert (sorted(map(str, g1.params))[0] == repr_A or sorted(map(str, g1.params))[0] == repr_B) assert g1(2, z=3) == 12 assert g1(2, w=10, z=3) == 60 assert g1(2, params={'g1_z_x': 5, 'g1_w': 10}) == 200
def __init__(self, psr): super(BasisCommonGP, self).__init__(psr) self.name = self.psrname + "_" + self.signal_id pname = "_".join([psr.name, name]) self._bases = basisFunction(pname, psr=psr) self._params, self._coefficients = {}, {} for par in itertools.chain(self._prior._params.values(), self._orf._params.values(), self._bases._params.values()): self._params[par.name] = par rand_state = np.int(np.abs(np.sum(psr.pos)) * 10000) ra = uniform.rvs(loc=0, scale=2 * np.pi, random_state=rand_state) dec = cosine.rvs(loc=0, scale=0.5, random_state=rand_state + 11) newpos = np.array(SkyCoord(ra=ra*u.rad, \ dec=dec*u.rad).cartesian.xyz) self._psrpos = psr.pos self._psrpos_scrambled = newpos if coefficients: self._construct_basis() # if we're given an instantiated coefficient vector # that's what we will use if isinstance(coefficients, parameter.Parameter): self._coefficients[""] = coefficients self._params[coefficients.name] = coefficients return chain = itertools.chain(self._prior._params.values(), self._orf._params.values(), self._bases._params.values()) priorargs = {par.name: self._params[par.name] for par in chain} logprior = parameter.Function(self._get_coefficient_logprior, **priorargs) size = self._basis.shape[1] cpar = parameter.GPCoefficients( logprior=logprior, size=size)(pname + "_coefficients") self._coefficients[""] = cpar self._params[cpar.name] = cpar
def _do_selection(self, psr, priorfn, basisfn, coefficients, selection): sel = selection(psr) self._keys = list(sorted(sel.masks.keys())) self._masks = [sel.masks[key] for key in self._keys] self._prior, self._bases = {}, {} self._params, self._coefficients = {}, {} for key, mask in zip(self._keys, self._masks): pnames = [psr.name, name, key] pname = '_'.join([n for n in pnames if n]) self._prior[key] = priorfn(pname, psr=psr) self._bases[key] = basisfn(pname, psr=psr) for par in itertools.chain(self._prior[key]._params.values(), self._bases[key]._params.values()): self._params[par.name] = par if coefficients and pyv3: # we can only create GPCoefficients parameters if the basis # can be constructed with default arguments # (and does not change size) self._construct_basis() for key in self._keys: pname = '_'.join([n for n in [psr.name, name, key] if n]) chain = itertools.chain(self._prior[key]._params.values(), self._bases[key]._params.values()) priorargs = { par.name: self._params[par.name] for par in chain } logprior = parameter.Function( functools.partial(self._get_coefficient_logprior, key), **priorargs) size = self._slices[key].stop - self._slices[key].start cpar = parameter.GPCoefficients(logprior=logprior, size=size)(pname + '_coefficients') self._coefficients[key] = cpar self._params[cpar.name] = cpar
def test_powerlaw_equad(self): def powerlaw(f, log10_A=-15): return (10**log10_A) * f**2 def log10(A=10**-16): return np.log10(A) fquad = white_signals.EquadNoise(log10_equad=parameter.Function( log10, A=parameter.Uniform(10**-17, 10**-14))) fquad1 = fquad(self.psr) repr_A = '[B1855+09_log10_equad_A:Uniform(pmin=1e-17, pmax=1e-14)]' repr_B = '[B1855+09_log10_equad_A:Uniform(pmax=1e-14, pmin=1e-17)]' assert str(fquad1.params) == repr_A or str(fquad1.params) == repr_B assert np.allclose( fquad1.get_ndiag(params={'B1855+09_log10_equad_A': 10**-14})[:3], np.array([1e-28, 1e-28, 1e-28]))
def __init__(self, psr): super(BasisCommonGP, self).__init__(psr) self.name = self.psrname + '_' + self.signal_id pname = '_'.join([psr.name, name]) self._bases = basisFunction(pname, psr=psr) self._params, self._coefficients = {}, {} for par in itertools.chain(self._prior._params.values(), self._orf._params.values(), self._bases._params.values()): self._params[par.name] = par self._psrpos = psr.pos if coefficients and pyv3: self._construct_basis() # if we're given an instantiated coefficient vector # that's what we will use if isinstance(coefficients, parameter.Parameter): self._coefficients[''] = coefficients self._params[coefficients.name] = coefficients return chain = itertools.chain(self._prior._params.values(), self._orf._params.values(), self._bases._params.values()) priorargs = {par.name: self._params[par.name] for par in chain} logprior = parameter.Function(self._get_coefficient_logprior, **priorargs) size = self._basis.shape[1] cpar = parameter.GPCoefficients( logprior=logprior, size=size)(pname + '_coefficients') self._coefficients[''] = cpar self._params[cpar.name] = cpar
def test_enterprise_Function(self): def add(a, x=1, y=2): return a + x + y x = parameter.Uniform(0, 1) f = parameter.Function(add, x=x) assert issubclass(f, parameter.FunctionBase) f1 = f('f1') repr_A = 'f1(f1_x:Uniform(pmin=0, pmax=1))' repr_B = 'f1(f1_x:Uniform(pmax=1, pmin=0))' assert isinstance(f1, parameter.FunctionBase) assert str(f1) == repr_A or str(f1) == repr_B assert len(f1.params) == 1 assert f1(2) == 5 assert f1(2, 0.5, 7) == 9.5 assert f1(2, x=0.5, y=7) == 9.5 assert f1(3, params={'f1_x': 4}) == 9
class ACE_SWEPAM_Parameter(parameter.Parameter): _size = size _typename = parameter._argrepr('ACE_SWEPAM') _prior = parameter.Function(ACE_SWEPAM_Prior) _sampler = staticmethod(ACE_SWEPAM_Sampler)
class Gamma(parameter.Parameter): _size = size _prior = parameter.Function(GammaPrior, a=a, loc=loc, scale=scale) _sampler = staticmethod(GammaSampler) _typename = parameter._argrepr("Gamma", a=a, loc=loc, scale=scale)