Example #1
0
    def sample_preimage(self, point):
        """
        Sample a short vector s such that s[0] + s[1] * h = point.
        """
        [[a, b], [c, d]] = self.B0_fft

        # We compute a vector t_fft such that:
        #     (fft(point), fft(0)) * B0_fft = t_fft
        # Because fft(0) = 0 and the inverse of B has a very specific form,
        # we can do several optimizations.
        point_fft = fft(point)
        t0_fft = [(point_fft[i] * d[i]) / q for i in range(self.n)]
        t1_fft = [(-point_fft[i] * b[i]) / q for i in range(self.n)]
        t_fft = [t0_fft, t1_fft]

        # We now compute v such that:
        #     v = z * B0 for an integral vector z
        #     v is close to (point, 0)
        z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin)
        v0_fft = add_fft(mul_fft(z_fft[0], a), mul_fft(z_fft[1], c))
        v1_fft = add_fft(mul_fft(z_fft[0], b), mul_fft(z_fft[1], d))
        v0 = [int(round(elt)) for elt in ifft(v0_fft)]
        v1 = [int(round(elt)) for elt in ifft(v1_fft)]

        # The difference s = (point, 0) - v is such that:
        #     s is short
        #     s[0] + s[1] * h = point
        s = [sub(point, v0), neg(v1)]
        return s
Example #2
0
 def sample_preimage_fft(self, point):
     """Sample preimage."""
     B = self.B0_fft
     c = point, [0] * self.n
     t_fft = self.get_coord_in_fft(c)
     z_fft = ffsampling_fft(t_fft, self.T_fft)
     v0_fft = add_fft(mul_fft(z_fft[0], B[0][0]),
                      mul_fft(z_fft[1], B[1][0]))
     v1_fft = add_fft(mul_fft(z_fft[0], B[0][1]),
                      mul_fft(z_fft[1], B[1][1]))
     v0 = [int(round(elt)) for elt in ifft(v0_fft)]
     v1 = [int(round(elt)) for elt in ifft(v1_fft)]
     v = v0, v1
     s = [sub(c[0], v[0]), sub(c[1], v[1])]
     return s
Example #3
0
    def sample_preimage_fft(self, point):
        """
        Sample preimage.

        Input:
        self        The private key
        point       An element of Z_q[x] / (x ** d + 1)

        Output:
        s           A short element such that s * B = point

        Format:     Coefficient
        """
        d = self.d
        m = self.m
        # Compute large preimage
        c = [point] + [[0] * d for _ in range(m)]
        # Move to FFT domain
        c_fft = [fft(elt) for elt in c]
        # Compute coefficients in span(B)
        t_fft = vecmatmul_fft(c_fft, self.invB_fft)
        # Fast Fourier sampling
        z_fft = ffsampling_fft(t_fft, self.T_fft)
        # Compute short preimage s = (c - v) = (t - z) * B
        v_fft = vecmatmul_fft(z_fft, self.B_fft)
        v = [[int(round(coef)) for coef in ifft(elt)] for elt in v_fft]
        s = [sub(c[i], v[i]) for i in range(m + 1)]
        return s
    def __fitcf__(self, **args):
        train_objects_files = returnFiles(args['train_object_folder'])
        train_objects = returnImages(train_objects_files)
        transformed_train_objects = preproc(train_objects)
        filter_raw = cf.synthesize(
            transformed_train_objects,
            train_object_labels=args['train_object_labels'],
            filter_type=self.args['filter_type'])

        if self.type is 'cf':
            self.data = filter_raw
            self.__setthr__(transformed_train_objects,
                            args['train_object_labels'])
        else:
            filter_holo = synthesizeHolo(ifft(filter_raw))
            self.data = proc(filter_holo, self.processing, **self.args)
            transformed_train_objects = [
                square(element,
                       np.shape(self.data)[0], 0, True)
                for element in transformed_train_objects
            ]
            self.__setthr__(transformed_train_objects,
                            args['train_object_labels'])

        if args['is_save']:
            self.__save()
    def __save(self):
        """\n    For saving of classifier.
        In progress...
        """
        full_path = pjoin('data', 'model', self.type)
        full_classifier_name = pjoin(full_path, self.name) + '.pkl'
        if not (os.path.isdir(full_path)):
            try:
                os.mkdir(full_path)
            except OSError:
                raise OSError(
                    "directory {} can't be created!".format(full_path))

        with open(full_classifier_name, 'wb') as output:
            dump(self.data, output)

        if self.type is 'cf':
            full_image_name = pjoin(full_path, self.name) + '.png'
            img = np.real(ifft(self.data))
            img = img.astype(float) * 255 / np.max(img)
            cv.imwrite(full_image_name, img)
        elif self.type is 'cf_holo':
            full_image_name = pjoin(full_path, self.name) + '.png'
            img = np.abs(self.data)
            img = img.astype(float) * 255 / np.max(img)
            cv.imwrite(full_image_name, img)
