def test_two_dim_matmul(self):
max_seq_length = 3
hidden_dim = 8
# We test the 2D matmul function on the DFT calculation (primary use-case).
dft_mat_seq = jnp.asarray(linalg.dft(max_seq_length))
dft_mat_hidden = jnp.asarray(linalg.dft(hidden_dim))
two_dim_matmul = functools.partial(
fourier.two_dim_matmul,
matrix_dim_one=dft_mat_seq,
matrix_dim_two=dft_mat_hidden)
inputs = jnp.array([[1, 0, 0, 11, 9, 2, 0.4, 2], [1, 1, 0, 1, 0, 2, 8, 1],
[1, 4, 0, 5, 5, 0, -3, 1]],
dtype=jnp.float32)
expected_output = np.fft.fftn(inputs)
for precision, delta in zip(
[lax.Precision.DEFAULT, lax.Precision.HIGH, lax.Precision.HIGHEST],
[1e-4, 1e-5, 1e-5]):
actual_output = two_dim_matmul(inputs, precision=precision)
# Compare results row by row.
for i in range(max_seq_length):
self.assertSequenceAlmostEqual(
actual_output[i], expected_output[i], delta=delta)
def _init_fourier_transform(self):
"""Initializes Fourier Transform.
On GPUs/CPUs: The native FFT implementation is optimal for all sequence
lengths.
On TPUs: For relatively shorter sequences, it is faster to pre-compute the
DFT matrix and then compute Fourier Transform using matrix multiplications.
For longer sequences, the FFT is faster, provided the MAX_SEQ_LENGTH is a
power of 2.
"""
if self.config.use_fft:
if (self.config.max_seq_length > 4096 and
not math.log2(self.config.max_seq_length).is_integer()):
raise ValueError(
"For large input sequence lengths (>4096), the maximum input "
"sequence length must be a power of 2 to take advantage of FFT "
"optimizations. We encourage the same for the model hidden "
"dimension. config.max_seq_length: %d. config.d_model: $d" %
self.config.max_seq_length, self.config.d_model)
self.fourier_transform = jnp.fft.fftn
else:
dft_mat_hidden = linalg.dft(self.config.d_model)
dft_mat_seq = linalg.dft(self.config.max_seq_length)
self.fourier_transform = functools.partial(
fourier.two_dim_matmul,
matrix_dim_one=jnp.asarray(dft_mat_seq),
matrix_dim_two=jnp.asarray(dft_mat_hidden),
precision=lax.Precision.DEFAULT)
def fftImageBothWays(im, raw=True):
if raw:
im = np.array(imRaw).astype(float)
else:
im = imRaw
dftLeft = dft(im.shape[0])
dftRight = dft(im.shape[1])
return multiplyMatrixRGBArrayMatrixTranspose(dftLeft, im, dftRight)
def test_dft():
m = dft(2)
expected = array([[1.0, 1.0], [1.0, -1.0]])
yield (assert_array_almost_equal, m, expected)
m = dft(2, scale='n')
yield (assert_array_almost_equal, m, expected / 2.0)
m = dft(2, scale='sqrtn')
yield (assert_array_almost_equal, m, expected / sqrt(2.0))
x = array([0, 1, 2, 3, 4, 5, 0, 1])
m = dft(8)
mx = m.dot(x)
fx = fft(x)
yield (assert_array_almost_equal, mx, fx)
def test_dft():
m = dft(2)
expected = array([[1.0, 1.0], [1.0, -1.0]])
yield (assert_array_almost_equal, m, expected)
m = dft(2, scale='n')
yield (assert_array_almost_equal, m, expected/2.0)
m = dft(2, scale='sqrtn')
yield (assert_array_almost_equal, m, expected/sqrt(2.0))
x = array([0, 1, 2, 3, 4, 5, 0, 1])
m = dft(8)
mx = m.dot(x)
fx = fft(x)
yield (assert_array_almost_equal, mx, fx)
def DIF_FFT(N, s):
W_N = np.exp(-1j * (2 * np.pi / N))
p = [s[i] + s[i + N // 2] for i in range(N // 2)]
q = [(s[i] - s[i + N // 2]) * (W_N ** i) for i in range(N // 2)]
P = dft(N // 2) @ p
Q = dft(N // 2) @ q
result = []
for i in range(N // 2):
result.append(P[i])
result.append(Q[i])
return result
def W2_init_Imag(shape,
dtype=None,
partition_info=None): # both W1 and W2 need initialization
# fk = np.arange(N)
# fk = 2.0 * np.pi * fk / N
# fk = np.square(fk)
# Hk = -1.0 * 1j * fk * beta2 / 2.0 + alp / 2.0
# Hk = Hk * delta / 2.0
# Hk = np.exp(Hk)
Hk = np.ones(N)
Hk = Hk * 3.0
dia_Hk = np.diag(Hk)
w = dft(N)
w_invert = linalg.inv(w)
A = np.matmul(w_invert, dia_Hk)
A = np.matmul(A, w)
A_imag = np.imag(A)
return K.variable(value=A_imag, dtype=dtype)
#
# def MF_init(shape, dtype=None, partition_info=None):
# val = np.ones((N, M))
# val[1:-1, 1:-1] = 0
# return K.variable(value=val, dtype=dtype)
def __init__(self, perm=None, W=4, V=4, D=256, K=4, Modulation='QPSK'):
self.Modulation = Modulation
self.W = W
self.V = V
self.D = D
self.K = K
self.M = D // K
if self.Modulation == 'QPSK':
self.symbols = np.array([1 + 1j, 1 - 1j, -1 + 1j, -1 - 1j])
self.Q = 4
self.rate = self.V * self.K * (np.log2(self.Q) +
np.log2(self.M)) / self.D
if perm is None:
self.perm = [np.random.permutation(self.D) for i in range(W * V)]
self.perm_inv = [np.argsort(self.perm[i]) for i in range(W * V)]
self.perm = np.vstack(self.perm)
self.perm_inv = np.vstack(self.perm_inv)
self.DFT = dft(self.D)
self.dictionary = [self.DFT[self.perm[i]] for i in range(W * V)]
self.dictionary = np.hstack(self.dictionary)
def get_matrix(n, tf='dct'):
if tf == 'dft':
F = la.dft(n, scale='sqrtn')
elif tf == 'dct':
I = np.identity(n)
F = dct(I, norm='ortho')
return F
def get_half_period_fourier_basis_as_rows(nb_points, nb_vectors):
f = dft(2 * nb_points)
f_real = np.real(f)
f_imag = np.imag(f)
return np.concatenate(
[f_real[:nb_points, :nb_vectors], f_imag[:nb_points, :nb_vectors]],
axis=1).astype(np.float32)
def get_filters(R, filter_size, P=None, n_rings=None):
"""Perform single-frequency DFT on each ring of a polar-resampled patch"""
k = filter_size
filters = {}
N = n_samples(k)
from scipy.linalg import dft
for m, r in R.iteritems():
rsh = r.get_shape().as_list()
# Get the basis matrices
weights = get_interpolation_weights(k, m, n_rings=n_rings)
DFT = dft(N)[m,:]
LPF = np.dot(DFT, weights).T
cosine = np.real(LPF).astype(np.float32)
sine = np.imag(LPF).astype(np.float32)
# Reshape for multiplication with radial profile
cosine = tf.constant(cosine)
sine = tf.constant(sine)
# Project taps on to rotational basis
r = tf.reshape(r, tf.stack([rsh[0],rsh[1]*rsh[2]]))
ucos = tf.reshape(tf.matmul(cosine, r), tf.stack([k, k, rsh[1], rsh[2]]))
usin = tf.reshape(tf.matmul(sine, r), tf.stack([k, k, rsh[1], rsh[2]]))
if P is not None:
# Rotate basis matrices
ucos_ = tf.cos(P[m])*ucos + tf.sin(P[m])*usin
usin = -tf.sin(P[m])*ucos + tf.cos(P[m])*usin
ucos = ucos_
filters[m] = (ucos, usin)
return filters
def dftMatrix(size):
"""Form an explicit DFT matrix."""
M = 1
for dim in size:
m = dft(dim)
M = np.kron(M, m)
return (M)
def generate_tmats(dim, rgen):
assert SAMPLES >= 3
mats = {'ID': np.eye(dim), 'SWAP': np.eye(dim)[::-1]}
mats.update({'DFT': dft(dim, scale='sqrtn')})
mats.update({'RAND_%i' % i: unitary_haar(dim, rgen=rgen)
for i in range(SAMPLES - 3)})
return mats
def build(self, input_shape):
"""
This method must be defined for any custom layer, here you define the training parameters.
input_shape: a tensor that automatically captures the dimensions of the input by tensorflow.
"""
# get the size of the input
self.N = input_shape.as_list()[1]
# construct the DFT matrix
self.F = dft(self.N) / self.fs
# construct the trapezoidal rule matrix
self.D = np.eye(self.N // 2)
self.D[0, 0] = 0.5
self.D[-1, -1] = 0.5
# define the trainable parameters representing the double side band PSD of noise
self.S = self.add_weight(name="S",
shape=tf.TensorShape((self.N // 2, 1)),
initializer=initializers.Ones(),
constraint=constraints.NonNeg(),
trainable=True)
# this has to be called for any tensorflow custom layer
super(coherence_Layer, self).build(input_shape)
def construct_circuit(self,
mode,
register=None,
circuit=None,
use_basis_gates=True):
if mode == 'vector':
return linalg.dft(2**self._num_qubits, scale='sqrtn')
elif mode == 'circuit':
if register is None:
register = QuantumRegister(self._num_qubits, name='q')
if circuit is None:
circuit = QuantumCircuit(register)
for j in reversed(range(self._num_qubits)):
circuit.u2(0, np.pi,
register[j]) if use_basis_gates else circuit.h(
register[j])
for k in reversed(range(j)):
lam = -1.0 * pi / float(2**(j - k))
if use_basis_gates:
circuit.u1(lam / 2, register[j])
circuit.cx(register[j], register[k])
circuit.u1(-lam / 2, register[k])
circuit.cx(register[j], register[k])
circuit.u1(lam / 2, register[k])
else:
circuit.cu1(lam, register[j], register[k])
return circuit
else:
raise ValueError('Mode should be either "vector" or "circuit"')
def dft_3D_norm(matrixin3D, size):
m = dft(size)
row_fft = zeros((size, size), dtype=complex)
column_fft = zeros((size, size), dtype=complex)
z_fft = []
for i in range(0, size):
z_fft.append([])
for j in range(0, size):
z_fft[i].append([])
for k in range(0, size):
z_fft[i][j].append(1)
#Dft loop
for k in range(0, size):
test_matrix = matrixin3D[k]
for i in range(0, size):
row_fft_i = 1 / sqrt(size) * fft.fftshift(m @ test_matrix[i])
row_fft[i] = row_fft_i
for i in range(0, size):
column_fft_i = 1 / sqrt(size) * fft.fftshift(m @ row_fft[:, i])
column_fft[:, i] = (column_fft_i)
z_fft[k] = column_fft
z_fft = array(z_fft)
z_fft = array(z_fft)
#z_fft=abs(array(z_fft))
for i in range(0, size):
for j in range(0, size):
z_fft_k = 1 / sqrt(size) * fft.fftshift(m @ z_fft[:, i, j])
z_fft[:, i, j] = array(abs(z_fft_k))
return z_fft
def _cov_fourier(cov, dx, taper=None):
"""
Determine the covariance of a Fourier space vector from the known covariance of a real-space vector.
Parameters
----------
cov : array
Either square 2-dimensional covariance matrix in real space, or 3D, with first axis a dependent dimension.
dx : float
The physical interval between bins in the covariance matrix.
Returns
-------
cov_fourier : Covariance of Fourier-space vector (same shape as cov)
"""
N = cov.shape[-1]
if taper is not None:
cov *= np.outer(taper(N), taper(N))
F = dft(N, "sqrtn")
out = np.real(np.conjugate(F.T).dot(cov).dot(F).transpose(1, 0, 2) * dx**2)
# Select only positive eta entries
return out.T[1:N / 2, 1:N / 2].T
def getQExp(beta, theta, n):
assert n % 2 == 1
diagHalfArray = [beta**(i/((n-1)/2)) for i in range(1, int((n-1)/2) + 1)]
diagArray = [1] + diagHalfArray + diagHalfArray
assert len(diagArray) == n
DStar = np.diag(diagArray)
# pl.matshow(DStar)
# pl.show()
normalizedDFT = dft(n)/sqrt(n)
# print DStar
# pl.matshow(DStar)
# pl.show()
# pl.matshow(abs(np.dot(np.dot(np.transpose(np.conj(normalizedDFT)), DStar),
# normalizedDFT)))
# pl.show()
return np.dot(np.dot(np.transpose(np.conj(normalizedDFT)), DStar),
normalizedDFT)
def DIT_FFT(N, s):
even_part = [s[i] for i in range(len(s)) if i % 2 == 0]
odd_part = [s[i] for i in range(len(s)) if i % 2 != 0]
F = dft(N // 2) @ even_part
G = dft(N // 2) @ odd_part
W_N = np.exp(-1j * (2 * np.pi / N))
X = []
for i in range(N // 2):
X.append(F[i] + (W_N**i) * G[i])
for i in range(N // 2):
X.append(F[i] - (W_N**i) * G[i])
return X
def set_perm(self, perm):
self.perm = perm
self.DFT = dft(self.D)
self.dictionary = [
self.DFT[self.perm[i]] for i in range(self.W * self.V)
]
self.dictionary = np.hstack(self.dictionary)
for i in range(self.W * self.V):
self.perm_inv[i] = np.argsort(self.perm[i])
def IDFT(fourier_signal):
"""
A method for transforming back a fourier signal to it's original values
:param fourier_signal: The transformed fourier to convert back
:return: The input array in original values
"""
N = fourier_signal.shape[0]
fft_coef = np.linalg.inv(linalg.dft(N))
out_vec = (1 / N) * fft_coef.dot(fourier_signal)
return out_vec
def construct_circuit(self, mode, qubits=None, circuit=None):
if mode == 'vector':
# note the difference between QFT and DFT in the phase definition:
# QFT: \omega = exp(2*pi*i/N) ; DFT: \omega = exp(-2*pi*i/N)
# so linalg.inv(linalg.dft()) is correct for QFT
return linalg.inv(linalg.dft(2 ** self._num_qubits, scale='sqrtn'))
elif mode == 'circuit':
ftc = FourierTransformCircuits(self._num_qubits, approximation_degree=0, inverse=False)
return ftc.construct_circuit(qubits, circuit)
else:
raise ValueError('Mode should be either "vector" or "circuit"')
def multExpD(N, A, gamma, time, r):
expDList = []
qft = dft(N, scale='sqrtn')
iqft = inv(qft)
for t in time:
B = -gamma * A * t / r
lambdA = iqft @ B @ qft
D = np.diag(lambdA)
D = np.exp(-1j * D)
expDList.append(list(D))
return expDList
def generate_sequence(N, signal_length):
# generate random dictionary
D = dft(signal_length).real
# generate random outputs
y = np.zeros((N,signal_length))
for i in range(y.shape[0]):
x = np.random.choice(D.shape[1], int(D.shape[1]/10))
y[i,:] = np.sum(D[x,:], axis=0)
y[i,:] = np.multiply(y[i,:], np.random.uniform(1, 2,size=y.shape[1]))
return y
def _init_fourier_transform(self, config):
if not config.use_tpu_fourier_optimizations:
self.fourier_transform = partial(torch.fft.fftn, dim=(1, 2))
elif config.max_position_embeddings <= 4096:
if is_scipy_available():
self.register_buffer(
"dft_mat_hidden", torch.tensor(linalg.dft(config.hidden_size), dtype=torch.complex64)
)
self.register_buffer(
"dft_mat_seq", torch.tensor(linalg.dft(config.tpu_short_seq_length), dtype=torch.complex64)
)
self.fourier_transform = partial(
two_dim_matmul, matrix_dim_one=self.dft_mat_seq, matrix_dim_two=self.dft_mat_hidden
)
else:
logging.warning(
"SciPy is needed for DFT matrix calculation and is not found. Using TPU optimized fast fourier transform instead."
)
self.fourier_transform = fftn
else:
self.fourier_transform = fftn
def _init_fourier_transform(self, config):
if not config.use_tpu_fourier_optimizations:
self.fourier_transform = partial(torch.fft.fftn, dim=(1, 2))
elif config.n_pos <= 4096:
if is_scipy_available():
self.register_buffer(
"dft_mat_hidden",
torch.tensor(linalg.dft(config.d_model), dtype=torch.complex64),
)
self.register_buffer(
"dft_mat_seq",
torch.tensor(linalg.dft(config.tpu_short_seq_length), dtype=torch.complex64),
)
self.fourier_transform = partial(
two_dim_matmul,
matrix_dim_one=self.dft_mat_seq,
matrix_dim_two=self.dft_mat_hidden,
)
else:
self.fourier_transform = fftn
else:
self.fourier_transform = fftn
def calc_coeffs_DFT(self, OAreg, HCreg, filt, ND = [None], target = [None], fluxTimesE = False):
if not np.any(ND):
ND = self.ND
if not np.any(target):
target = self.target
if fluxTimesE:
ND = ND*self.Ebins.reshape(ND.shape[0], 1)
target = target*self.Ebins
# if not np.any(filt):
# filt = np.ones_like(self.OAbins <= self.maxOA, dtype = float)
# penalty matrix for coefficients
nBinsOA = np.sum(self.OAbins <= self.maxOA)
nBinsHC = self.ND_HC.shape[1]
# # OA penalty term is a difference matrix
# OA_penalty = np.diag(nBinsOA*[1]) - np.diag((nBinsOA - 1)*[1], k = 1)
# # OA penalty term is the L1 norm
# OA_penalty = np.eye(nBinsOA)
# OA penalty is a frequency filter based on the DFT
from scipy.linalg import dft
# OA_penalty = np.diag(filt)*dft(nBinsOA) + OAreg*(np.diag(nBinsOA*[1]) - np.diag((nBinsOA - 1)*[1], k = 1))
OA_penalty = np.diag(filt)*dft(nBinsOA) + OAreg*(np.diag(nBinsOA*[1]) - np.diag((nBinsOA - 1)*[1], k = 1))
HC_penalty = np.eye(nBinsHC)
self.A = block_diag(OA_penalty, HC_penalty)
# Gamma = block_diag(OAreg*OA_penalty, HCreg*HC_penalty)
Gamma = block_diag(OA_penalty, HCreg*HC_penalty)
self.Gamma = Gamma
# weighting matrix for target flux
P = np.diag(np.where(self.Ebins > self.Ebounds[1],
self.OutOfRegionFactors[1],
np.where(self.Ebins < self.Ebounds[0],
self.OutOfRegionFactors[0],
1)))
self.P = P
# ND matrix
NDmatr = np.matrix(ND)
LHS = np.matmul(NDmatr.T, np.matmul(P, NDmatr)) + np.matmul(Gamma.T.conj(), Gamma)
RHS = np.dot(np.matmul(NDmatr.T, P), target)
self.c = np.array(np.dot(RHS, LHS.I)).squeeze()
self.c = np.linalg.solve(LHS, RHS)
self.cOA = self.c[:nBinsOA]
self.cHC = self.c[nBinsOA:]
self.fluxPred = np.dot(self.ND, self.c)
self.ratePred = np.dot(self.ND_rate, self.c)
self.ratePred_statErr = np.sqrt(np.dot(self.ND_rate, np.power(self.c, 2)))
def __init__(self, frame_size=512, frame_shift=256, loss_type='mae'):
self.frame_size = frame_size
self.frame_shift = frame_shift
self.loss_type = loss_type
#self.device = device
self.frame = TorchSignalToFrames(frame_size=self.frame_size,
frame_shift=self.frame_shift)
D = linalg.dft(frame_size)
W = np.hamming(self.frame_size)
DR = np.real(D)
DI = np.imag(D)
self.DR = torch.from_numpy(DR).float().cuda() # to(self.device)
self.DR = self.DR.contiguous().transpose(0, 1)
self.DI = torch.from_numpy(DI).float().cuda() # to(self.device)
self.DI = self.DI.contiguous().transpose(0, 1)
self.W = torch.from_numpy(W).float().cuda() # to(self.device)
def MMSE_FDE(self, receive_signal, channel, sigma):
self.receive_signal = receive_signal
self.channel = channel
self.sigma = sigma
# DFT matrix
DFT = dft(self.Nc)
IDFT = (np.conjugate(DFT).T) / self.Nc
# Fourier transform
Fourier_channel = np.dot(DFT, self.channel)
Fourier_receive_signal = np.dot(DFT, self.receive_signal)
# Noise Power
Pn = 2 * self.sigma * self.sigma * self.user
# Eye matrix for MMSE
I = np.eye(self.BS, dtype=np.complex)
I = Pn * I
# Calculate MMSE Weight
H = np.zeros((self.BS, self.user), dtype=np.complex)
Fourier_FDE_signal = np.zeros((self.Nc, self.user), dtype=np.complex)
R = np.zeros((self.BS, 1), dtype=np.complex)
for r in range(self.BS):
for s in range(self.user):
H[r, s] = Fourier_channel[0, self.BS * r + s]
MMSE_W = np.dot(H, np.conjugate(H.T)) + I
MMSE_Weight = np.dot(np.linalg.inv(MMSE_W), H)
for i in range(self.Nc):
for r in range(self.BS):
R[r, 0] = Fourier_receive_signal[i, r]
tmp = np.dot(np.conjugate(MMSE_Weight.T), R)
for s in range(self.user):
Fourier_FDE_signal[i, s] = tmp[s, 0]
# Inv Fourier transform
FDE_signal = np.dot(IDFT, Fourier_FDE_signal)
return FDE_signal
def __init__(self,
block,
subcarrier,
CP,
sigma,
gamma=0.0,
phi=0.0,
PA_IBO_dB=5,
PA_rho=2,
LNA_alpha_1=5,
LNA_alpha_2=2,
h_si_list=None,
h_s_list=None,
h_si_len=1,
h_s_len=1,
receive_antenna=1,
tx_iqi=True,
pa=True,
lna=True,
rx_iqi=True,
equalizer='ZF'):
self.block = block
self.subcarrier = subcarrier
self.CP = CP
self.sigma = sigma
self.gamma = gamma
self.phi = phi
self.PA_IBO_dB = PA_IBO_dB
self.PA_rho = PA_rho
self.LNA_alpha_1 = LNA_alpha_1
self.LNA_alpha_2 = LNA_alpha_2
self.h_si_list = h_si_list
self.h_s_list = h_s_list
self.h_si_len = h_si_len
self.h_s_len = h_s_len
self.receive_antenna = receive_antenna
self.tx_iqi = tx_iqi
self.pa = pa
self.lna = lna
self.rx_iqi = rx_iqi
self.subcarrier_CP = subcarrier + CP
self.dft_mat = dft(self.subcarrier, scale="sqrtn")
self.idft_mat = self.dft_mat.conj().T
self.cp_zero = np.hstack((np.zeros(
(self.subcarrier, self.CP)), np.eye(self.subcarrier)))
def DFT(size, cutoff):
r"""Discrete Fourier transform in the Fock basis.
Args:
size (int): size of the DFT. The unitary will
act on Fock basis elements |0> to |size-1>.
cutoff (int): the Fock basis truncation of the returned unitary.
Must be larger than size.
Returns:
array: a [cutoff, cutoff] complex array representing
the action of the DFT in the truncated
Fock basis.
"""
U = np.identity(cutoff, dtype=np.complex128)
U[:size, :size] = dft(size)/np.sqrt(size)
return U
def get_transform_matrix(self, size):
""" Calculates the transform matrix based on self.matrix parameter,
which can be {'dct', 'dft'}."""
if self.matrix == 'dct':
'''Calculate the square DCT transform matrix. Results are
equivalent to Matlab dctmtx(n) with 64 bit precision.'''
transform_matrix = np.array(range(size),
np.float64).repeat(size).reshape(
size, size)
transform_matrixT = np.pi * (transform_matrix.transpose() +
0.5) / size
transform_matrixT = (1.0 / np.sqrt(size / 2.0)) * np.cos(
transform_matrix * transform_matrixT)
transform_matrixT[0] = transform_matrixT[0] * (np.sqrt(2.0) / 2.0)
elif self.matrix == 'dft':
transform_matrixT = dft(size, scale='sqrtn')
return transform_matrixT
def construct_circuit(self, mode, register=None, circuit=None):
if mode == 'vector':
return linalg.dft(2**self._num_qubits, scale='sqrtn')
elif mode == 'circuit':
if register is None:
register = QuantumRegister(self._num_qubits, name='q')
if circuit is None:
circuit = QuantumCircuit(register)
for j in reversed(range(self._num_qubits)):
circuit.h(register[j])
# neighbor_range = range(np.max([0, j - self._degree + 1]), j)
neighbor_range = range(
np.max([0, j - self._num_qubits + self._degree + 1]), j)
for k in reversed(neighbor_range):
circuit.cu1(-1.0 * pi / float(2**(j - k)), register[j],
register[k])
return circuit
else:
raise ValueError('Mode should be either "vector" or "circuit"')
def test_fourier_matrices_product(self):
"""
Test Fourier basis transition
This test validates that the transition of a matrix from Fourier basis to the standard basis is equivalent to
multiplying my the DFT matrix from right and its inverse from the left.
"""
rng = Generator(PCG64(1995))
n: int = rng.integers(low=2, high=100)
mat: Matrix = rng.standard_normal((n, n))
tested_output = change_from_fourier_basis(mat)
dft_mat: Matrix = dft(n, scale="sqrtn")
expected_output: Matrix = np.conj(dft_mat.T).dot(mat).dot(dft_mat)
self.assertTrue(np.allclose(tested_output, expected_output))
mat: Matrix = rng.standard_normal((n, n))
mat_fourier: Matrix = change_to_fourier_basis(mat)
expected_output: Matrix = dft_mat.dot(mat).dot(np.conj(dft_mat.T))
self.assertTrue(np.allclose(mat_fourier, expected_output))
def __init__(self, idim, odim,
rng=None,
irange=0.1):
super(ComplexLinear, self).__init__(rng=rng)
self.idim = idim
self.odim = odim
# must be true for fourier layer
assert idim == odim
# odim is output and the input dimensions of the DFT layer
dft_mat = dft(odim).T
# diag(M * M^{dagger}) gives me the normalization values for each row
# setting M = M^T does the trick for collumns
normalization_vals = numpy.diag((dft_mat.T).dot(numpy.conj(dft_mat.T)))
# This is the renormalized weight matrix from my understanding
self.W = dft_mat # / normalization_vals.reshape(-1,1)
# seperating in to two (outputing double number of neurons )
self.Wr = numpy.real(self.W)
self.Wi = numpy.imag(self.W)
self.b = numpy.zeros((self.odim*2,), dtype=numpy.float32)
ax.set_ylabel("Mutual information (bits)")
ax.set_xlabel("p")
pl.show()
sys.exit()
if covTest:
n = 101
scaling = 1
cov = getChristosCovMat(n, scaling)
print abs(np.dot(np.dot(dft(n), cov), np.transpose(dft(n))))/n
pl.matshow(abs(np.dot(np.dot(dft(n), cov), np.transpose(dft(n)))))
pl.show()
if uptTest:
n = 80
# upt = np.triu(np.ones((n,n)))
# upt = np.identity(n)
# upt = circ([0]*int(n/2) + [1]*int(n/2))
# print sorted([abs(i) for i in np.linalg.eig(upt)[0]])
p.matshow(np.real(np.dot(meb, np.conj(np.transpose(meb)))), cmap="Greys_r") p.colorbar() p.show() # tm = circulant(seq) # meb = fourierEigenbasis(n) p.matshow(np.real(meb), cmap="Greys_r") p.show() diag = np.dot(np.dot(meb, tm), np.transpose(np.conj(meb))) p.matshow(np.real(diag), cmap="Greys_r") p.colorbar() p.show() meb = dft(n) tm = circulant(seq) diag = np.dot(np.dot(meb, tm), np.transpose(np.conj(meb))) p.matshow(np.real(meb), cmap="Greys_r") p.show() p.matshow(np.real(diag), cmap="Greys_r") p.colorbar() p.show()
# s = (np.random.binomial(1,p,n)*2 - np.ones(n))
s = getCenteredVector(p, n)
print mean(s)
print variance(s)
# print s
c = circ(s)
normalizedC = c/sqrt(n)
print normalizedC
dftMat = dft(n)/sqrt(n)
diagC = np.dot(np.dot(np.conj(dftMat), normalizedC), dftMat)
print diagC
diagDiagC = np.diagonal(diagC)
pl.plot(np.multiply(np.conjugate(diagDiagC), diagDiagC))
pl.show()
pl.matshow(np.real(diagC))
pl.show()
# sys.exit()
# h = circhank(s)
# normalizedH = h/sqrt(n)
# s = (np.random.binomial(1,p,n)*2 - np.ones(n))
s = getCenteredVector(p, n)
print mean(s)
print variance(s)
# print s
c = circ(s)
normalizedC = c/sqrt(n)
print normalizedC
dftMat = dft(n)/sqrt(n)
diagC = np.dot(np.dot(np.conj(dftMat), normalizedC), dftMat)
print diagC
diagDiagC = np.diagonal(diagC)
pl.plot(np.multiply(np.conjugate(diagDiagC), diagDiagC))
pl.show()
pl.matshow(np.real(diagC))
pl.show()
# sys.exit()
# h = circhank(s)
# normalizedH = h/sqrt(n)
def time_dft(self, size):
sl.dft(size)
