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
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
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
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 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
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