def __init__(self, time_1, time_2, e_1, e_2, x, labels=None, priors=None, vars=None, name='', model=None): super(CopulaIndependentComponent, self).__init__(name, model) if priors is None: priors = {} if vars is None: vars = {} # we need 2 sets of these x, labels = any_to_tensor_and_labels(x, labels) # now we have x, shape and labels self.x = x labels_1 = [s + "_1" for s in labels] ###First Dimension coeffs_1 = list() for name in labels_1: if name in vars: v = Deterministic(name, vars[name]) else: v = self.Var(name=name, dist=priors.get( name, priors.get('Regressor', self.default_regressor_prior))) coeffs_1.append(v) self.coeffs_1 = tt.stack(coeffs_1, axis=0) #### Second Dimension labels_2 = [s + "_2" for s in labels] coeffs_2 = list() for name in labels_2: if name in vars: v = Deterministic(name, vars[name]) else: v = self.Var(name=name, dist=priors.get( name, priors.get('Regressor', self.default_regressor_prior))) coeffs_2.append(v) self.coeffs_2 = tt.stack(coeffs_2, axis=0) ### create independent components as attributes of self. self.indep_1 = x.dot(self.coeffs_1) self.indep_2 = x.dot(self.coeffs_2) self.labels_1 = labels_1 self.labels_2 = labels_2
def __init__( self, x, y, intercept=True, labels=None, priors=None, vars=None, name="", model=None, offset=0.0, ): super().__init__(name, model) if len(y.shape) > 1: err_msg = ("Only one-dimensional observed variable objects (i.e." " of shape `(n, )`) are supported") raise TypeError(err_msg) if priors is None: priors = {} if vars is None: vars = {} x, labels = any_to_tensor_and_labels(x, labels) # now we have x, shape and labels if intercept: x = tt.concatenate([tt.ones((x.shape[0], 1), x.dtype), x], axis=1) labels = ["Intercept"] + labels coeffs = list() for name in labels: if name == "Intercept": if name in vars: v = Deterministic(name, vars[name]) else: v = self.Var(name=name, dist=priors.get(name, self.default_intercept_prior)) coeffs.append(v) else: if name in vars: v = Deterministic(name, vars[name]) else: v = self.Var( name=name, dist=priors.get( name, priors.get("Regressor", self.default_regressor_prior)), ) coeffs.append(v) self.coeffs = tt.stack(coeffs, axis=0) self.y_est = x.dot(self.coeffs) + offset
def __init__(self, x, y, e, intercept=True, labels=None, priors=None, vars=None, name='', model=None): super(LinearComponent, self).__init__(name, model) if priors is None: priors = {} if vars is None: vars = {} x, labels = any_to_tensor_and_labels(x, labels) # now we have x, shape and labels if intercept: x = tt.concatenate( [tt.ones((x.shape[0], 1), x.dtype), x], axis=1 ) labels = ['Intercept'] + labels self.x =x coeffs = list() for name in labels: if name == 'Intercept': if name in vars: v = Deterministic(name, vars[name]) else: v = self.Var( name=name, dist=priors.get( name, self.default_intercept_prior ) ) coeffs.append(v) else: if name in vars: v = Deterministic(name, vars[name]) else: v = self.Var( name=name, dist=priors.get( name, priors.get( 'Regressor', self.default_regressor_prior ) ) ) coeffs.append(v) self.coeffs = tt.stack(coeffs, axis=0) self.y_est = x.dot(self.coeffs)
def check_trace(self, step_method): """Tests whether the trace for step methods is exactly the same as on master. Code changes that effect how random numbers are drawn may change this, and require `master_samples` to be updated, but such changes should be noted and justified in the commit. This method may also be used to benchmark step methods across commits, by running, for example ``` BENCHMARK=100000 ./scripts/test.sh -s pymc3/tests/test_step.py:TestStepMethods ``` on multiple commits. """ n_steps = 100 with Model(): x = Normal('x', mu=0, sd=1) if step_method.__name__ == 'SMC': Deterministic('like', - 0.5 * tt.log(2 * np.pi) - 0.5 * x.T.dot(x)) trace = smc.ATMIP_sample(n_steps=n_steps, step=step_method(random_seed=1), n_jobs=1, progressbar=False, homepath=self.temp_dir) else: trace = sample(0, tune=n_steps, discard_tuned_samples=False, step=step_method(), random_seed=1) assert_array_almost_equal( trace.get_values('x'), self.master_samples[step_method], decimal=select_by_precision(float64=6, float32=4))
def __init__(self, time, event, x, rs, minibatch=1, labels=None, priors=None, vars=None, name='', model=None): super(FrailtyIndependentComponent_Fix, self).__init__(name, model) if priors is None: priors = {} if vars is None: vars = {} ### first thing to do is determine whether we are working with tensors or np.matrices ## Debugging print(str(time)) # if we are working with a matrix, we need to grab the value of the array that populates it if str(time) == '<TensorType(float64, matrix)>': data_tensor = True self.k = k = time.get_value().shape[1] # outcome dimentionality self.n = n = time.get_value().shape[ 0] # total number of observations self.p = p = x.get_value().shape[1] # number of covariates else: data_tensor = False self.k = k = time.shape[1] # outcome dimentionality self.n = n = time.shape[0] # total number of observations self.p = p = x.shape[1] # number of covariates x, labels = any_to_tensor_and_labels( x, labels) # might need to do this for the other variables ## now for secondary delta for the gamma frac if data_tensor == True: # Create tensor variable for the gamma_frac component of the likelihood self.event_change = event_change = theano.shared(np.array([np.append(np.repeat(1, s), np.repeat(0, k-s)).tolist()\ for s in np.sum(event.get_value(), axis = 1)]), borrow = True) else: self.event_change = event_change = np.array([np.append(np.repeat(1, s), np.repeat(0, k-s)).tolist()\ for s in np.sum(event, axis = 1)]) ## Keep track of total size of the dataset, for minibatching ## new 10.10.2018 # If minibatch, then we need the x component to be a generator and not just a tensor # by this step in the computation, X is already in tensor form if minibatch >= 2: # kinda hacky but whatever, we can fix this later print("We're Mini batching") # If we're using mini-batch, then we have to tell the inner workings to fix the MAP estimate minibatch = int( minibatch) #just in case some n00b puts in a double/float here x_mini = pm.Minibatch( data=x.get_value(), batch_size=minibatch ) # make minibatch instance of the design matrix time_mini = pm.Minibatch( data=time.get_value(), batch_size=minibatch) # minibatch instance of the time array event_mini = pm.Minibatch( data=event.get_value(), batch_size=minibatch) # minibatch instance of the event array event_change_mini = pm.Minibatch( data=event_change.get_value(), batch_size=minibatch ) # minibatch instance of the transformed event array ## assign self. attributes to later parameterize the logp function self.x = x_mini self.time = time_mini self.event = event_mini self.event_change = event_change_mini else: # if not minibatching, just pass the tensors as they are self.x = x self.time = time self.event = event self.event_change = event_change # now we have x, shape and labels # init a list to store all of the parameters that go into our likelihood coeffs_all = list() lams = list() rhos = list() for level in range( k ): # for each dimension, instantiate a covariate effect for each predictor labels_this = [s + "_" + str(level) for s in labels] coeffs_this = list() for name in labels_this: if name in vars: v = Deterministic(name, vars[name]) else: v = self.Var(name=name, dist=priors.get( name, priors.get('Regressor', self.default_regressor_prior))) coeffs_this.append(v) coeffs_this = tt.stack(coeffs_this, axis=0) coeffs_all.append(coeffs_this) ### Now for the baseline hazard portions lam_name = 'lam_' + str(level) lam = self.Var(name=lam_name, dist=priors.get( lam_name, priors.get('lam', self.default_lambda_prior)) ) # create labels for the lambdas lams.append(lam) # rhos rho_name = 'rho_' + str(level) rho = self.Var(name=rho_name, dist=priors.get( rho_name, priors.get('rho', self.default_rho_prior))) rhos.append(rho) # finally, transformation parameters r # frailty parameter theta = self.Var(name='theta', dist=priors.get( 'theta', priors.get('Theta', self.default_theta_prior))) # make self attribute for the coefficients self.coeffs_all = coeffs_all # changing 10.18 self.theta = theta self.lams = lams = tt.stack(lams, axis=0) self.rhos = rhos = tt.stack(rhos, axis=0)