Example #1
0
    def _sample_constraint_ls(self, comp, vals):
        def lpSigmoid(ff, gain=self.constraint_gain):
            probs = 1. / (1. + np.exp(-gain * ff))
            probs[probs <= 0] = 1e-12
            probs[probs >= 1] = 1 - 1e-12
            llh = np.sum(vals * np.log(probs) + (1 - vals) * np.log(1 - probs))
            return llh

        def updateGain(gain):
            if gain < 0.01 or gain > 10:
                return -np.inf

            cov = self.constraint_amp2 * (
                self.cov_func(self.constraint_ls, comp, None) +
                1e-6 * np.eye(comp.shape[0])) + self.constraint_noise * np.eye(
                    comp.shape[0])
            chol = spla.cholesky(cov, lower=True)
            solve = spla.cho_solve((chol, True),
                                   vals)  # - self.constraint_mean)
            #lp    = -np.sum(np.log(np.diag(chol)))-0.5*np.dot(self.ff, solve)
            lp = lpSigmoid(self.ff, gain)

            return lp

        def logprob(ls):
            if np.any(ls < 0) or np.any(ls > self.constraint_max_ls):
                return -np.inf

            cov = self.constraint_amp2 * (
                self.cov_func(ls, comp, None) + 1e-6 * np.eye(comp.shape[0])
            ) + self.constraint_noise * np.eye(comp.shape[0])
            chol = spla.cholesky(cov, lower=True)
            solve = spla.cho_solve((chol, True),
                                   self.ff)  # - self.constraint_mean)
            #lp    = -np.sum(np.log(np.diag(chol)))-0.5*np.dot(self.ff, solve)

            lp = lpSigmoid(self.ff)

            return lp

        #hypers = util.slice_sample(np.hstack((self.constraint_ls, self.ff)), logprob, compwise=True)
        hypers = util.slice_sample(self.constraint_ls, logprob, compwise=True)
        self.constraint_ls = hypers

        cov = self.constraint_amp2 * (
            self.cov_func(self.constraint_ls, comp, None) + 1e-6 * np.eye(
                comp.shape[0])) + self.constraint_noise * np.eye(comp.shape[0])
        chol = spla.cholesky(cov, lower=False)
        ff = self.ff
        for jj in xrange(20):
            (ff, lpell) = self.elliptical_slice(ff, chol, lpSigmoid)

        self.ff = ff

        # Update gain
        hypers = util.slice_sample(np.array([self.constraint_gain]),
                                   updateGain,
                                   compwise=True)
        self.constraint_gain = hypers
    def _sample_constraint_ls(self, comp, vals):
        def lpProbit(ff, gain=self.constraint_gain):
            probs = sps.norm.cdf(ff * gain)
            probs[probs <= 0] = 1e-12
            probs[probs >= 1] = 1 - 1e-12
            llh = np.sum(vals * np.log(probs) + (1 - vals) * np.log(1 - probs))

            return llh

        def lpSigmoid(ff, gain=self.constraint_gain):
            probs = 1.0 / (1.0 + np.exp(-gain * ff))
            probs[probs <= 0] = 1e-12
            probs[probs >= 1] = 1 - 1e-12
            llh = np.sum(vals * np.log(probs) + (1 - vals) * np.log(1 - probs))
            return llh

        def updateGain(gain):
            if gain < 0.01 or gain > 10:
                return -np.inf

            cov = self.constraint_amp2 * (
                self.cov_func(self.constraint_ls, comp, None) + 1e-6 * np.eye(comp.shape[0])
            ) + self.constraint_noise * np.eye(comp.shape[0])
            chol = spla.cholesky(cov, lower=True)
            solve = spla.cho_solve((chol, True), vals)
            lp = lpProbit(self.ff, gain)

            return lp

        def logprob(ls):
            if np.any(ls < 0) or np.any(ls > self.constraint_max_ls):
                return -np.inf

            cov = self.constraint_amp2 * (
                self.cov_func(ls, comp, None) + 1e-6 * np.eye(comp.shape[0])
            ) + self.constraint_noise * np.eye(comp.shape[0])
            chol = spla.cholesky(cov, lower=True)
            solve = spla.cho_solve((chol, True), self.ff)
            lp = lpProbit(self.ff)

            return lp

        hypers = util.slice_sample(self.constraint_ls, logprob, compwise=True)
        self.constraint_ls = hypers

        cov = self.constraint_amp2 * (
            self.cov_func(self.constraint_ls, comp, None) + 1e-6 * np.eye(comp.shape[0])
        ) + self.constraint_noise * np.eye(comp.shape[0])
        chol = spla.cholesky(cov, lower=False)
        ff = self.ff
        for jj in range(20):
            (ff, lpell) = self.elliptical_slice(ff, chol, lpProbit)

        self.ff = ff

        # Update gain
        hypers = util.slice_sample(np.array([self.constraint_gain]), updateGain, compwise=True)
        self.constraint_gain = hypers[0]
    def _sample_constraint_ls(self, comp, vals):
        def lpSigmoid(ff, gain=self.constraint_gain):
            probs = 1./(1. + np.exp(-gain*ff));
            probs[probs <= 0] = 1e-12
            probs[probs >= 1] = 1-1e-12
            llh   = np.sum(vals*np.log(probs) + (1-vals)*np.log(1-probs));
            return llh

        def updateGain(gain):
            if gain < 0.01 or gain > 10:
                return -np.inf

            cov   = self.constraint_amp2 * (self.cov_func(self.constraint_ls, comp, None) + 1e-6*np.eye(comp.shape[0])) + self.constraint_noise*np.eye(comp.shape[0])
            chol  = spla.cholesky(cov, lower=True)
            solve = spla.cho_solve((chol, True), vals)# - self.constraint_mean)
            #lp    = -np.sum(np.log(np.diag(chol)))-0.5*np.dot(self.ff, solve)
            lp   = lpSigmoid(self.ff, gain)

            return lp

        def logprob(ls):
            if np.any(ls < 0) or np.any(ls > self.constraint_max_ls):
                return -np.inf
        
            cov   = self.constraint_amp2 * (self.cov_func(ls, comp, None) + 1e-6*np.eye(comp.shape[0])) + self.constraint_noise*np.eye(comp.shape[0])
            chol  = spla.cholesky(cov, lower=True)
            solve = spla.cho_solve((chol, True), self.ff)# - self.constraint_mean)
            #lp    = -np.sum(np.log(np.diag(chol)))-0.5*np.dot(self.ff, solve)

            lp   = lpSigmoid(self.ff)

            return lp

        #hypers = util.slice_sample(np.hstack((self.constraint_ls, self.ff)), logprob, compwise=True)
        hypers = util.slice_sample(self.constraint_ls, logprob, compwise=True)
        self.constraint_ls = hypers

        cov   = self.constraint_amp2 * (self.cov_func(self.constraint_ls, comp, None) + 1e-6*np.eye(comp.shape[0])) + self.constraint_noise*np.eye(comp.shape[0])
        chol  = spla.cholesky(cov, lower=False)
        ff = self.ff
        for jj in xrange(20):
            (ff, lpell) = self.elliptical_slice(ff, chol, lpSigmoid);
            
        self.ff = ff

        # Update gain
        hypers = util.slice_sample(np.array([self.constraint_gain]), updateGain, compwise=True)
        self.constraint_gain = hypers
    def _sample_noiseless(self, comp, vals):
        def logprob(hypers):
            mean = hypers[0]
            amp2 = hypers[1]
            noise = 1e-3

            # This is pretty hacky, but keeps things sane.
            if mean > np.max(vals) or mean < np.min(vals):
                return -np.inf

            if amp2 < 0:
                return -np.inf

            cov = (amp2 * (self.cov_func(self.ls, comp, None) +
                           1e-6 * np.eye(comp.shape[0])) +
                   noise * np.eye(comp.shape[0]))
            chol = spla.cholesky(cov, lower=True)
            solve = spla.cho_solve((chol, True), vals - mean)
            lp = -np.sum(np.log(np.diag(chol))) - 0.5 * np.dot(
                vals - mean, solve)

            # Roll in amplitude lognormal prior
            lp -= 0.5 * (np.log(amp2) / self.amp2_scale)**2

            return lp

        hypers = util.slice_sample(np.array([self.mean, self.amp2,
                                             self.noise]),
                                   logprob,
                                   compwise=False)
        self.mean = hypers[0]
        self.amp2 = hypers[1]
        self.noise = 1e-3