Example #6
0
def conv_fft(y, z, n):

    y_value = fft(y)
    z_value = fft(z)

    result = [y_value[i] * z_value[i] / n for i in xrange(n)]

    return [i.real for i in ifft(result)]
def reduce(f, g, F, G):
    """
    Reduce (F, G) relatively to (f, g).

    This is done via Babai's reduction.
    (F, G) <-- (F, G) - k * (f, g), where k = round((F f* + G g*) / (f f* + g g*)).
    Corresponds to algorithm 7 (Reduce) of Falcon's documentation.
    """
    n = len(f)
    size = max(53, bitsize(min(f)), bitsize(max(f)), bitsize(min(g)),
               bitsize(max(g)))

    f_adjust = [elt >> (size - 53) for elt in f]
    g_adjust = [elt >> (size - 53) for elt in g]
    fa_fft = fft(f_adjust)
    ga_fft = fft(g_adjust)

    while (1):
        # Because we work in finite precision to reduce very large polynomials,
        # we may need to perform the reduction several times.
        Size = max(53, bitsize(min(F)), bitsize(max(F)), bitsize(min(G)),
                   bitsize(max(G)))
        if Size < size:
            break

        F_adjust = [elt >> (Size - 53) for elt in F]
        G_adjust = [elt >> (Size - 53) for elt in G]
        Fa_fft = fft(F_adjust)
        Ga_fft = fft(G_adjust)

        den_fft = add_fft(mul_fft(fa_fft, adj_fft(fa_fft)),
                          mul_fft(ga_fft, adj_fft(ga_fft)))
        num_fft = add_fft(mul_fft(Fa_fft, adj_fft(fa_fft)),
                          mul_fft(Ga_fft, adj_fft(ga_fft)))
        k_fft = div_fft(num_fft, den_fft)
        k = ifft(k_fft)
        k = [int(round(elt)) for elt in k]
        if all(elt == 0 for elt in k):
            break
        # The two next lines are the costliest operations in ntru_gen
        # (more than 75% of the total cost in dimension n = 1024).
        # There are at least two ways to make them faster:
        # - replace Karatsuba with Toom-Cook
        # - mutualized Karatsuba, see ia.cr/2020/268
        # For simplicity reasons, we didn't implement these optimisations here.
        fk = karamul(f, k)
        gk = karamul(g, k)
        for i in range(n):
            F[i] -= fk[i] << (Size - size)
            G[i] -= gk[i] << (Size - size)
    return F, G
Example #8
0
    def sample_preimage(self, point, seed=None):
        """
        Sample a short vector s such that s[0] + s[1] * h = point.
        """
        [[a, b], [c, d]] = self.B0_fft

        # We compute a vector t_fft such that:
        #     (fft(point), fft(0)) * B0_fft = t_fft
        # Because fft(0) = 0 and the inverse of B has a very specific form,
        # we can do several optimizations.
        point_fft = fft(point)
        t0_fft = [(point_fft[i] * d[i]) / q for i in range(self.n)]
        t1_fft = [(-point_fft[i] * b[i]) / q for i in range(self.n)]
        t_fft = [t0_fft, t1_fft]

        # We now compute v such that:
        #     v = z * B0 for an integral vector z
        #     v is close to (point, 0)
        if seed is None:
            # If no seed is defined, use urandom as the pseudo-random source.
            z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin, urandom)
        else:
            # If a seed is defined, initialize a ChaCha20 PRG
            # that is used to generate pseudo-randomness.
            chacha_prng = ChaCha20(seed)
            z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin,
                                   chacha_prng.randombytes)

        v0_fft = add_fft(mul_fft(z_fft[0], a), mul_fft(z_fft[1], c))
        v1_fft = add_fft(mul_fft(z_fft[0], b), mul_fft(z_fft[1], d))
        v0 = [int(round(elt)) for elt in ifft(v0_fft)]
        v1 = [int(round(elt)) for elt in ifft(v1_fft)]

        # The difference s = (point, 0) - v is such that:
        #     s is short
        #     s[0] + s[1] * h = point
        s = [sub(point, v0), neg(v1)]
        return s
