def encoding_func(features): """ Take in 'n' features as a numpy array, and output a 'dim' dimensional SSP """ vec = power(axis_vectors[0], features[0]) for i in range(1, n): vec *= power(axis_vectors[i], features[i]) return vec.v
def encoding_func(features): """ Take in 'n' features as a numpy array, and output a 'dim' dimensional SSP """ # TODO: any scaling required? # TODO: make sure matrix multiply order is correct tranformed_features = transform_axes @ features vec = power(axis_vectors[0], tranformed_features[0]) for i in range(1, n + 1): vec *= power(axis_vectors[i], tranformed_features[i]) return vec.v
def encode_point_n(x, y, axis_sps, x_axis, y_axis): """ Encodes a given 2D point as a ND SSP """ # 2D point represented as an N dimensional vector in the plane spanned by 'x_axis' and 'y_axis' vec = (x_axis * x + y_axis * y) # Generate the SSP from the high dimensional vector, by convolving all of the axis vector components together ret = power(axis_sps[0], vec[0]) for i in range(1, len(axis_sps)): ret *= power(axis_sps[i], vec[i]) return ret
def encode_dataset(data, dim=256, seed=13, scale=1.0): """ :param data: the data to be encoded :param dim: dimensionality of the SSP :param seed: seed for the single axis vector :param scale: scaling of the data for the encoding :return: """ rng = np.random.RandomState(seed=seed) # TODO: have option to normalize everything first, for consistent relative scale axis_vec = make_good_unitary(dim, rng=rng) n_samples = data.shape[0] n_features = data.shape[1] n_out_features = n_features * dim data_out = np.zeros((n_samples, n_out_features)) for s in range(n_samples): for f in range(n_features): data_out[s, f * dim:(f + 1) * dim] = power(axis_vec, data[s, f] * scale).v return data_out
def get_axes_and_scale(dim=256, n=3, seed=13, apply_scaling=True): """ Get X and Y axis vectors based on an n dimensional projection. Also return the correct scaling so the size of the bump in the heatmap is consistent """ rng = np.random.RandomState(seed=seed) points_nd = np.eye(n) * np.sqrt(n) # points in 2D that will correspond to each axis, plus one at zero points_2d = np.zeros((n, 2)) thetas = np.linspace(0, 2 * np.pi, n + 1)[:-1] # TODO: will want a scaling here, or along the high dim axes for i, theta in enumerate(thetas): points_2d[i, 0] = np.cos(theta) points_2d[i, 1] = np.sin(theta) transform_mat = np.linalg.lstsq(points_2d, points_nd) x_axis = transform_mat[0][0, :] y_axis = transform_mat[0][1, :] if apply_scaling: x_axis /= transform_mat[3][0] y_axis /= transform_mat[3][1] axis_sps = [] for i in range(n): # random unitary vector axis_sps.append(make_good_unitary(dim, rng=rng)) X = power(axis_sps[0], x_axis[0]) Y = power(axis_sps[0], y_axis[0]) for i in range(1, n): X *= power(axis_sps[i], x_axis[i]) Y *= power(axis_sps[i], y_axis[i]) return X, Y, transform_mat[3][0]
X_vec = circulant_matrix_to_vec(covariance) X = spa.SemanticPointer(data=X_vec) # X.make_unitary() X_circ = circulant(X.v) else: raise NotImplementedError plt.figure() plt.imshow(X_circ) similarity = np.zeros((args.res, )) zero_vec = np.zeros((dim, )) zero_vec[0] = 1 for i, x in enumerate(xs): p = power(X, x) similarity[i] = np.dot(p.v, zero_vec) plt.figure() plt.plot(similarity) plt.show() # def compute_circulant_matrix(vec): # # mat = np.zeros((len(vec), len(vec))) # # for i in range(len(vec)): # mat[i, :]
fig, ax = plt.subplots(1, 3, figsize=(8, 4)) sigma_normal = 0.5 sigma_hex = 0.5 sigma_hex_c = 0.5 sim_hex = np.zeros((res, )) sim_hex_c = np.zeros((res, )) # this version has axes generated together and then converted to 2D sim_normal = np.zeros((res, )) gauss_hex = gaussian_1d(0, sigma_hex, xs) gauss_hex_c = gaussian_1d(0, sigma_hex_c, xs) gauss_normal = gaussian_1d(0, sigma_normal, xs) for i, x, in enumerate(xs): sim_normal[i] = power(X, x).v[0] sim_hex_c[i] = power(Xh, x).v[0] sim_hex[i] = encode_point_hex(0, x, X, Y, Z).v[0] ax[0].plot(xs, sim_normal) ax[0].plot(xs, gauss_normal) ax[1].plot(xs, sim_hex) ax[1].plot(xs, gauss_hex) ax[2].plot(xs, sim_hex_c) ax[2].plot(xs, gauss_hex_c) for i in range(len(ax)): ax[i].set_ylim([-.2, 1.2]) plt.show()
def orthogonal_hex_dir_7dim(phi=np.pi / 2., angle=0): dim = 7 xf = np.zeros((dim, ), dtype='Complex64') xf[0] = 1 xf[1] = np.exp(1.j * phi) xf[2] = 1 xf[3] = 1 xf[4] = np.conj(xf[3]) xf[5] = np.conj(xf[2]) xf[6] = np.conj(xf[1]) yf = np.zeros((dim, ), dtype='Complex64') yf[0] = 1 yf[1] = 1 yf[2] = np.exp(1.j * phi) yf[3] = 1 yf[4] = np.conj(yf[3]) yf[5] = np.conj(yf[2]) yf[6] = np.conj(yf[1]) zf = np.zeros((dim, ), dtype='Complex64') zf[0] = 1 zf[1] = 1 zf[2] = 1 zf[3] = np.exp(1.j * phi) zf[4] = np.conj(zf[3]) zf[5] = np.conj(zf[2]) zf[6] = np.conj(zf[1]) Xh = np.fft.ifft(xf).real Yh = np.fft.ifft(yf).real Zh = np.fft.ifft(zf).real # checks to make sure everything worked correctly assert np.allclose(np.abs(xf), 1) assert np.allclose(np.abs(yf), 1) assert np.allclose(np.fft.fft(Xh), xf) assert np.allclose(np.fft.fft(Yh), yf) assert np.allclose(np.linalg.norm(Xh), 1) assert np.allclose(np.linalg.norm(Yh), 1) axis_sps = [ spa.SemanticPointer(data=Xh), spa.SemanticPointer(data=Yh), spa.SemanticPointer(data=Zh), ] n = 3 points_nd = np.eye(n) * np.sqrt(n) # points in 2D that will correspond to each axis, plus one at zero points_2d = np.zeros((n, 2)) thetas = np.linspace(0, 2 * np.pi, n + 1)[:-1] + angle # TODO: will want a scaling here, or along the high dim axes for i, theta in enumerate(thetas): points_2d[i, 0] = np.cos(theta) points_2d[i, 1] = np.sin(theta) transform_mat = np.linalg.lstsq(points_2d, points_nd) x_axis = transform_mat[0][0, :] / transform_mat[3][0] y_axis = transform_mat[0][1, :] / transform_mat[3][1] X = power(axis_sps[0], x_axis[0]) Y = power(axis_sps[0], y_axis[0]) for i in range(1, n): X *= power(axis_sps[i], x_axis[i]) Y *= power(axis_sps[i], y_axis[i]) sv = transform_mat[3][0] return X, Y, sv, transform_mat[0]
def encoding_func(feature): return power(axis_vec, feature * scale * axis_scaling).v
def encode_point_3d(x, y, z, x_axis_sp, y_axis_sp, z_axis_sp): return power(x_axis_sp, x) * power(y_axis_sp, y) * power(z_axis_sp, z)
locs = [ 0, 2.2, -3.4, ] locs = [ 0, 3.2, ] n_locs = len(locs) vecs = np.zeros((n_locs, dim)) for i, loc in enumerate(locs): vecs[i, :] = power(X, loc).v sims = np.zeros((res, n_locs)) for i, x in enumerate(xs): hmv[i, :] = power(X, x).v for j in range(n_locs): sims[i, j] = np.dot(vecs[j], hmv[i, :]) plt.plot(xs, sims, linewidth=2.5) plt.legend(["k = {}".format(k) for k in locs], fontsize=16) plt.xlabel("Exponent", fontsize=18) plt.ylabel("Dot Product", fontsize=18)