def build_model(self, name='cot_uniform_model'): # Define Stochastic variables with pm.Model(name=name) as self.model: self.cot_phi = pm.Uniform('cot_phi_gal', lower=1, upper=4, shape=len(self.galaxies)) self.phi_gal = pm.Deterministic( 'phi_gal', 180 / np.pi * tt.arctan(1 / self.cot_phi)) # note we don't model inter-galaxy dispersion here # intra-galaxy dispersion self.sigma_gal = pm.InverseGamma('sigma_gal', alpha=2, beta=20, testval=5) # arm offset parameter self.c = pm.Cauchy('c', alpha=0, beta=10, shape=self.n_arms, testval=np.tile(0, self.n_arms)) # radial noise self.sigma_r = pm.InverseGamma('sigma_r', alpha=2, beta=0.5) # Define Dependent variables self.phi_arm = pm.TruncatedNormal( 'phi_arm', mu=self.phi_gal[self.gal_arm_map], sd=self.sigma_gal, lower=0, upper=90, shape=self.n_arms) # convert to a gradient for a linear fit self.b = tt.tan(np.pi / 180 * self.phi_arm) r = pm.Deterministic( 'r', tt.exp(self.b[self.data['arm_index'].values] * self.data['theta'] + self.c[self.data['arm_index'].values])) # likelihood function self.likelihood = pm.Normal( 'Likelihood', mu=r, sigma=self.sigma_r, observed=self.data['r'], )
def logp(self, value): """ Calculate log-probability of King distribution at specified value. Parameters ---------- value : numeric Value(s) for which log-probability is calculated. If the log probabilities for multiple values are desired the values must be provided in a numpy array or theano tensor Returns ------- TensorVariable """ r = (value - self.location) / self.scale v = 1.0 / tt.sqrt(1. + r**2) u = 1.0 / tt.sqrt(1. + self.rt**2) cte = 2 * self.scale * (self.rt / (1 + self.rt**2) + tt.arctan( self.rt) - 2. * tt.arcsinh(self.rt) / np.sqrt(1. + self.rt**2)) log_d = 2. * tt.log(v - u) - tt.log(cte) return tt.switch(tt.abs_(r) < self.rt, log_d, -1e20) #avoids inf in advi
def SQUASH(self, sample): """ Perform the boxing operation symbolically (see .squash). """ return 0.5 + tns.arctan(sample)/np.pi
def _model_setup(self): with self._model: # COSMOLOGY omega_m = pm.Uniform("OmegaM", lower=0, upper=1.) # Dark energy EOS w = pm.Normal("w", mu=-1, sd=1) # My custom distance mod. function to enable # ADVI and HMC smapling. dm = distmod_w_flat(omega_m, self._h0, w, self._zcmb) # PHILIPS PARAMETERS # M0 is the location parameter for the distribution # sys_scat is the scale parameter for the M0 distribution # rather than "unexpalined variance" M0 = pm.Uniform("M0", lower=-20., upper=-18.) sys_scat = pm.HalfCauchy('sys_scat', beta=2.5) # Gelman recommendation for variance parameter M_true = pm.Normal('M_true', M0, sys_scat, shape=self._n_SN) # following Rubin's Unity model... best idea? not sure taninv_alpha = pm.Uniform("taninv_alpha", lower=-.2, upper=.3) taninv_beta = pm.Uniform("taninv_beta", lower=-1.4, upper=1.4) # Transform variables alpha = pm.Deterministic('alpha', T.tan(taninv_alpha)) beta = pm.Deterministic('beta', T.tan(taninv_beta)) # Z correction parameters delta_beta = pm.Uniform('delta_beta', lower=-1.5, upper=1.5) zt = pm.Uniform('zt', lower=0.2, upper=1) # Again using Rubin's Unity model. # After discussion with Rubin, the idea is that # these parameters are ideally sampled from a Gaussian, # but we know they are not entirely correct. So instead, # the Cauchy is less informative around the mean, while # still having informative tails. xm = pm.Cauchy('xm', alpha=0, beta=1) cm = pm.Cauchy('cm', alpha=0, beta=1) Rx_log = pm.Uniform('Rx_log', lower=-0.5, upper=0.5) Rc_log = pm.Uniform('Rc_log', lower=-1.5, upper=1.5) # Transformed variables Rx = pm.Deterministic("Rx", T.pow(10., Rx_log)) Rc = pm.Deterministic("Rc", T.pow(10., Rc_log)) x_true = pm.Normal('x_true', mu=xm, sd=Rx, shape=self._n_SN) c_true = pm.Normal('c_true', mu=cm, sd=Rc, shape=self._n_SN) # Do the correction mb = pm.Deterministic("mb", M_true + dm - alpha * x_true + beta * c_true + delta_beta * ( 0.5 + 1. / np.pi * T.arctan((self._zcmb - zt) / 0.01)) * c_true) # Likelihood and measurement error obsc = pm.Normal("obsc", mu=c_true, sd=self._dcolor, observed=self._color) obsx = pm.Normal("obsx", mu=x_true, sd=self._dx1, observed=self._x1) obsm = pm.Normal("obsm", mu=mb, sd=self._dmb_obs, observed=self._mb_obs)
def recurrence(x_t, h_prev, theta, V_re, V_im, hidden_bias, scale): def scale_diag(input, n_hidden, diag): input_re = input[:, :n_hidden] input_im = input[:, n_hidden:] Diag = T.nlinalg.AllocDiag()(diag) input_re_times_Diag = T.dot(input_re, Diag) input_im_times_Diag = T.dot(input_im, Diag) return T.concatenate([input_re_times_Diag, input_im_times_Diag], axis=1) def times_diag(input, n_hidden, diag): input_re = input[:, :n_hidden] input_im = input[:, n_hidden:] Re = T.nlinalg.AllocDiag()(T.cos(diag)) Im = T.nlinalg.AllocDiag()(T.sin(diag)) input_re_times_Re = T.dot(input_re, Re) input_re_times_Im = T.dot(input_re, Im) input_im_times_Re = T.dot(input_im, Re) input_im_times_Im = T.dot(input_im, Im) return T.concatenate([input_re_times_Re - input_im_times_Im, input_re_times_Im + input_im_times_Re], axis=1) def vec_permutation(input, n_hidden, index_permute): re = input[:, :n_hidden] im = input[:, n_hidden:] re_permute = re[:, index_permute] im_permute = im[:, index_permute] return T.concatenate([re_permute, im_permute], axis=1) def times_reflection(input, n_hidden, reflection): input_re = input[:, :n_hidden] input_im = input[:, n_hidden:] reflect_re = reflection[n_hidden:] reflect_im = reflection[:n_hidden] vstarv = (reflect_re**2 + reflect_im**2).sum() input_re_reflect = input_re - 2 / vstarv * (T.outer(T.dot(input_re, reflect_re), reflect_re) + T.outer(T.dot(input_im, reflect_im), reflect_im)) input_im_reflect = input_im - 2 / vstarv * (-T.outer(T.dot(input_re, reflect_im), reflect_im) + T.outer(T.dot(input_im, reflect_re), reflect_re)) return T.concatenate([input_re_reflect, input_im_reflect], axis=1) # Compute hidden linear transform step1 = times_diag(h_prev, n_hidden, theta[0,:]) step2 = times_reflection(step1, n_hidden, reflection[0,:]) step3 = vec_permutation(step2, n_hidden, index_permute) step4 = times_diag(step3, n_hidden, theta[1,:]) step5 = times_reflection(step4, n_hidden, reflection[1,:]) step6 = times_diag(step5, n_hidden, theta[2,:]) step7 = scale_diag(step6, n_hidden, scale) hidden_lin_output = step7 # Compute data linear transform data_lin_output_re = T.dot(x_t, V_re) data_lin_output_im = T.dot(x_t, V_im) data_lin_output = T.concatenate([data_lin_output_re, data_lin_output_im], axis=1) # Total linear output lin_output = hidden_lin_output + data_lin_output lin_output_re = lin_output[:, :n_hidden] lin_output_im = lin_output[:, n_hidden:] # Apply non-linearity ---------------------------- # nonlinear mod and phase operations lin_output_mod = T.sqrt(lin_output_re ** 2 + lin_output_im ** 2) lin_output_phase = T.arctan(lin_output_im / (lin_output_re + 1e-5)) nonlin_output_mod = T.maximum(lin_output_mod + hidden_bias.dimshuffle('x',0), 0.) \ / (lin_output_mod + 1e-5) warp_phase_params = T.tanh(phase_params) warp_phase_x = warp_phase_params[:n_hidden] * np.pi / 2 warp_phase_y = warp_phase_params[n_hidden:] * np.pi / 2 m1 = (warp_phase_y - 0.5 * np.pi) / (warp_phase_x - 0.5 * np.pi + 1e-5) m2 = (warp_phase_y + 0.5 * np.pi) / (warp_phase_x + 0.5 * np.pi + 1e-5) lin1 = m1 * (lin_output_phase - 0.5 * np.pi) + 0.5 * np.pi lin2 = m2 * (lin_output_phase + 0.5 * np.pi) - 0.5 * np.pi nonlin_output_phase = T.switch(T.lt(lin_output_phase, warp_phase_x), lin1, lin2) nonlin_output_re = nonlin_output_mod * T.cos(nonlin_output_phase) nonlin_output_im = nonlin_output_mod * T.sin(nonlin_output_phase) # scale RELU nonlinearity # modulus = T.sqrt(lin_output_re ** 2 + lin_output_im ** 2) # rescale = T.maximum(modulus + hidden_bias.dimshuffle('x',0), 0.) / (modulus + 1e-5) # nonlin_output_re = lin_output_re * rescale # nonlin_output_im = lin_output_im * rescale h_t = T.concatenate([nonlin_output_re, nonlin_output_im], axis=1) return h_t
def arcTan(X): return T.arctan(X)
def B(self, alpha, beta): return (1 / alpha) * T.arctan(beta * T.tan(self.pi * alpha / 2))
def tangential_distance(glxy_position, halo_position): # foo_position should be a 2-d numpy array delta = glxy_position - halo_position t = (2*T.arctan(delta[:,1]/delta[:,0])) return T.stack([-T.cos(t), -T.sin(t)], axis=1)
def atan(x): return T.arctan(x)
def arctan(self, X): return T.arctan(X)
def maape(y_true, y_pred): return K.mean(arctan(K.abs((y_pred - y_true) / y_true)))
def B(self, alpha, beta): return (1/alpha)*T.arctan(beta*T.tan(self.pi*alpha/2))