def TimeseriesFromPSD_nd(param_noise):
"""
GPU only
"""
(asd_pos, asd_neg, low_f, high_f, high_f_, size, fs, fmin, fmax) = param_noise
(*D_, N) = size
D = reduce(lambda x, y: x * y, D_)
# Gauss noise and its one-sided PSD without window
gauss_noise = 1* nd.random_normal(loc=0,scale=64,shape=(D, N), ctx=ctx)
_, xf_noise, psd_gauss = oneSidedPeriodogram_nd(gauss_noise, fs=8192)
psd_gauss = nd.array(psd_gauss, ctx = ctx, dtype='float64')
psd_twosided = nd.concat( # low positive
nd.zeros((D, low_f), ctx = ctx, dtype='float64'),
# high positive
psd_gauss[:, low_f:high_f] * asd_pos,
nd.zeros((D, high_f_), ctx = ctx, dtype='float64'),
nd.zeros((D, high_f_), ctx = ctx, dtype='float64'),
# high negative
psd_gauss[:, low_f:high_f][::-1] * asd_neg,
# low negative
nd.zeros((D, low_f), ctx = ctx, dtype='float64'), dim=1)
amplitude = nd.sqrt(psd_twosided *2 *fs*N )
epsilon_imag = nd.random_uniform(low=0, high=1, shape=(D,N),ctx=ctx,dtype='float64')*2*np.pi
re = nd.cos(epsilon_imag)*amplitude
im = nd.sin(epsilon_imag)*amplitude
temp = nd.zeros((D, N*2) , ctx=ctx)
temp[:,::2] = re
temp[:,1::2] = im
timeseries = mx.contrib.ndarray.ifft(temp)/N
return timeseries.reshape(size), psd_twosided
def embedding(self, observed_arr):
'''
Embedding. In default, this method does the positional encoding.
Args:
observed_arr: `mxnet.ndarray` of observed data points.
Returns:
`mxnet.ndarray` of embedded data points.
'''
batch_size, seq_len, depth_dim = observed_arr.shape
self.batch_size = batch_size
self.seq_len = seq_len
self.depth_dim = depth_dim
if self.embedding_flag is False:
return observed_arr
depth_arr = nd.tile(nd.expand_dims((nd.arange(depth_dim) / 2).astype(int) * 2, 0), [seq_len, 1])
depth_arr = depth_arr / depth_dim
depth_arr = nd.power(10000.0, depth_arr).astype(np.float32)
phase_arr = nd.tile(nd.expand_dims((nd.arange(depth_dim) % 2) * np.pi / 2, 0), [seq_len, 1])
positional_arr = nd.tile(nd.expand_dims(nd.arange(seq_len), 1), [1, depth_dim])
sin_arr = nd.sin(positional_arr / depth_arr + phase_arr)
positional_encoded_arr = nd.tile(nd.expand_dims(sin_arr, 0), [batch_size, 1, 1])
positional_encoded_arr = positional_encoded_arr.as_in_context(observed_arr.context)
result_arr = observed_arr + (positional_encoded_arr * self.embedding_weignt)
return result_arr
def test_jitter_synthetic(
jitter_method, float_type, ctx=mx.Context('cpu')
) -> None:
# Initialize problem parameters
batch_size = 1
prediction_length = 50
context_length = 5
num_samples = 3
# Initialize test data to generate Gaussian Process from
lb = -5
ub = 5
dx = (ub - lb) / (prediction_length - 1)
x_test = nd.arange(lb, ub + dx, dx, ctx=ctx, dtype=float_type).reshape(
-1, 1
)
x_test = nd.tile(x_test, reps=(batch_size, 1, 1))
# Define the GP hyper parameters
amplitude = nd.ones((batch_size, 1, 1), ctx=ctx, dtype=float_type)
length_scale = math.sqrt(0.4) * nd.ones_like(amplitude)
sigma = math.sqrt(1e-5) * nd.ones_like(amplitude)
# Instantiate desired kernel object and compute kernel matrix
rbf_kernel = RBFKernel(amplitude, length_scale)
# Generate samples from 0 mean Gaussian process with RBF Kernel and plot it
gp = GaussianProcess(
sigma=sigma,
kernel=rbf_kernel,
prediction_length=prediction_length,
context_length=context_length,
num_samples=num_samples,
ctx=ctx,
float_type=float_type,
jitter_method=jitter_method,
sample_noise=False, # Returns sample without noise
)
# Generate training set on subset of interval using the sine function
x_train = nd.array([-4, -3, -2, -1, 1], ctx=ctx, dtype=float_type).reshape(
context_length, 1
)
x_train = nd.tile(x_train, reps=(batch_size, 1, 1))
y_train = nd.sin(x_train.squeeze(axis=2))
# Predict exact GP using the GP predictive mean and covariance using the same fixed hyper-parameters
samples, predictive_mean, predictive_std = gp.exact_inference(
x_train, y_train, x_test
)
assert (
np.sum(np.isnan(samples.asnumpy())) == 0
), 'NaNs in predictive samples!'
def edge_func(self, edges):
real_head, img_head = nd.split(edges.src['emb'], num_outputs=2, axis=-1)
real_tail, img_tail = nd.split(edges.dst['emb'], num_outputs=2, axis=-1)
phase_rel = edges.data['emb'] / (self.emb_init / np.pi)
re_rel, im_rel = nd.cos(phase_rel), nd.sin(phase_rel)
real_score = real_head * re_rel - img_head * im_rel
img_score = real_head * im_rel + img_head * re_rel
real_score = real_score - real_tail
img_score = img_score - img_tail
#sqrt((x*x).sum() + eps)
score = mx.nd.sqrt(real_score * real_score + img_score * img_score + self.eps).sum(-1)
return {'score': self.gamma - score}
def infer(self, head_emb, rel_emb, tail_emb):
re_head, im_head = nd.split(head_emb, num_outputs=2, axis=-1)
re_tail, im_tail = nd.split(tail_emb, num_outputs=2, axis=-1)
phase_rel = rel_emb / (self.emb_init / np.pi)
re_rel, im_rel = nd.cos(phase_rel), nd.sin(phase_rel)
real_score = re_head.expand_dims(axis=1) * re_rel.expand_dims(axis=0) - im_head.expand_dims(axis=1) * im_rel.expand_dims(axis=0)
img_score = re_head.expand_dims(axis=1) * im_rel.expand_dims(axis=0) + im_head.expand_dims(axis=1) * re_rel.expand_dims(axis=0)
real_score = real_score.expand_dims(axis=2) - re_tail.expand_dims(axis=0).expand_dims(axis=0)
img_score = img_score.expand_dims(axis=2) - im_tail.expand_dims(axis=0).expand_dims(axis=0)
score = mx.nd.sqrt(real_score * real_score + img_score * img_score + self.eps).sum(-1)
return self.gamma - score
def fn(heads, relations, tails, num_chunks, chunk_size, neg_sample_size):
hidden_dim = heads.shape[1]
emb_real, emb_img = nd.split(heads, num_outputs=2, axis=-1)
phase_rel = relations / (emb_init / np.pi)
rel_real, rel_img = nd.cos(phase_rel), nd.sin(phase_rel)
real = emb_real * rel_real - emb_img * rel_img
img = emb_real * rel_img + emb_img * rel_real
emb_complex = nd.concat(real, img, dim=-1)
tmp = emb_complex.reshape(num_chunks, chunk_size, 1, hidden_dim)
tails = tails.reshape(num_chunks, 1, neg_sample_size, hidden_dim)
score = tmp - tails
score_real, score_img = nd.split(score, num_outputs=2, axis=-1)
score = mx.nd.sqrt(score_real * score_real + score_img * score_img + self.eps).sum(-1)
return gamma - score
def main():
# Initialize problem parameters
batch_size = 1
prediction_length = 50
context_length = 5
axis = [-5, 5, -3, 3]
float_type = np.float64
ctx = mx.Context("gpu")
num_samples = 3
ts_idx = 0
# Initialize test data to generate Gaussian Process from
lb = -5
ub = 5
dx = (ub - lb) / (prediction_length - 1)
x_test = nd.arange(lb, ub + dx, dx, ctx=ctx,
dtype=float_type).reshape(-1, 1)
x_test = nd.tile(x_test, reps=(batch_size, 1, 1))
# Define the GP hyper parameters
amplitude = nd.ones((batch_size, 1, 1), ctx=ctx, dtype=float_type)
length_scale = math.sqrt(0.4) * nd.ones_like(amplitude)
sigma = math.sqrt(1e-5) * nd.ones_like(amplitude)
# Instantiate desired kernel object and compute kernel matrix
rbf_kernel = RBFKernel(amplitude, length_scale)
# Generate samples from 0 mean Gaussian process with RBF Kernel and plot it
gp = GaussianProcess(
sigma=sigma,
kernel=rbf_kernel,
prediction_length=prediction_length,
context_length=context_length,
num_samples=num_samples,
ctx=ctx,
float_type=float_type,
sample_noise=False, # Returns sample without noise
)
mean = nd.zeros((batch_size, prediction_length), ctx=ctx, dtype=float_type)
covariance = rbf_kernel.kernel_matrix(x_test, x_test)
gp.plot(x_test=x_test, samples=gp.sample(mean, covariance), ts_idx=ts_idx)
# Generate training set on subset of interval using the sine function
x_train = nd.array([-4, -3, -2, -1, 1], ctx=ctx,
dtype=float_type).reshape(context_length, 1)
x_train = nd.tile(x_train, reps=(batch_size, 1, 1))
y_train = nd.sin(x_train.squeeze(axis=2))
# Predict exact GP using the GP predictive mean and covariance using the same fixed hyper-parameters
samples, predictive_mean, predictive_std = gp.exact_inference(
x_train, y_train, x_test)
assert (np.sum(np.isnan(
samples.asnumpy())) == 0), "NaNs in predictive samples!"
gp.plot(
x_train=x_train,
y_train=y_train,
x_test=x_test,
ts_idx=ts_idx,
mean=predictive_mean,
std=predictive_std,
samples=samples,
axis=axis,
)