Example #5
0
    def _sample_noiseless(self, comp, vals):
        def logprob(hypers):
            mean  = hypers[0]
            amp2  = hypers[1]
            noise = 1e-3

            # This is pretty hacky, but keeps things sane.
            if mean > np.max(vals) or mean < np.min(vals):
                return -np.inf

            if amp2 < 0:
                return -np.inf

            cov   = amp2 * (self.cov_func(self.ls, comp, None) + 1e-6*np.eye(comp.shape[0])) + noise*np.eye(comp.shape[0])
            chol  = spla.cholesky(cov, lower=True)
            solve = spla.cho_solve((chol, True), vals - mean)
            lp    = -np.sum(np.log(np.diag(chol)))-0.5*np.dot(vals-mean, solve)

            # Roll in amplitude lognormal prior
            lp -= 0.5*(np.log(amp2)/self.amp2_scale)**2

            return lp

        hypers = util.slice_sample(np.array([self.mean, self.amp2, self.noise]), logprob, compwise=False)
        self.mean  = hypers[0]
        self.amp2  = hypers[1]
        self.noise = 1e-3
Example #6
0
def sample_from_proposal_measure(starting_point, log_proposal_measure, number_of_points, chain_length=20):
    '''
    Samples points from a proposal measure.
    Args:
        starting_point: The point where to start the sampling.
        log_proposal_measure: A function that measures in log-scale how suitable a point is to represent Pmin.
        number_of_points: The number of samples to draw.
    Returns:
        a numpy array containing the desired number of samples
    '''

    representer_points = np.zeros([number_of_points, starting_point.shape[0]])
    #TODO: burnin?

    for i in range(0, number_of_points):
        #this for loop ensures better mixing
        for c in range(0, chain_length):
            try:
                starting_point = slice_sample(starting_point, log_proposal_measure)
            except Exception as e:
                starting_point = handle_slice_sampler_exception(e, starting_point, log_proposal_measure)

        representer_points[i] = starting_point

    return representer_points
