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