Example #9
0
def radon(tomo_stack, deapodization_factor, ST, k_r, num_angles, xp, fft):

    num_slices = tomo_stack.shape[0]
    num_rays = tomo_stack.shape[2]

    sinogram_stack = xp.empty((num_slices, num_angles, num_rays),
                              dtype=xp.float32)

    deapodization_factor.shape = (num_rays, num_rays)

    #go through each slice
    #for i in range(0,num_slices):
    #    tomo_slice = tomo_stack[i]

    # two slices at once by merrging into a complex
    for i in range(0, num_slices, 2):

        # merge two slices into complex
        if i > num_slices - 2:
            tomo_slice = tomo_stack[i]

        else:
            tomo_slice = tomo_stack[i] + 1j * tomo_stack[i + 1]

        ###################################
        # non uniform FFT cartesian (x,y) to Fourier polar (q,theta):
        tomo_slice = tomo_slice * deapodization_factor
        tomo_slice = fft.fft2(tomo_slice)

        # gridding from cartiesian (qx,qy) to polar (q-theta)
        sinogram = (ST) * tomo_slice.ravel()  #SpMV
        sinogram.shape = (num_angles, num_rays)

        # end of non uniform FFT
        ###################################

        # (q-theta) to radon (r-theta) :
        sinogram = fft.ifft(sinogram)

        # put the sinogram in the stack
        # extract two slices out of complex
        if i > num_slices - 2:
            #print("ratio gridrec_transpose i/r=",  xp.max(xp.abs(sinogram.imag)/xp.max(xp.abs(sinogram.real))))

            sinogram_stack[i] = sinogram.real
        else:
            sinogram_stack[i] = sinogram.real
            sinogram_stack[i + 1] = sinogram.imag

    return sinogram_stack
Example #10
0
def reduce(f, g, F, G):
    """
    Reduce (F, G) relatively to (f, g).

    This is done via Babai's reduction.
    (F, G) <-- (F, G) - k * (f, g), where k = round((F f* + G g*) / (f f* + g g*)).
    Similar to algorithm Reduce of Falcon's documentation.

    Input:
    f, g, F, G      Four polynomials mod (x ** n + 1)

    Output:
    None            The inputs are reduced as detailed above.

    Format:         Coefficient
    """
    n = len(f)
    size = max(53, bitsize(min(f)), bitsize(max(f)), bitsize(min(g)), bitsize(max(g)))

    f_adjust = [elt >> (size - 53) for elt in f]
    g_adjust = [elt >> (size - 53) for elt in g]
    fa_fft = fft(f_adjust)
    ga_fft = fft(g_adjust)

    while(1):
        # Because we are working in finite precision to reduce very large polynomials,
        # we may need to perform the reduction several times.
        Size = max(53, bitsize(min(F)), bitsize(max(F)), bitsize(min(G)), bitsize(max(G)))
        if Size < size:
            break

        F_adjust = [elt >> (Size - 53) for elt in F]
        G_adjust = [elt >> (Size - 53) for elt in G]
        Fa_fft = fft(F_adjust)
        Ga_fft = fft(G_adjust)

        den_fft = add_fft(mul_fft(fa_fft, adj_fft(fa_fft)), mul_fft(ga_fft, adj_fft(ga_fft)))
        num_fft = add_fft(mul_fft(Fa_fft, adj_fft(fa_fft)), mul_fft(Ga_fft, adj_fft(ga_fft)))
        k_fft = div_fft(num_fft, den_fft)
        k = ifft(k_fft)
        k = [int(round(elt)) for elt in k]
        if all(elt == 0 for elt in k):
            break
        fk = karamul(f, k)
        gk = karamul(g, k)
        for i in range(n):
            F[i] -= fk[i] << (Size - size)
            G[i] -= gk[i] << (Size - size)
    return F, G
def corr(img, flt):
    """\n    Calculate correlation of input image and filter. Fourier image of
    filter is used. Be careful!
    Parameters
    ----------
    img : ndarray
        Input image
    flt : ndarray
        Input filter Fourier image.

    Returns
    -------
    corr : ndarray
    """
    return ifft(fft(img) * np.conj(flt))