def handle_slice_sampler_exception(exception, starting_point, proposal_measure, opt_compwise=False):
    '''
    Handles slice sampler exceptions. If the slice sampler shrank to zero the slice sampler will be restarted
    a few times. If this fails or if the exception was another this method will raise the given exception.
    Args:
        exception: the exception that occured
        starting_point: the starting point that was used
        proposal_measure: the used proposal measure
        opt_compwise: how to set the compwise option
    Returns:
        the output of the slice sampelr
    Raises:
        Exception: the first argument
    '''
    if exception.message == "Slice sampler shrank to zero!":
        log("Slice sampler shrank to zero! Action: trying to restart " + str(NUMBER_OF_RESTARTS)
            + " times with same starting point")
        restarts_left = NUMBER_OF_RESTARTS
        while restarts_left > 0:
            try:
                return slice_sample(starting_point, proposal_measure, compwise=opt_compwise)
            except Exception as e:
                log("Restart failed. " + str(restarts_left) + " restarts left. Exception was: " + e.message)
                restarts_left = restarts_left - 1
        # if we leave the while loop we will raise the exception we got
    raise exception
Example #8
0
    def _sample_constraint_noisy(self, comp, vals):
        def lpSigmoid(ff, gain=self.constraint_gain):
            probs = 1. / (1. + np.exp(-gain * ff))
            probs[probs <= 0] = 1e-12
            probs[probs >= 1] = 1 - 1e-12
            llh = np.sum(vals * np.log(probs) + (1 - vals) * np.log(1 - probs))
            return llh

        def logprob(hypers):
            #mean  = hypers[0]
            amp2 = hypers[0]
            #gain = hypers[2]
            ff = hypers[1:]

            # This is pretty hacky, but keeps things sane.
            #if mean > np.max(vals) or mean < np.min(vals):
            #    return -np.inf

            if amp2 < 0:
                return -np.inf

            noise = self.constraint_noise
            cov = amp2 * (self.cov_func(self.constraint_ls, comp, None) +
                          1e-6 * np.eye(comp.shape[0])) + noise * np.eye(
                              comp.shape[0])
            chol = spla.cholesky(cov, lower=True)
            solve = spla.cho_solve((chol, True), ff)  # - mean)
            #lp    = -np.sum(np.log(np.diag(chol)))-0.5*np.dot(ff-mean, solve)
            lp = -np.sum(np.log(np.diag(chol))) - 0.5 * np.dot(ff, solve)

            # Roll in noise horseshoe prior.
            #lp += np.log(np.log(1 + (self.constraint_noise_scale/noise)**2))
            #lp -= 0.5*(np.log(noise)/self.constraint_noise_scale)**2

            # Roll in amplitude lognormal prior
            lp -= 0.5 * (np.log(amp2) / self.constraint_amp2_scale)**2

            #lp    = -np.sum(np.log(np.diag(chol)))-0.5*np.dot(self.ff, solve)
            lp += lpSigmoid(ff, self.constraint_gain)

            return lp

        hypers = util.slice_sample(np.hstack(
            (np.array([self.constraint_amp2]), self.ff)),
                                   logprob,
                                   compwise=False)
        #self.constraint_mean  = hypers[0]
        self.constraint_amp2 = hypers[0]
        #self.constraint_gain = hypers[2]
        self.ff = hypers[1:]
        cov = self.constraint_amp2 * (
            self.cov_func(self.constraint_ls, comp, None) + 1e-6 * np.eye(
                comp.shape[0])) + self.constraint_noise * np.eye(comp.shape[0])
        chol = spla.cholesky(cov, lower=False)
        ff = self.ff
        for jj in xrange(50):
            (ff, lpell) = self.elliptical_slice(ff, chol, lpSigmoid)
        self.ff = ff
