def reduce_data(self, mode=1, plot=True):
print "Reducing data..."
K = 500
X = self.D[:, :self.state_dim]
# Normalize
# x_max_X = np.max(X, axis=0)
# x_min_X = np.min(X, axis=0)
# for i in range(self.state_action_dim):
# X[:,i] = (X[:,i]-x_min_X[i])/(x_max_X[i]-x_min_X[i])
kdt = KDTree(X, leaf_size=20, metric='euclidean')
df = DiffusionMap(sigma=1, embedding_dim=2, k=K)
Xreduced = []
for i in range(X.shape[0]):
if not (i % 100):
print i, X.shape[0]
idx = kdt.query(X[i, :].reshape(1, -1), k=K, return_distance=False)
X_nn = X[idx, :].reshape(K, self.state_dim)
V, _ = df.fit_transform(X_nn, density_normalize=False)
Xreduced.append(V[0, :])
Xreduced = np.array(Xreduced)
if plot:
plt.scatter(Xreduced[:, 0], Xreduced[:, 1])
plt.show()
return Xreduced
def test_DiffusionMap_get_kernel_matrix_symmetry(mixtureNormals):
"make sure the kernel matrix is symmetric"
X = mixtureNormals
df = DiffusionMap(sigma=1, embedding_dim=2)
K = df._get_kernel_matrix(X, k=2)
Q = (K - K.T).toarray() # np.all doesnt work on sparse matrices
assert np.all(Q == 0), 'returned kernel matrix is not symmetric'
def test_DiffusionMap_fit_transform_eigenvalue_ordering(mixtureNormals):
"must return the largest first"
X = mixtureNormals
embDim = 2
df = DiffusionMap(sigma=1, embedding_dim=embDim)
X_embed, lam = df.fit_transform(X)
assert (lam[0] > lam[1])
def test_DiffusionMap_nearestNeighbour_number_of_neighbours(mixtureNormals):
X = mixtureNormals
embDim = 2
df = DiffusionMap(sigma=1, embedding_dim=embDim)
kNN = 4
distances, indices = df._get_NN(X, k=kNN)
assert distances.shape == (X.shape[0], kNN)
assert indices.shape == (X.shape[0], kNN)
def test_DiffusionMap_fit_transform_output_dimensions(mixtureNormals):
X = mixtureNormals
embDim = 2
df = DiffusionMap(sigma=1, embedding_dim=embDim)
X_embed, lam = df.fit_transform(X)
assert X_embed.shape == (X.shape[0], embDim), "returns wrong dimensionally"
assert lam.shape[0] == X_embed.shape[
1], "must return as many eigenvalues as embedded dimensions"
def __init__(self):
# Number of NN
if useDiffusionMaps:
dim = 3
self.K = 1000
self.K_manifold = 100
sigma = 2.0
if diffORspec == 'diff':
# self.df = DiffusionMap(sigma=sigma, embedding_dim=dim)
self.df = DiffusionMap(sigma=10, embedding_dim=dim, k=self.K)
print(
'[gp_transition] Using diffusion maps with dimension %d, K: (%d, %d) and sigma=%f.'
% (dim, self.K_manifold, self.K, sigma))
else:
self.embedding = spectralEmbed(embedding_dim=dim)
print(
'[gp_transition] Using spectral embedding with dimension %d.'
% (dim))
data_load.__init__(self,
simORreal=simORreal,
discreteORcont=discreteORcont,
K=self.K,
K_manifold=self.K_manifold,
sigma=sigma,
dim=dim,
dr='diff')
else:
self.K = 100
print('[gp_transition] No diffusion maps used, K=%d.' % self.K)
data_load.__init__(self,
simORreal=simORreal,
discreteORcont=discreteORcont,
K=self.K,
dr='spec')
svm_failure.__init__(
self,
simORreal=simORreal,
discrete=(True if discreteORcont == 'discrete' else False))
mean_shift.__init__(self)
rospy.Service('/gp/transition', batch_transition, self.GetTransition)
rospy.Service('/gp/transitionOneParticle', one_transition,
self.GetTransitionOneParticle)
rospy.Service('/gp/transitionRepeat', batch_transition_repeat,
self.GetTransitionRepeat)
rospy.Service('/gp/batchSVMcheck', batch_transition,
self.batch_svm_check_service)
rospy.Service('/gp/set_K', setk, self.setK)
rospy.Service('/gp/set_new_kdtree', setKD, self.setKDtree)
rospy.init_node('gp_transition', anonymous=True)
print('[gp_transition] Ready.')
rospy.spin()
def test_DiffusionMap_get_kernel_matrix_number_of_neighbours(mixtureNormals):
"""actually we would like to test for the exact number of neighvours
but due tot the symmetrizing, it can exceed the kNN"""
X = mixtureNormals
embDim = 2
df = DiffusionMap(sigma=1, embedding_dim=embDim)
kNN = 4
K = df._get_kernel_matrix(X, k=kNN)
assert K.shape == (X.shape[0], X.shape[0])
nonzero_elements_per_row = np.sum(K.toarray() != 0, 1)
print(nonzero_elements_per_row)
assert np.all(
nonzero_elements_per_row >= kNN
) # the number of nonzero elements must be kNN or larger (due to the symmetrizing
def setK(self, msg):
V = np.array(msg.data)
if V[0] < self.state_dim:
useDiffusionMaps = True
dim = int(V[0])
self.K_manifold = int(V[1])
self.K = int(V[2])
if diffORspec == 'diff':
sigma = V[3]
self.df = DiffusionMap(sigma=sigma, embedding_dim=dim)
if V[4]:
self.dr = 'diff'
self.precompute_hyperp(K=self.K,
K_manifold=self.K_manifold,
sigma=sigma,
dim=dim)
print(
'[gp_transition] Using diffusion maps with dimension %d, K: (%d, %d) and sigma=%f.'
% (dim, self.K_manifold, self.K, sigma))
elif diffORspec == 'spec':
self.embedding = spectralEmbed(embedding_dim=dim)
if V[4]:
self.dr = 'spec'
self.precompute_hyperp(K=self.K,
K_manifold=self.K_manifold,
dim=dim)
print(
'[gp_transition] Using spectral embedding with dimension %d.'
% (dim))
else:
useDiffusionMaps = False
self.K = int(V[1])
if V[4]:
self.precompute_hyperp(K=self.K)
print('[gp_transition] No diffusion maps used, K=%d.' % self.K)
def __init__(self):
svm_failure.__init__(
self, discrete=(True if discreteORcont == 'discrete' else False))
data_load.__init__(self,
simORreal=simORreal,
discreteORcont=discreteORcont)
# Number of NN
if useDiffusionMaps:
self.K = 1000
self.K_manifold = 100
self.df = DiffusionMap(sigma=1, embedding_dim=3, k=self.K)
else:
self.K = 100
rospy.Service('/gpup/transition', gpup_transition, self.GetTransition)
rospy.Service('/gpup/transitionRepeat', gpup_transition_repeat,
self.GetTransitionRepeat)
rospy.init_node('gpup_transition', anonymous=True)
print('[gpup_transition] Ready.')
rate = rospy.Rate(15) # 15hz
while not rospy.is_shutdown():
rospy.spin()
import gpflow
import time
from scipy.io import loadmat
import pickle
import math
from diffusionMaps import DiffusionMap
saved = False
discrete = True
useDiffusionMaps = True
# Number of NN
if useDiffusionMaps:
K = 5000
df = DiffusionMap(sigma=1, embedding_dim=3, k=K)
else:
K = 100
print('Loading data...')
if discrete:
Q = loadmat('../../data/sim_data_discrete.mat')
Qtrain = Q['D']
is_start = Q['is_start'][0][0]
is_end = Q['is_end'][0][0] - 180
Qtest = Qtrain[is_start:is_end, :]
Qtrain = np.concatenate((Qtrain[:is_start, :], Qtrain[is_end:, :]), axis=0)
else:
Q = loadmat('../../data/sim_data_cont.mat')
Qtrain = Q['D']
is_start = Q['is_start'][0][0]
def test__get_kernel_matrix_sparse(mixtureNormals):
df = DiffusionMap(sigma=1, embedding_dim=2)
K = df._get_kernel_matrix(mixtureNormals, k=10)
assert issparse(K)