Example #12
0
 def computeCMBY(d0):
     """
     For CMB, y = S^1/2 A N^-1 d, where S is CMB signal covariance matrix (Cl's)
     """
     # N.B. Reshaping operations required to go between 2D pixel arrays and 
     # 1D vector (for linear system)
     d2 = 0
     for freq in range(nFreq):
         d1 = d0[freq].data.copy().reshape((ny,nx))
         d1 *= ninvs[freq]
         a_l = fft.fft(d1,axes=[-2,-1])
         a_l *= beams[freq]*precond_2d
         d1 = numpy.real(fft.ifft(a_l,axes=[-2,-1],normalize=True))
         d1 = numpy.reshape(d1,(nx*ny))
         d2 += d1
     return d2
Example #13
0
def test_ffnp(d, m, iterations):
    """Test ffnp.

    This functions check that:
    1. the two versions (coefficient and FFT embeddings) of ffnp are consistent
    2. ffnp output lattice vectors close to the targets.
    """
    q = q_12289
    A, B, inv_B, sqr_gsnorm = module_ntru_gen(d, q, m)
    G0 = gram(B)
    G0_fft = [[fft(elt) for elt in row] for row in G0]
    T = ffldl(G0)
    T_fft = ffldl_fft(G0_fft)
    th_bound = (m + 1) * d * sqr_gsnorm / 4.

    mn = 0
    for i in range(iterations):
        t = [[random() for coef in range(d)] for poly in range(m + 1)]
        t_fft = [fft(elt) for elt in t]

        z = ffnp(t, T)
        z_fft = ffnp_fft(t_fft, T_fft)

        zb = [ifft(elt) for elt in z_fft]
        zb = [[round(coef) for coef in elt] for elt in zb]
        if z != zb:
            print("ffnp and ffnp_fft are not consistent")
            return False
        diff = [sub(t[i], z[i]) for i in range(m + 1)]
        diffB = vecmatmul(diff, B)
        norm_zmc = int(round(sqnorm(diffB)))
        mn = max(mn, norm_zmc)

    if mn > th_bound:
        print("z = {z}".format(z=z))
        print("t = {t}".format(t=t))
        print("mn = {mn}".format(mn=mn))
        print("th_bound = {th_bound}".format(th_bound=th_bound))
        print("sqr_gsnorm = {sqr_gsnorm}".format(sqr_gsnorm=sqr_gsnorm))
        print("Warning: the algorithm outputs vectors longer than expected")
        return False
    else:
        return True
def restoreHolo(holo_image, show_image=True):
    """\n    Restore Fourier hologram of input image.
    Parameters
    ----------
    holo_image : ndarray
    show_image : bool, default=True
        If True, shows image in new figure.

    Returns
    -------
    restored_holo_image : ndarray
    """
    restored_holo_image = np.abs(ifft(holo_image))
    image_shape = np.shape(restored_holo_image)
    restored_holo_image[image_shape[0] / 2, image_shape[1] / 2] = 0
    restored_holo_image -= np.min(restored_holo_image)
    restored_holo_image /= np.max(restored_holo_image)
    if show_image:
        cv.imshow("Restored Holo", restored_holo_image)
    return restored_holo_image
Example #15
0
def test_ffnp(n, iterations):
    """Test ffnp.

    This functions check that:
    1. the two versions (coefficient and FFT embeddings) of ffnp are consistent
    2. ffnp output lattice vectors close to the targets.
    """
    f = sign_KAT[n][0]["f"]
    g = sign_KAT[n][0]["g"]
    F = sign_KAT[n][0]["F"]
    G = sign_KAT[n][0]["G"]
    B = [[g, neg(f)], [G, neg(F)]]
    G0 = gram(B)
    G0_fft = [[fft(elt) for elt in row] for row in G0]
    T = ffldl(G0)
    T_fft = ffldl_fft(G0_fft)

    sqgsnorm = gs_norm(f, g, q)
    m = 0
    for i in range(iterations):
        t = [[random() for i in range(n)], [random() for i in range(n)]]
        t_fft = [fft(elt) for elt in t]

        z = ffnp(t, T)
        z_fft = ffnp_fft(t_fft, T_fft)

        zb = [ifft(elt) for elt in z_fft]
        zb = [[round(coef) for coef in elt] for elt in zb]
        if z != zb:
            print("ffnp and ffnp_fft are not consistent")
            return False
        diff = [sub(t[0], z[0]), sub(t[1], z[1])]
        diffB = vecmatmul(diff, B)
        norm_zmc = int(round(sqnorm(diffB)))
        m = max(m, norm_zmc)
    th_bound = (n / 4.) * sqgsnorm
    if m > th_bound:
        print("Warning: ffnp does not output vectors as short as expected")
        return False
    else:
        return True