Example #9
0
    def _sample_time_ls(self, comp, vals):
        def logprob(ls):
            if np.any(ls < 0) or np.any(ls > self.time_max_ls):
                return -np.inf

            cov   = self.time_amp2 * (self.cov_func(ls, comp, None) + 1e-6*np.eye(comp.shape[0])) + self.time_noise*np.eye(comp.shape[0])
            chol  = spla.cholesky(cov, lower=True)
            solve = spla.cho_solve((chol, True), vals - self.time_mean)
            lp    = -np.sum(np.log(np.diag(chol)))-0.5*np.dot(vals-self.time_mean, solve)
            return lp

        self.time_ls = util.slice_sample(self.time_ls, logprob, compwise=True)
Example #10
0
    def _sample_time_ls(self, comp, vals):
        def logprob(ls):
            if np.any(ls < 0) or np.any(ls > self.time_max_ls):
                return -np.inf

            cov   = self.time_amp2 * (self.cov_func(ls, comp, None) + 1e-6*np.eye(comp.shape[0])) + self.time_noise*np.eye(comp.shape[0])
            chol  = spla.cholesky(cov, lower=True)
            solve = spla.cho_solve((chol, True), vals - self.time_mean)
            lp    = -np.sum(np.log(np.diag(chol)))-0.5*np.dot(vals-self.time_mean, solve)
            return lp

        self.time_ls = util.slice_sample(self.time_ls, logprob, compwise=True)
    def _sample_constraint_noisy(self, comp, vals):
        def lpSigmoid(ff,gain=self.constraint_gain):
            probs = 1./(1. + np.exp(-gain*ff));
            probs[probs <= 0] = 1e-12
            probs[probs >= 1] = 1-1e-12
            llh   = np.sum(vals*np.log(probs) + (1-vals)*np.log(1-probs));
            return llh

        def logprob(hypers):
            #mean  = hypers[0]
            amp2  = hypers[0]
            #gain = hypers[2]
            ff = hypers[1:]

            # This is pretty hacky, but keeps things sane.
            #if mean > np.max(vals) or mean < np.min(vals):
            #    return -np.inf

            if amp2 < 0:
                return -np.inf

            noise = self.constraint_noise
            cov   = amp2 * (self.cov_func(self.constraint_ls, comp, None) + 1e-6*np.eye(comp.shape[0])) + noise*np.eye(comp.shape[0])
            chol  = spla.cholesky(cov, lower=True)
            solve = spla.cho_solve((chol, True), ff)# - mean)
            #lp    = -np.sum(np.log(np.diag(chol)))-0.5*np.dot(ff-mean, solve)
            lp    = -np.sum(np.log(np.diag(chol)))-0.5*np.dot(ff, solve)

            # Roll in noise horseshoe prior.
            #lp += np.log(np.log(1 + (self.constraint_noise_scale/noise)**2))
            #lp -= 0.5*(np.log(noise)/self.constraint_noise_scale)**2

            # Roll in amplitude lognormal prior
            lp -= 0.5*(np.log(amp2)/self.constraint_amp2_scale)**2

            #lp    = -np.sum(np.log(np.diag(chol)))-0.5*np.dot(self.ff, solve)
            lp   += lpSigmoid(ff,self.constraint_gain)

            return lp

        hypers = util.slice_sample(np.hstack((np.array([self.constraint_amp2]), self.ff)), logprob, compwise=False)
        #self.constraint_mean  = hypers[0]
        self.constraint_amp2  = hypers[0]
        #self.constraint_gain = hypers[2]
        self.ff = hypers[1:]
        cov   = self.constraint_amp2 * (self.cov_func(self.constraint_ls, comp, None) + 1e-6*np.eye(comp.shape[0])) + self.constraint_noise*np.eye(comp.shape[0])
        chol  = spla.cholesky(cov, lower=False)
        ff = self.ff
        for jj in xrange(50):
            (ff, lpell) = self.elliptical_slice(ff, chol, lpSigmoid);            
        self.ff = ff
    def _sample_constraint_noisy(self, comp, vals):
        def lpProbit(ff, gain=self.constraint_gain):
            probs = sps.norm.cdf(ff * gain)
            probs[probs <= 0] = 1e-12
            probs[probs >= 1] = 1 - 1e-12
            llh = np.sum(vals * np.log(probs) + (1 - vals) * np.log(1 - probs))
            if np.any(np.isnan(probs)):
                print(probs)
            return llh

        def lpSigmoid(ff, gain=self.constraint_gain):
            probs = 1.0 / (1.0 + np.exp(-gain * ff))
            probs[probs <= 0] = 1e-12
            probs[probs >= 1] = 1 - 1e-12
            llh = np.sum(vals * np.log(probs) + (1 - vals) * np.log(1 - probs))
            return llh

        def logprob(hypers):
            amp2 = hypers[0]
            ff = hypers[1:]

            if amp2 < 0:
                return -np.inf

            noise = self.constraint_noise
            cov = amp2 * (
                self.cov_func(self.constraint_ls, comp, None) + 1e-6 * np.eye(comp.shape[0])
            ) + noise * np.eye(comp.shape[0])
            chol = spla.cholesky(cov, lower=True)
            solve = spla.cho_solve((chol, True), ff)
            lp = -np.sum(np.log(np.diag(chol))) - 0.5 * np.dot(ff, solve)

            # Roll in amplitude lognormal prior
            lp -= 0.5 * (np.log(amp2) / self.constraint_amp2_scale) ** 2

            lp += lpProbit(ff, self.constraint_gain)

            return lp

        hypers = util.slice_sample(np.hstack((np.array([self.constraint_amp2]), self.ff)), logprob, compwise=False)
        self.constraint_amp2 = hypers[0]
        self.ff = hypers[1:]
        cov = self.constraint_amp2 * (
            (self.cov_func(self.constraint_ls, comp, None) + 1e-6 * np.eye(comp.shape[0]))
            + self.constraint_noise * np.eye(comp.shape[0])
        )
        chol = spla.cholesky(cov, lower=False)
        ff = self.ff
        for jj in range(50):
            (ff, lpell) = self.elliptical_slice(ff, chol, lpProbit)
        self.ff = ff
