Beispiel #1
0
    def __init__(self, x_range, dx, z, k, n, sigma):
        self.dx = dx
        self.z = z
        self.k = k
        self.sigma = sigma
        self.x_range = x_range
        kern = DenseL1Kernel(self.z, self.k)

        X = np.random.uniform(x_range[0], x_range[1], (n, dx))
        kxx = kern(X) + sigma**2 * np.eye(X.shape[0])
        y = np.random.multivariate_normal(np.zeros(n), kxx).T

        self.gp = DenseKernelGP(X, y, sigma=sigma, kern=kern)
        self.gp.fit()
        self.get_max()
Beispiel #2
0
def generate_tilecoding_gps(X, y, sigma, tilecoding, include_sparse=True, include_dense=True):
    # create sparse format tilecoding projector
    sparsephi = IndexToBinarySparse(tilecoding, normalize=True)

    # create dense format tilecoding projector
    densephi = IndexToDense(tilecoding, normalize=True)

    # create dense kernel based off tilecoding
    densekern = DenseKernel(tilecoding, normalize=True)

    # create sparse kernel based off tilecoding
    sparsekern = SparseKernel(tilecoding, normalize=True)

    gps = []

    if include_dense:
        df_gp = DenseFeatureGP(X, y, sigma=sigma, phi=densephi)
        dk_gp = DenseKernelGP(X, y, sigma=sigma, kern=densekern)
        gps = gps + [('Dense Feature GP', df_gp),
                     ('Dense Kernel GP', dk_gp)]
    if include_sparse:
        sf_gp = SparseFeatureGP(X, y, sigma=sigma, phi=sparsephi)
        sk_gp = SparseKernelGP(X, y, sigma=sigma, kern=sparsekern)
        gps = gps + [('Sparse Feature GP', sf_gp),
                     ('Sparse Kernel GP', sk_gp)]
    return gps
Beispiel #3
0
class sampled_gp_func(object):
    def __init__(self, x_range, dx, z, k, n, sigma):
        self.dx = dx
        self.z = z
        self.k = k
        self.sigma = sigma
        self.x_range = x_range
        kern = DenseL1Kernel(self.z, self.k)

        X = np.random.uniform(x_range[0], x_range[1], (n, dx))
        kxx = kern(X) + sigma**2 * np.eye(X.shape[0])
        y = np.random.multivariate_normal(np.zeros(n), kxx).T

        self.gp = DenseKernelGP(X, y, sigma=sigma, kern=kern)
        self.gp.fit()
        self.get_max()

    def get_max(self):
        x = self.x_range[0].copy()
        all_cat = np.unique(self.z)
        for a in all_cat:
            active = self.z == a
            k1 = DenseL1Kernel(self.z[active], self.k[active])
            af = lambda x: np.array(k1(x, self.gp.X[:, active])).dot(self.gp.
                                                                     alpha)
            x[active] = global_minimize(af, self.x_range[:, active], 10000)
        self.argmax = x
        self.fmax = -np.squeeze(
            np.array(self.gp.kern(x, self.gp.X)).dot(self.gp.alpha))

    def __call__(self, x):
        if x.ndim == 1:
            n = 1
        else:
            n = x.shape[0]
        kXn = np.array(self.gp.kern(x, self.gp.X))
        mu = kXn.dot(self.gp.alpha)
        f = mu
        f += np.random.normal(size=n) * self.sigma
        return -np.squeeze(f)
Beispiel #4
0
    def get_tilegp(self):
        nlayers = self.options['nlayers']
        indices = []
        ntiles = []
        hashing = None
        all_cat = np.unique(self.z)
        if self.tilecap:
            hashing_mem = self.tilecap / len(all_cat) / nlayers
            hashing = [rp.UNH(hashing_mem) for _ in xrange(len(all_cat))]
        for a in all_cat:
            inds = helper.find(self.z == a)
            indices.append(inds)
            ntiles.append(self.k[inds])

        phi = TileCoding(
            input_indices=indices,
            # ntiles = input dim x number of layers x tilings
            ntiles=ntiles,
            ntilings=[nlayers] * len(indices),
            hashing=hashing,
            state_range=self.x_range,
            rnd_stream=np.random,
            bias_term=False)
        if self.gp_type == 'sk':
            # densekern > sparsekern \approx sparserp
            sparsekern = SparseKernel(phi, normalize=True)
            gp = SparseKernelGP(self.X, self.y, sigma=0.1, kern=sparsekern)
        elif self.gp_type == 'sf':
            # too slow
            sparsephi = IndexToBinarySparse(phi, normalize=True)
            gp = SparseFeatureGP(self.X, self.y, sigma=0.1, phi=sparsephi)
        #print 'in gibbs ', phi.size
        elif self.gp_type == 'dk':
            densekern = DenseKernel(phi, normalize=True)
            gp = DenseKernelGP(self.X,
                               self.y,
                               sigma=self.sigma,
                               kern=densekern)
        else:
            random_proj = rp.sparse_random_matrix(300,
                                                  phi.size,
                                                  random_state=np.random)
            densephi = SparseRPTilecoding(phi,
                                          random_proj=random_proj,
                                          normalize=True,
                                          output_dense=True)
            gp = DenseFeatureGP(self.X, self.y, sigma=self.sigma, phi=densephi)

        gp.fit()
        return gp
Beispiel #5
0
def sample_gp_posterior(dx, z, k, n, x_range):
    kern = get_kernel(z, k, x_range)
    X = np.random.uniform(x_range[0], x_range[1], (n, dx))
    kxx = kern(X) + 0.01 * np.eye(X.shape[0])
    y = np.random.multivariate_normal(np.zeros(n), kxx).T
    gp = DenseKernelGP(X, y, sigma=0.1, kern=kern)
    gp.fit()
    f = lambda x: gp.predict(x)[0] if len(x.shape) > 1 else gp.predict(x)[0][0]

    return f
Beispiel #6
0
def generate_rp_tilecoding_gps(X, y, sigma, tilecoding, random_proj, include_sparse=True, include_dense=True):
    # create dense format tilecoding projector
    densephi = SparseRPTilecoding(tilecoding, random_proj=random_proj, normalize=True, output_dense=True)

    # create dense kernel based off tilecoding
    densekern = DenseKernel(tilecoding, normalize=True)

    # create sparse kernel based off tilecoding
    sparsekern = SparseKernel(tilecoding, normalize=True)

    gps = []

    if include_dense:
        df_gp = DenseFeatureGP(X, y, sigma=sigma, phi=densephi)
        dk_gp = DenseKernelGP(X, y, sigma=sigma, kern=densekern)
        gps = gps + [('Dense Feature GP', df_gp),
                     ('Dense Kernel GP', dk_gp)]
    if include_sparse:
        sk_gp = SparseKernelGP(X, y, sigma=sigma, kern=sparsekern)
        gps = gps + [('Sparse Feature GP', sf_gp),
                     ('Sparse Kernel GP', sk_gp)]
    return gps
Beispiel #7
0
 def get_l1gp(self):
   kern = DenseL1Kernel(self.z, self.k)
   gp = DenseKernelGP(self.X, self.y, sigma=self.sigma, kern=kern)
   gp.fit()
   return gp