for iY in range(maxfreq, len(Y)-maxfreq ) :
    Y[iY] = complex(0,0)
    #Y[iY] = Y[iY] * (0.5 - 0.5 * math.cos(2*math.pi*iY/float(N-1))) 

    #for iY in range(0,N) : 
    #    Y[iY] = Y[iY] * math.exp(-1.0*iY / 50.0)

powery = fft_power(Y)
powerx = array([ float(i) for i in xrange(len(powery)) ] )

Yre = [math.sqrt(Y[i].real**2+Y[i].imag**2) for i in xrange(len(Y))]
import heapq
print powery.index(heapq.nlargest(2,powery)[1])
            

ysmoothed = ifft(Y)
ysmoothedreal = real(ysmoothed)






if window : 
    for iy in range(1,len(yinput)-1) :
        ysmoothedreal[iy] = ysmoothedreal[iy] / (0.5 - 0.5 * math.cos(2*math.pi*iy/float(N-1)))
        y[iy]= y[iy] / (0.5 - 0.5 * math.cos(2*math.pi*iy/float(N-1)))


ax1 = plt.subplot(2, 1, 1)
y= y[:(N-padlength)]
Example #17
0
    pads = [0.0] * (pow(2, int(log2N)+1) - N)   #now paddle with 0s
    ma = m + pads
    ca = c + pads
    N = len(m)
    print len(m)
M = fft(ma)
C = fft(ca)


maxfreq = 15
# Now smooth the data
for i in range(maxfreq, len(M)-maxfreq ) :
    M[i] = complex(0,0)
    C[i] = complex(0,0)

cp = ifft(C)
mp = ifft(M)
cpr = real(cp)
mpr = real(mp)

mf = mpr[0:len(m)]
cf = cpr[0:len(c)]


plt.subplot(2, 1, 1)
plt.plot(T,mf)
plt.xlabel('Temperature')
plt.ylabel('m')

plt.subplot(2,1,2)
plt.plot(T,cf)
Example #18
0
L = 532*0.000000001      # wavelength in nm
w = 0.002  # width field of view 
z = 0.05  # z step in meter

imp = IJ.getImage()

#synthetic amplitude and phase
am = [math.exp(-1.6*val) for val in imp.getProcessor().getPixels()] 
ph = [-3*val for val in imp.getProcessor().getPixels()]

t = [x*cmath.exp(-1j*y) for x, y in zip(am, ph)] 

real = ImagePlus("real", FloatProcessor(N,N,[val.real for val in t]))
imaginary = ImagePlus("IMAGINARY", FloatProcessor(N,N,[val.imag for val in t]))


fft_1 = fft.fft(real,imaginary,N,N)

#projection to detector plane
z = Propagator.Zone(L, N, z, w)
real2 = [(x * y).real for x , y in zip(fft_1, [val.conjugate() for val in z])]
imag2 = [(x * y).imag for x , y in zip(fft_1, [val.conjugate() for val in z])]
R2 = ImagePlus("real", FloatProcessor(N, N, real2, None))
I2 = ImagePlus("imaginary", FloatProcessor(N, N, imag2, None))

ifft_1 = fft.ifft(R2,I2,N,N)

#amplitude at detector plane
Amplitude = ImagePlus("Amplitude_det", FloatProcessor(N, N, [abs(x) for x in ifft_1], None)).show()

Example #19
0
        m = [val for val in imp.getProcessor().getPixels()]
        sin = [math.sin(val) for val in imp2.getProcessor().getPixels()]
        cos = [math.cos(val) for val in imp2.getProcessor().getPixels()]
        imp_r = ImagePlus(
            "", FloatProcessor(N, N, [x * y for x, y in zip(m, cos)]))
        imp_i = ImagePlus(
            "", FloatProcessor(N, N, [x * y for x, y in zip(m, sin)]))
        fft_1 = fft.fft(imp_r, imp_i, N, N)

    #multiply image by fresnel kernel: propagate to object plane
    real = [(x * y).real for x, y in zip(fft_1, z)]
    imag = [(x * y).imag for x, y in zip(fft_1, z)]
    R = ImagePlus("", FloatProcessor(N, N, real, None))
    I = ImagePlus("", FloatProcessor(N, N, imag, None))

    fft_2 = fft.ifft(R, I, N, N)

    phase = [cmath.phase(x) for x in fft_2]  #phase
    m = [abs(x) for x in fft_2]

    #filter in object domain, no non negative absorbances
    fil = [-1 * math.log(val) for val in [abs(x) for x in fft_2]]
    ind = [i for i, x in enumerate(fil) if x < 0]

    for i in ind:
        phase[i] = 0
        fil[i] = 0

    m = [math.exp(-1 * val) for val in fil]  #amplitude after filtering
    sin = [math.sin(val) for val in phase]
    cos = [math.cos(val) for val in phase]