def _sample_ls(comp, vals, cov_func, start_point, mean, amp2, noise):
    def logprob(ls):
        if np.any(ls < 0) or np.any(ls > MAX_LS):
            return -np.inf

        cov = (amp2 * (cov_func(ls, comp, None) + 
            1e-6 * np.eye(comp.shape[0])) + noise * np.eye(comp.shape[0]))
        chol = spla.cholesky(cov, lower=True)
        solve = spla.cho_solve((chol, True), vals - mean)

        lp = (-np.sum(np.log(np.diag(chol))) - 0.5 * np.dot(vals - mean, solve))
        return lp

    try:
        return slice_sample(start_point, logprob, compwise=True)
    except Exception as e:
        return handle_slice_sampler_exception(e, start_point, logprob, True)
def _sample_mean_amp_noise(comp, vals, cov_func, start_point, ls):
    default_noise = 1e-3
    #if we get a start point that consists only of two variables that means we don't care for the noise
    noiseless = (start_point.shape[0] == 2)

    def logprob(hypers):
        mean = hypers[0]
        amp2 = hypers[1]
        if not noiseless:
            noise = hypers[2]
        else:
            noise = default_noise

        # This is pretty hacky, but keeps things sane.
        if mean > np.max(vals) or mean < np.min(vals):
            return -np.inf

        if amp2 < 0 or noise < 0:
            return -np.inf

        cov = (amp2 * (cov_func(ls, comp, None) +
            1e-6 * np.eye(comp.shape[0])) + noise * np.eye(comp.shape[0]))

        chol = spla.cholesky(cov, lower=True)
        solve = spla.cho_solve((chol, True), vals - mean)
        lp = -np.sum(np.log(np.diag(chol))) - 0.5 * np.dot(vals - mean, solve)
        if not noiseless:
            # Roll in noise horseshoe prior.
            lp += np.log(np.log(1 + (NOISE_SCALE / noise) ** 2))

        # Roll in amplitude lognormal prior
        lp -= 0.5 * (np.log(amp2) / AMP2_SCALE) ** 2
        #print "LP: " + str(lp)
        return lp
    try:
        return slice_sample(start_point, logprob, compwise=False)
    except Exception as e:
        return handle_slice_sampler_exception(e, start_point, logprob, False)