Example #20
0
import sys

import numpy as np

from matplotlib import pyplot as plt

import fft

N = 8 * 2

X = np.arange(N)

V = np.cos(2*np.pi*X/N+0.5) + np.sin(2*np.pi*0.5*X/N) - 0.3*np.cos(2*np.pi*X/N) + 5.0*np.sin(2*np.pi*0.3*X/N)
print 'V:', V
Q1 = fft.fft(V)
P1 = fft.ifft(Q1)

plt.plot(X, V, '-b', X, np.real(Q1), '-g', X, np.real(P1), '-r')
plt.show()
print 'Q1:', Q1
print 'P1:', np.real(P1)

Q2 = np.fft.fft(V)
P2 = np.fft.ifft(Q2)

plt.plot(X, V, '-b', X, np.real(Q2/np.sqrt(N)), '-g', X, np.real(P2), '-r')
plt.show()
print 'Q2:', Q2
print 'P2:', P2

max_dev = np.max(np.abs(P1-P2))
maxfreq = 50
# Now smooth the data
for iY in range(maxfreq, len(Y) - maxfreq):
    Y[iY] = complex(0, 0)
    #Y[iY] = Y[iY] * (0.5 - 0.5 * math.cos(2*math.pi*iY/float(N-1)))

    #for iY in range(0,N) :
    #    Y[iY] = Y[iY] * math.exp(-1.0*iY / 50.0)

powery = fft_power(Y)
powerx = array([float(i) for i in xrange(len(powery))])

Yre = [math.sqrt(Y[i].real**2 + Y[i].imag**2) for i in xrange(len(Y))]

ysmoothed = ifft(Y)
ysmoothedreal = real(ysmoothed)

ax1 = plt.subplot(2, 1, 1)
p1, = plt.plot(x, y)
p2, = plt.plot(x, ysmoothedreal)
ax1.legend([p1, p2], ['Original', 'Smoothed'])

ax2 = plt.subplot(2, 1, 2)
p3, = plt.plot(powerx, powery)
p4, = plt.plot(x, Yre)
ax2.legend([p3, p4], ["Power", "Magnitude"])
plt.yscale('log')

plt.show()
Example #22
0
    def call(self, inputs):
        channel_axis = 1 if self.data_format == 'channels_first' else -1
        input_dim = K.shape(inputs)[channel_axis] // 2
        if self.rank == 1:
            f_real = self.kernel[:, :, :self.filters]
            f_imag = self.kernel[:, :, self.filters:]
        elif self.rank == 2:
            f_real = self.kernel[:, :, :, :self.filters]
            f_imag = self.kernel[:, :, :, self.filters:]
        elif self.rank == 3:
            f_real = self.kernel[:, :, :, :, :self.filters]
            f_imag = self.kernel[:, :, :, :, self.filters:]

        convArgs = {
            "strides":
            self.strides[0] if self.rank == 1 else self.strides,
            "padding":
            self.padding,
            "data_format":
            self.data_format,
            "dilation_rate":
            self.dilation_rate[0] if self.rank == 1 else self.dilation_rate
        }
        convFunc = {1: K.conv1d, 2: K.conv2d, 3: K.conv3d}[self.rank]

        # processing if the weights are assumed to be represented in the spectral domain

        if self.spectral_parametrization:
            if self.rank == 1:
                f_real = K.permute_dimensions(f_real, (2, 1, 0))
                f_imag = K.permute_dimensions(f_imag, (2, 1, 0))
                f = K.concatenate([f_real, f_imag], axis=0)
                fshape = K.shape(f)
                f = K.reshape(f, (fshape[0] * fshape[1], fshape[2]))
                f = ifft(f)
                f = K.reshape(f, fshape)
                f_real = f[:fshape[0] // 2]
                f_imag = f[fshape[0] // 2:]
                f_real = K.permute_dimensions(f_real, (2, 1, 0))
                f_imag = K.permute_dimensions(f_imag, (2, 1, 0))
            elif self.rank == 2:
                f_real = K.permute_dimensions(f_real, (3, 2, 0, 1))
                f_imag = K.permute_dimensions(f_imag, (3, 2, 0, 1))
                f = K.concatenate([f_real, f_imag], axis=0)
                fshape = K.shape(f)
                f = K.reshape(f, (fshape[0] * fshape[1], fshape[2], fshape[3]))
                f = ifft2(f)
                f = K.reshape(f, fshape)
                f_real = f[:fshape[0] // 2]
                f_imag = f[fshape[0] // 2:]
                f_real = K.permute_dimensions(f_real, (2, 3, 1, 0))
                f_imag = K.permute_dimensions(f_imag, (2, 3, 1, 0))

        # In case of weight normalization, real and imaginary weights are normalized

        if self.normalize_weight:
            ker_shape = self.kernel_shape
            nb_kernels = ker_shape[-2] * ker_shape[-1]
            kernel_shape_4_norm = (np.prod(self.kernel_size), nb_kernels)
            reshaped_f_real = K.reshape(f_real, kernel_shape_4_norm)
            reshaped_f_imag = K.reshape(f_imag, kernel_shape_4_norm)
            reduction_axes = list(range(2))
            del reduction_axes[-1]
            mu_real = K.mean(reshaped_f_real, axis=reduction_axes)
            mu_imag = K.mean(reshaped_f_imag, axis=reduction_axes)

            broadcast_mu_shape = [1] * 2
            broadcast_mu_shape[-1] = nb_kernels
            broadcast_mu_real = K.reshape(mu_real, broadcast_mu_shape)
            broadcast_mu_imag = K.reshape(mu_imag, broadcast_mu_shape)
            reshaped_f_real_centred = reshaped_f_real - broadcast_mu_real
            reshaped_f_imag_centred = reshaped_f_imag - broadcast_mu_imag
            Vrr = K.mean(reshaped_f_real_centred**2,
                         axis=reduction_axes) + self.epsilon
            Vii = K.mean(reshaped_f_imag_centred**2,
                         axis=reduction_axes) + self.epsilon
            Vri = K.mean(reshaped_f_real_centred * reshaped_f_imag_centred,
                         axis=reduction_axes) + self.epsilon

            normalized_weight = complex_normalization(K.concatenate(
                [reshaped_f_real, reshaped_f_imag], axis=-1),
                                                      Vrr,
                                                      Vii,
                                                      Vri,
                                                      beta=None,
                                                      gamma_rr=self.gamma_rr,
                                                      gamma_ri=self.gamma_ri,
                                                      gamma_ii=self.gamma_ii,
                                                      scale=True,
                                                      center=False,
                                                      axis=-1)

            normalized_real = normalized_weight[:, :nb_kernels]
            normalized_imag = normalized_weight[:, nb_kernels:]
            f_real = K.reshape(normalized_real, self.kernel_shape)
            f_imag = K.reshape(normalized_imag, self.kernel_shape)

        # Performing complex convolution

        f_real._keras_shape = self.kernel_shape
        f_imag._keras_shape = self.kernel_shape

        cat_kernels_4_real = K.concatenate([f_real, -f_imag], axis=-2)
        cat_kernels_4_imag = K.concatenate([f_imag, f_real], axis=-2)
        cat_kernels_4_complex = K.concatenate(
            [cat_kernels_4_real, cat_kernels_4_imag], axis=-1)
        cat_kernels_4_complex._keras_shape = self.kernel_size + (
            2 * input_dim, 2 * self.filters)

        output = convFunc(inputs, cat_kernels_4_complex, **convArgs)

        if self.use_bias:
            output = K.bias_add(output,
                                self.bias,
                                data_format=self.data_format)

        if self.activation is not None:
            output = self.activation(output)

        return output
Example #23
0
import numpy as np

from matplotlib import pyplot as plt

import fft

N = 8 * 2

X = np.arange(N)

V = np.cos(2 * np.pi * X / N + 0.5) + np.sin(
    2 * np.pi * 0.5 * X / N) - 0.3 * np.cos(2 * np.pi * X / N) + 5.0 * np.sin(
        2 * np.pi * 0.3 * X / N)
print 'V:', V
Q1 = fft.fft(V)
P1 = fft.ifft(Q1)

plt.plot(X, V, '-b', X, np.real(Q1), '-g', X, np.real(P1), '-r')
plt.show()
print 'Q1:', Q1
print 'P1:', np.real(P1)

Q2 = np.fft.fft(V)
P2 = np.fft.ifft(Q2)

plt.plot(X, V, '-b', X, np.real(Q2 / np.sqrt(N)), '-g', X, np.real(P2), '-r')
plt.show()
print 'Q2:', Q2
print 'P2:', P2

max_dev = np.max(np.abs(P1 - P2))
Example #24
0
def module_ntru_gen(d, q, m):
    """
    Take as input system parameters, and output two "module-NTRU" matrices A and B such that:
    - B * A = 0 [mod q]
    - B has small polynomials
    - A is in Hermite normal form
    Also compute the inverse of B (over the field K = Q[x] / (x ** d + 1)).

    Input:
    d           The degree of the underlying ring R = Z[x] / (x ** d + 1)
    q           An integer
    m           An integer

    Output:
    A           A matrix in R ^ ((m + 1) x 1)
    B           A matrix in R ^ ((m + 1) x (m + 1))
    inv_B       A matrix in K ^ ((m + 1) x (m + 1))
    sq_gs_norm  A real number, the square of the Gram-Schmidt norm of B

    Format:     Coefficient
    """
    if m == 1:
        magic_constant = [1.15]
        gs_slack = 1.17
    elif m == 2:
        magic_constant = [1.07, 1.14]
        gs_slack = 1.17
    elif m == 3:
        magic_constant = [1.21, 1.10, 1.06]
        gs_slack = 1.24
    else:
        print("No parameters implemented yet for m = {m}".format(m=m))
        return
    max_gs_norm = gs_slack * (q ** (1 / (m + 1)))
    while True:
        # We generate all rows of B except the last
        B = [[None for j in range(m + 1)] for i in range(m + 1)]
        for i in range(m):
            for j in range(m + 1):
                # Each coefficient B[i][j] is a polynomial
                sigma = magic_constant[i] * (q ** (1 / (m + 1))) # ==> ||bi~|| = gs_slack * q^(1/(m+1))
                sig = sqrt(1 / (d * (m + 1 - i))) * sigma        # sig = stdv. dev. des coef de bi
                B[i][j] = [int(round(gauss(0, sig))) for k in range(d)]
        # We check that the GS norm is not larger than tolerated
        Bp_fft = [[fft(poly) for poly in row] for row in B[:-1]]
        Gp = gram_fft(Bp_fft)
        [Lp_fft, Dp_fft] = ldl_fft(Gp)
        Dp = [[[0] * d for col in range(m)] for row in range(m)]
        for i in range(m):
            Dp[i][i] = ifft(Dp_fft[i][i])
        prod_di = [1] + [0] * (d - 1)
        for i in range(m):
            prod_di = mul(prod_di, Dp[i][i])
        last = div([q ** 2] + [0] * (d - 1), prod_di)
        norms = [Dp[i][i][0] for i in range(m)] + [last[0]]
        # If the GS norm is too large, restart
        if sqrt(max(norms)) > max_gs_norm:
            continue
        # Try to solve the module-NTRU equation
        f = submatrix(B, m, 0)
        f = [[neg(elt) for elt in row] for row in f]
        g = [B[j][0] for j in range(m)]
        fp = my_det(f)
        adjf = my_adjugate(f)
        gp = [0] * d
        for i in range(m):
            gp = add(gp, karamul(adjf[0][i], g[i]))
        try:
            # Compute f^(-1) mod q
            fp_q = [elt % q for elt in fp]
            inv_f = [[elt[:] for elt in row] for row in adjf]
            for i in range(m):
                for j in range(m):
                    inv_f[i][j] = [elt % q for elt in inv_f[i][j]]
                    inv_f[i][j] = div_zq(inv_f[i][j], fp_q, q)
            # Compute h = f^(-1) * g mod q and A = [1 | h]
            h = [None] * m
            for i in range(m):
                elt = [0] * d
                for j in range(m):
                    elt = add_zq(elt, mul_zq(inv_f[i][j], g[j], q), q)
                h[i] = elt
            one = [1] + [0 for _ in range(1, d)]
            A = [one] + h
            Fp, Gp = ntru_solve(fp, gp, q)
            B[m][0] = Gp
            B[m][1] = [- coef for coef in Fp]
            for i in range(2, m + 1):
                B[m][i] = [0 for _ in range(d)]
            # Compute the inverse of B
            det_B = my_det(B)
            inv_B = my_adjugate(B)
            inv_B = [[div(poly, det_B) for poly in row] for row in inv_B]
            return A, B, inv_B, max(norms)
        # If any step failed, restart
        except (ZeroDivisionError, ValueError):
            continue
Example #25
0
File: conv.py Project: gnar/my_fft
def conv(a, b):
  assert len(a) == len(b)
  n = len(a)

  a, b = fft(a), fft(b)
  return ifft(list(a[i] * b[i] / n for i in range(len(a))))