def __get_excit_wfm(filepath): """ Returns the excitation BE waveform present in the more parms.mat file Parameters ------------ filepath : String / unicode Absolute filepath of the .mat parameter file Returns ----------- ex_wfm : 1D numpy float array Band Excitation waveform """ if not path.exists(filepath): warn('BEPSndfTranslator - NO more_parms.mat file found') return np.zeros(1000, dtype=np.float32) if 'more_parms' in filepath: matread = loadmat(filepath, variable_names=['FFT_BE_wave']) fft_full = np.complex64(np.squeeze(matread['FFT_BE_wave'])) bin_inds = None fft_full_rev = None else: matread = loadmat(filepath, variable_names=['FFT_BE_wave', 'FFT_BE_rev_wave', 'BE_bin_ind']) bin_inds = np.uint(np.squeeze(matread['BE_bin_ind'])) - 1 fft_full = np.complex64(np.squeeze(matread['FFT_BE_wave'])) fft_full_rev = np.complex64(np.squeeze(matread['FFT_BE_rev_wave'])) return fft_full, fft_full_rev, bin_inds
def test_numpy(self): assert chash(np.bool_(True)) == chash(np.bool_(True)) assert chash(np.int8(1)) == chash(np.int8(1)) assert chash(np.int16(1)) assert chash(np.int32(1)) assert chash(np.int64(1)) assert chash(np.uint8(1)) assert chash(np.uint16(1)) assert chash(np.uint32(1)) assert chash(np.uint64(1)) assert chash(np.float32(1)) == chash(np.float32(1)) assert chash(np.float64(1)) == chash(np.float64(1)) assert chash(np.float128(1)) == chash(np.float128(1)) assert chash(np.complex64(1+1j)) == chash(np.complex64(1+1j)) assert chash(np.complex128(1+1j)) == chash(np.complex128(1+1j)) assert chash(np.complex256(1+1j)) == chash(np.complex256(1+1j)) assert chash(np.datetime64('2000-01-01')) == chash(np.datetime64('2000-01-01')) assert chash(np.timedelta64(1,'W')) == chash(np.timedelta64(1,'W')) self.assertRaises(ValueError, chash, np.object()) assert chash(np.array([[1, 2], [3, 4]])) == \ chash(np.array([[1, 2], [3, 4]])) assert chash(np.array([[1, 2], [3, 4]])) != \ chash(np.array([[1, 2], [3, 4]]).T) assert chash(np.array([1, 2, 3])) == chash(np.array([1, 2, 3])) assert chash(np.array([1, 2, 3], dtype=np.int32)) != \ chash(np.array([1, 2, 3], dtype=np.int64))
def runTest(self): node_list = ['n1', 'n2', 'n3'] V = np.complex64(( 1.02500000+0.0j, 1.00057074-0.03669173j, 1.02970624+0.0245978j)) phase = np.complex64((0.0, -0.03665437, 0.02388363)) P = np.complex64((1.00010597, -4.0, 3.0)) Q = np.complex64((0.90512173, -2.0, 1.36935805)) netlist = Netlist() # Check values are close to what we expect try: netlist.load_from_file("testing/inputfile2.txt") netlist.run() # print abs(netlist.result.V)- abs(V) print netlist.result.V print netlist.result.P # assert (np.allclose(netlist.result.V, V, rtol=1e-3, atol=1e-3)) # assert (np.allclose(netlist.result.phase, phase, rtol=1e-3, atol=1e-3)) # assert (np.allclose(netlist.result.P, P, rtol=1e-3, atol=1e-3)) # assert (np.allclose(netlist.result.Q, Q, rtol=1e-3, atol=1e-3)) finally: del netlist
def testCountingLoopHandrolledC64(self): # Define a function for the loop body @function.Defun(dtypes.int32, dtypes.complex64) def loop_body(step, rsum): step_out = step + constant_op.constant(1, dtype=dtypes.int32) sum_out = rsum + constant_op.constant(1.5 + 2j, dtype=dtypes.complex64) return step_out, sum_out # Define a function for the loop condition @function.Defun(dtypes.int32, dtypes.complex64) def loop_cond(step, rsum): del rsum return step < 10 with self.cached_session() as sess: init_index = array_ops.placeholder(dtypes.int32, []) init_sum = array_ops.placeholder(dtypes.complex64, []) with self.test_scope(): loop_outputs = xla.while_loop([init_index, init_sum], loop_cond, loop_body) result = sess.run(loop_outputs, {init_index: 0, init_sum: 0.0}) self.assertAllClose(result[1], np.complex64(15 + 20j), rtol=1e-3) no_iters_result = sess.run(loop_outputs, {init_index: 10, init_sum: 0.0}) self.assertAllClose(no_iters_result[1], np.complex64(0), rtol=1e-3)
def generate(self, width, height, real_axis_range, imag_axis_range, tasks): if not is_gpu_accelerated(): self._logger.error( 'No GPU acceleration is available, please use CPU.') return iterations = np.empty(width * height, np.int32) iterations_gpu = gpuarray.to_gpu(iterations) z_values = np.empty(width * height, np.float32) z_values_gpu = gpuarray.to_gpu(z_values) cmin = complex(real_axis_range[0], imag_axis_range[0]) cmax = complex(real_axis_range[1], imag_axis_range[1]) dc = cmax - cmin dx, mx = divmod(width, self._block_size[0]) dy, my = divmod(height, self._block_size[1]) grid_size = ((dx + (mx > 0)), (dy + (my > 0))) self._get_pixel_iterations( iterations_gpu, z_values_gpu, np.int32(width), np.int32(height), np.complex64(cmin), np.complex64(dc), block=self._block_size, grid=grid_size) return (iterations_gpu, z_values_gpu, abs(dc))
def test_arrays_replicated_3d(self): s = readsav(path.join(DATA_PATH, 'struct_arrays_replicated_3d.sav'), verbose=False) # Check column types assert_(s.arrays_rep.a.dtype.type is np.object_) assert_(s.arrays_rep.b.dtype.type is np.object_) assert_(s.arrays_rep.c.dtype.type is np.object_) assert_(s.arrays_rep.d.dtype.type is np.object_) # Check column shapes assert_equal(s.arrays_rep.a.shape, (4, 3, 2)) assert_equal(s.arrays_rep.b.shape, (4, 3, 2)) assert_equal(s.arrays_rep.c.shape, (4, 3, 2)) assert_equal(s.arrays_rep.d.shape, (4, 3, 2)) # Check values for i in range(4): for j in range(3): for k in range(2): assert_array_identical(s.arrays_rep.a[i, j, k], np.array([1, 2, 3], dtype=np.int16)) assert_array_identical(s.arrays_rep.b[i, j, k], np.array([4., 5., 6., 7.], dtype=np.float32)) assert_array_identical(s.arrays_rep.c[i, j, k], np.array([np.complex64(1+2j), np.complex64(7+8j)])) assert_array_identical(s.arrays_rep.d[i, j, k], np.array([b"cheese", b"bacon", b"spam"], dtype=np.object))
def test_dump_np_scalars(): data = [ int8(-27), complex64(exp(1)+37j), ( { 'alpha': float64(-exp(10)), 'str-only': complex64(-1-1j), }, uint32(123456789), float16(exp(-1)), { int64(37), uint64(-0), }, ), ] replaced = encode_scalars_inplace(deepcopy(data)) json = dumps(replaced) rec = loads(json) print(data) print(rec) assert data[0] == rec[0] assert data[1] == rec[1] assert data[2][0] == rec[2][0] assert data[2][1] == rec[2][1] assert data[2][2] == rec[2][2] assert data[2][3] == rec[2][3] assert data[2] == tuple(rec[2])
def test_cublasCgemmBatched(self): l, m, k, n = 11, 7, 5, 3 A = (np.random.rand(l, m, k)+1j*np.random.rand(l, m, k)).astype(np.complex64) B = (np.random.rand(l, k, n)+1j*np.random.rand(l, k, n)).astype(np.complex64) C_res = np.einsum('nij,njk->nik', A, B) a_gpu = gpuarray.to_gpu(A) b_gpu = gpuarray.to_gpu(B) c_gpu = gpuarray.empty((l, m, n), np.complex64) alpha = np.complex64(1.0) beta = np.complex64(0.0) a_arr = bptrs(a_gpu) b_arr = bptrs(b_gpu) c_arr = bptrs(c_gpu) cublas.cublasCgemmBatched(self.cublas_handle, 'n','n', n, m, k, alpha, b_arr.gpudata, n, a_arr.gpudata, k, beta, c_arr.gpudata, n, l) assert np.allclose(C_res, c_gpu.get())
def hiss_removal(audio): pend = len(audio)-(4410+1102) song = sonify(audio, 44100) song.FrameGenerator().__next__() song.window() song.Spectrum() noise_fft = song.fft(song.windowed_x)[:song.H+1] noise_power = np.log10(np.abs(noise_fft + 2 ** -16)) noise_floor = np.exp(2.0 * noise_power.mean()) mn = song.magnitude_spectrum e_n = energy(mn) pin = 0 output = np.zeros(len(audio)) hold_time = 0 ca = 0 cr = 0 amp = audio.max() while pin < pend: selection = pin+2048 song.frame = audio[pin:selection] song.window() song.M = 2048 song.Spectrum() e_m = energy(song.magnitude_spectrum) SNR = 10 * np.log10(e_m / e_n) ft = song.fft(song.windowed_x)[:song.H+1] power_spectral_density = np.abs(ft) ** 2 song.Envelope() song.AttackTime() rel_time = rel(song.attack_time) rel_coef = to_coef(rel_time, 44100) at_coef = to_coef(song.attack_time, 44100) ca = ca + song.attack_time cr = cr + rel_time if SNR > 0: np.add.at(output, range(pin, selection), audio[pin:selection]) else: if np.any(power_spectral_density < noise_floor): gc = dyn_constraint_satis(ft, [power_spectral_density, noise_floor], 0.12589254117941673) if ca > hold_time: gc = np.complex64([at_coef * gc[i- 1] + (1 - at_coef) * x if x > gc[i- 1] else x for i,x in enumerate(gc)]) if ca <= hold_time: gc = np.complex64([gc[i- 1] for i,x in enumerate(gc)]) if cr > hold_time: gc = np.complex64([rel_coef * gc[i- 1] + (1 - rel_coef) * x if x <= gc[i- 1] else x for i,x in enumerate(gc)]) if cr <= hold_time: gc = np.complex64([gc[i- 1] for i,x in enumerate(gc)]) print ("Reducing noise floor, this is taking some time") song.Phase(song.fft(song.windowed_x)) song.phase = song.phase[:song.magnitude_spectrum.size] ft *= gc song.magnitude_spectrum = np.sqrt(pow(ft.real,2) + pow(ft.imag,2)) np.add.at(output, range(pin, selection), song.ISTFT(song.magnitude_spectrum)) else: np.add.at(output, range(pin, selection), audio[pin:selection]) pin = pin + song.H hold_time += selection/44100 hissless = amp * output / output.max() #amplify to normal level return np.float32(hissless)
def energy_density_at_origin(k): K = complex64(ellipk(k**2)) E = complex64(ellipe(k**2)) k1 = sqrt(1-k**2) A = 32*(k**2 *(-K**2 * k**2 +E**2-4*E*K+3* K**2 + k**2)-2*(E-K)**2)**2/(k**8 * K**4 * k1**2) return A.real
def _update_filtered(self, translated): if translated is not None and self._taps_n is not None and self._taps_p is not None: filtered_data_1 = TimeData(numpy.complex64(scipy.signal.lfilter(self._taps_n, 1, translated.samples)), translated.sampling_rate) filtered_data_2 = TimeData(numpy.complex64(scipy.signal.lfilter(self._taps_p, 1, translated.samples)), translated.sampling_rate) self.eye_view.data = (filtered_data_1.abs, filtered_data_2.abs) self.burst.filtered = TimeData(filtered_data_2.abs.samples - filtered_data_1.abs.samples, filtered_data_1.sampling_rate) else: self.eye_view.data = (None, None) self.burst.filtered = None
def sc_complex_dot(x_gpu, y_gpu, c_gpu, transa='N', transb='N', handle=None): """ modified version of linalg.dot which allows for the target output array to be specified. This function does not return anything. """ if handle is None: handle = scikits.cuda.misc._global_cublas_handle assert len(x_gpu.shape) == 2 assert len(y_gpu.shape) == 2 assert len(c_gpu.shape) == 2 assert x_gpu.dtype == np.complex64 assert y_gpu.dtype == np.complex64 assert c_gpu.dtype == np.complex64 # Get the shapes of the arguments x_shape = x_gpu.shape y_shape = y_gpu.shape # Perform matrix multiplication for 2D arrays: alpha = np.complex64(1.0) beta = np.complex64(0.0) transa = string.lower(transa) transb = string.lower(transb) if transb in ['t', 'c']: m, k = y_shape elif transb in ['n']: k, m = y_shape else: raise ValueError('invalid value for transb') if transa in ['t', 'c']: l, n = x_shape elif transa in ['n']: n, l = x_shape else: raise ValueError('invalid value for transa') if l != k: raise ValueError('objects are not aligned') if transb == 'n': lda = max(1, m) else: lda = max(1, k) if transa == 'n': ldb = max(1, k) else: ldb = max(1, n) ldc = max(1, m) cublas.cublasCgemm(handle, transb, transa, m, n, k, alpha, y_gpu.gpudata, lda, x_gpu.gpudata, ldb, beta, c_gpu.gpudata, ldc)
def add_vdot(M, v, out, beta=0.0, transM='N', handle=None): if handle is None: handle = scm._global_cublas_handle assert M.strides[1] <= M.strides[0], 'only C-order arrays supported' transM = transM.lower() if transM == 'n': trans = 't' m = M.shape[1] n = M.shape[0] alpha = 1.0 lda = M.strides[0] // M.dtype.itemsize if v.shape[0] != M.shape[1] or out.shape[0] != M.shape[0]: raise ValueError('dimension mismatch: %s %s %s' % (M.shape, v.shape, out.shape)) elif transM == 't': trans = 'n' m = M.shape[1] n = M.shape[0] alpha = 1.0 lda = M.strides[0] // M.dtype.itemsize if v.shape[0] != M.shape[0] or out.shape[0] != M.shape[1]: raise ValueError('dimension mismatch: %s %s %s' % (M.shape, v.shape, out.shape)) else: raise ValueError('transM must be n or t') if (M.dtype == np.complex64 and v.dtype == np.complex64): cublas_func = scikits.cuda.cublas.cublasCgemv alpha = np.complex64(alpha) beta = np.complex64(beta) elif (M.dtype == np.float32 and v.dtype == np.float32): cublas_func = scikits.cuda.cublas.cublasSgemv alpha = np.float32(alpha) beta = np.float32(beta) elif (M.dtype == np.complex128 and v.dtype == np.complex128): cublas_func = scikits.cuda.cublas.cublasZgemv alpha = np.complex128(alpha) beta = np.complex128(beta) elif (M.dtype == np.float64 and v.dtype == np.float64): cublas_func = scikits.cuda.cublas.cublasDgemv alpha = np.float64(alpha) beta = np.float64(beta) else: raise ValueError('unsupported combination of input types') incx = 1 incy = 1 cublas_func(handle, trans, m, n, alpha, M.gpudata, lda, v.gpudata, incx, beta, out.gpudata, incy)
def __init__(self,timeSeries=None, lenSeries=2**18, numChannels=1, fMin=400,fMax=800, sampTime=None, noiseRMS=0.1): """ Initializes the AmplitudeTimeSeries instance. If a array is not passed, then a random whitenoise dataset is generated. Inputs: Len -- Number of time data points (usually a power of 2) 2^38 gives about 65 seconds of 400 MHz sampled data The time binning is decided by the bandwidth fMin -- lowest frequency (MHz) fMax -- highest frequency (MHz) noiseRMS -- RMS value of noise (TBD) noiseAlpha -- spectral slope (default is white noise) (TBD) ONLY GENERATES WHITE NOISE RIGHT NOW! """ self.shape = (np.uint(numChannels),np.uint(lenSeries)) self.fMax = fMax self.fMin = fMin if sampTime is None: self.sampTime = np.uint(numChannels)*1E-6/(fMax-fMin) else: self.sampTime = sampTime if timeSeries is None: # then use the rest of the data to generate a random timeseries if VERBOSE: print "AmplitudeTimeSeries __init__ did not get new data, generating white noise data" self.timeSeries = np.complex64(noiseRMS*(np.float16(random.standard_normal(self.shape)) +np.float16(random.standard_normal(self.shape))*1j)/np.sqrt(2)) else: if VERBOSE: print "AmplitudeTimeSeries __init__ got new data, making sure it is reasonable." if len(timeSeries.shape) == 1: self.shape = (1,timeSeries.shape[0]) else: self.shape = timeSeries.shape self.timeSeries = np.reshape(np.complex64(timeSeries),self.shape) self.fMin = fMin self.fMax = fMax if sampTime is None: self.sampTime = numChannels*1E-6/(fMax-fMin) else: self.sampTime = sampTime return None
def test_compressed(self): s = idlsave.read(path.join(DATA_PATH, 'various_compressed.sav'), verbose=False) assert_identical(s.i8u, np.uint8(234)) assert_identical(s.f32, np.float32(-3.1234567e+37)) assert_identical(s.c64, np.complex128(1.1987253647623157e+112-5.1987258887729157e+307j)) assert_equal(s.array5d.shape, (4, 3, 4, 6, 5)) assert_identical(s.arrays.a[0], np.array([1, 2, 3], dtype=np.int16)) assert_identical(s.arrays.b[0], np.array([4., 5., 6., 7.], dtype=np.float32)) assert_identical(s.arrays.c[0], np.array([np.complex64(1+2j), np.complex64(7+8j)])) assert_identical(s.arrays.d[0], np.array(asbytes_nested(["cheese", "bacon", "spam"]), dtype=np.object))
def test_dtypes(): a = afnumpy.random.random((2,3)) b = numpy.array(a) fassert(afnumpy.int32(a), numpy.int32(b)) fassert(afnumpy.complex64(a), numpy.complex64(b)) assert(afnumpy.float(a.sum()), numpy.float(b.sum())) fassert(afnumpy.complex64(b), numpy.complex64(a)) assert(type(afnumpy.complex64(b)), afnumpy.multiarray.ndarray) assert(type(afnumpy.complex64([1,2,3])), afnumpy.multiarray.ndarray) assert(type(afnumpy.bool8(True)), numpy.bool_)
def get_workspace(self, n): from pyfft.cuda import Plan as pycufftplan import pycuda.gpuarray as gpuarray ws = self.get(n) if ws: return ws return self.setdefault(n, (pycufftplan(int(n), stream=self.stream, normalize=False), gpuarray.empty(n, dtype=complex64(0.).dtype), gpuarray.empty(n, dtype=complex64(0.).dtype)))
def dmus(zeta, x, k): K = complex64(ellipk(k**2)) E = complex64(ellipe(k**2)) cm= (2*E-K)/K k1 = sqrt(1-k**2) xp = x[0]+complex(0,1)*x[1] xm = x[0]-complex(0,1)*x[1] S = sqrt(K**2-4*xp*xm) SP = sqrt(K**2-4*xp**2) SM = sqrt(K**2-4*xm**2) SPM = sqrt(-k1**2*(K**2*k**2-4*xm*xp)+(xm-xp)**2) R = 2*K**2*k1**2-S**2-8*x[2]**2 RM = complex(0,1)*SM**2*(xm*(2*k1**2-1)+xp)-(16*complex(0,1))*xm*x[2]**2 RP = complex(0,1)*SM**2*(xp*(2*k1**2-1)+xm)+(16*complex(0,1))*xp*x[2]**2 RMBAR=-complex(0,1)*SP**2*( xp*(2*k1**2-1)+xm ) +16*complex(0,1)*xp*x[2]**2 RPBAR=-complex(0,1)*SP**2*( xm*(2*k1**2-1)+xp ) -16*complex(0,1)*xm*x[2]**2 r=sqrt(x[0]**2+x[1]**2+x[2]**2) DM = [None,None,None,None] DM[0] = [None]*3 DM[1] = [None]*3 DM[2] = [None]*3 DM[3] = [None]*3 DM[0][0] = complex(0, 1) * (E * K * zeta[0] ** 2 - K ** 2 * zeta[0] ** 2 + 4 * zeta[0] ** 2 * x[0] ** 2 + complex(0, -4) * zeta[0] ** 2 * x[1] * x[0] + E * K - K ** 2 + 4 * x[0] ** 2 + complex(0, -8) * zeta[0] * x[2] * x[0] + complex(0, 4) * x[0] * x[1]) / (4 * zeta[0] ** 3 * x[0] ** 2 + complex(0, -8) * zeta[0] ** 3 * x[0] * x[1] + 2 * K ** 2 * k1 ** 2 * zeta[0] - K ** 2 * zeta[0] ** 3 + 4 * x[0] ** 2 * zeta[0] + complex(0, -12) * zeta[0] ** 2 * x[0] * x[2] - 4 * zeta[0] ** 3 * x[1] ** 2 - 12 * zeta[0] ** 2 * x[1] * x[2] - K ** 2 * zeta[0] + complex(0, -4) * x[0] * x[2] + 4 * x[1] ** 2 * zeta[0] - 8 * zeta[0] * x[2] ** 2 + 4 * x[1] * x[2]) DM[1][0] = complex(0, 1) * (E * K * zeta[1] ** 2 - K ** 2 * zeta[1] ** 2 + 4 * zeta[1] ** 2 * x[0] ** 2 + complex(0, -4) * zeta[1] ** 2 * x[1] * x[0] + E * K - K ** 2 + 4 * x[0] ** 2 + complex(0, -8) * zeta[1] * x[2] * x[0] + complex(0, 4) * x[0] * x[1]) / (4 * zeta[1] ** 3 * x[0] ** 2 + complex(0, -8) * zeta[1] ** 3 * x[0] * x[1] + 2 * K ** 2 * k1 ** 2 * zeta[1] - K ** 2 * zeta[1] ** 3 + 4 * x[0] ** 2 * zeta[1] + complex(0, -12) * zeta[1] ** 2 * x[0] * x[2] - 4 * zeta[1] ** 3 * x[1] ** 2 - 12 * zeta[1] ** 2 * x[1] * x[2] - K ** 2 * zeta[1] + complex(0, -4) * x[0] * x[2] + 4 * x[1] ** 2 * zeta[1] - 8 * zeta[1] * x[2] ** 2 + 4 * x[1] * x[2]) DM[2][0] = complex(0, 1) * (E * K * zeta[2] ** 2 - K ** 2 * zeta[2] ** 2 + 4 * zeta[2] ** 2 * x[0] ** 2 + complex(0, -4) * zeta[2] ** 2 * x[1] * x[0] + E * K - K ** 2 + 4 * x[0] ** 2 + complex(0, -8) * zeta[2] * x[2] * x[0] + complex(0, 4) * x[0] * x[1]) / (4 * zeta[2] ** 3 * x[0] ** 2 + complex(0, -8) * zeta[2] ** 3 * x[0] * x[1] + 2 * K ** 2 * k1 ** 2 * zeta[2] - K ** 2 * zeta[2] ** 3 + 4 * x[0] ** 2 * zeta[2] + complex(0, -12) * zeta[2] ** 2 * x[0] * x[2] - 4 * zeta[2] ** 3 * x[1] ** 2 - 12 * zeta[2] ** 2 * x[1] * x[2] - K ** 2 * zeta[2] + complex(0, -4) * x[0] * x[2] + 4 * x[1] ** 2 * zeta[2] - 8 * zeta[2] * x[2] ** 2 + 4 * x[1] * x[2]) DM[3][0] = complex(0, 1) * (E * K * zeta[3] ** 2 - K ** 2 * zeta[3] ** 2 + 4 * zeta[3] ** 2 * x[0] ** 2 + complex(0, -4) * zeta[3] ** 2 * x[1] * x[0] + E * K - K ** 2 + 4 * x[0] ** 2 + complex(0, -8) * zeta[3] * x[2] * x[0] + complex(0, 4) * x[0] * x[1]) / (4 * zeta[3] ** 3 * x[0] ** 2 + complex(0, -8) * zeta[3] ** 3 * x[0] * x[1] + 2 * K ** 2 * k1 ** 2 * zeta[3] - K ** 2 * zeta[3] ** 3 + 4 * x[0] ** 2 * zeta[3] + complex(0, -12) * zeta[3] ** 2 * x[0] * x[2] - 4 * zeta[3] ** 3 * x[1] ** 2 - 12 * zeta[3] ** 2 * x[1] * x[2] - K ** 2 * zeta[3] + complex(0, -4) * x[0] * x[2] + 4 * x[1] ** 2 * zeta[3] - 8 * zeta[3] * x[2] ** 2 + 4 * x[1] * x[2]) DM[0][1] = (complex(0, 4) * zeta[0] ** 2 * x[1] * x[0] + E * K * zeta[0] ** 2 + 4 * zeta[0] ** 2 * x[1] ** 2 + complex(0, 4) * x[0] * x[1] + 8 * zeta[0] * x[1] * x[2] - E * K - 4 * x[1] ** 2) / (4 * zeta[0] ** 3 * x[0] ** 2 + complex(0, -8) * zeta[0] ** 3 * x[0] * x[1] + 2 * K ** 2 * k1 ** 2 * zeta[0] - K ** 2 * zeta[0] ** 3 + 4 * x[0] ** 2 * zeta[0] + complex(0, -12) * zeta[0] ** 2 * x[0] * x[2] - 4 * zeta[0] ** 3 * x[1] ** 2 - 12 * zeta[0] ** 2 * x[1] * x[2] - K ** 2 * zeta[0] + complex(0, -4) * x[0] * x[2] + 4 * x[1] ** 2 * zeta[0] - 8 * zeta[0] * x[2] ** 2 + 4 * x[1] * x[2]) DM[1][1] = (complex(0, 4) * zeta[1] ** 2 * x[1] * x[0] + E * K * zeta[1] ** 2 + 4 * zeta[1] ** 2 * x[1] ** 2 + complex(0, 4) * x[0] * x[1] + 8 * zeta[1] * x[1] * x[2] - E * K - 4 * x[1] ** 2) / (4 * zeta[1] ** 3 * x[0] ** 2 + complex(0, -8) * zeta[1] ** 3 * x[0] * x[1] + 2 * K ** 2 * k1 ** 2 * zeta[1] - K ** 2 * zeta[1] ** 3 + 4 * x[0] ** 2 * zeta[1] + complex(0, -12) * zeta[1] ** 2 * x[0] * x[2] - 4 * zeta[1] ** 3 * x[1] ** 2 - 12 * zeta[1] ** 2 * x[1] * x[2] - K ** 2 * zeta[1] + complex(0, -4) * x[0] * x[2] + 4 * x[1] ** 2 * zeta[1] - 8 * zeta[1] * x[2] ** 2 + 4 * x[1] * x[2]) DM[2][1] = (complex(0, 4) * zeta[2] ** 2 * x[1] * x[0] + E * K * zeta[2] ** 2 + 4 * zeta[2] ** 2 * x[1] ** 2 + complex(0, 4) * x[0] * x[1] + 8 * zeta[2] * x[1] * x[2] - E * K - 4 * x[1] ** 2) / (4 * zeta[2] ** 3 * x[0] ** 2 + complex(0, -8) * zeta[2] ** 3 * x[0] * x[1] + 2 * K ** 2 * k1 ** 2 * zeta[2] - K ** 2 * zeta[2] ** 3 + 4 * x[0] ** 2 * zeta[2] + complex(0, -12) * zeta[2] ** 2 * x[0] * x[2] - 4 * zeta[2] ** 3 * x[1] ** 2 - 12 * zeta[2] ** 2 * x[1] * x[2] - K ** 2 * zeta[2] + complex(0, -4) * x[0] * x[2] + 4 * x[1] ** 2 * zeta[2] - 8 * zeta[2] * x[2] ** 2 + 4 * x[1] * x[2]) DM[3][1] = (complex(0, 4) * zeta[3] ** 2 * x[1] * x[0] + E * K * zeta[3] ** 2 + 4 * zeta[3] ** 2 * x[1] ** 2 + complex(0, 4) * x[0] * x[1] + 8 * zeta[3] * x[1] * x[2] - E * K - 4 * x[1] ** 2) / (4 * zeta[3] ** 3 * x[0] ** 2 + complex(0, -8) * zeta[3] ** 3 * x[0] * x[1] + 2 * K ** 2 * k1 ** 2 * zeta[3] - K ** 2 * zeta[3] ** 3 + 4 * x[0] ** 2 * zeta[3] + complex(0, -12) * zeta[3] ** 2 * x[0] * x[2] - 4 * zeta[3] ** 3 * x[1] ** 2 - 12 * zeta[3] ** 2 * x[1] * x[2] - K ** 2 * zeta[3] + complex(0, -4) * x[0] * x[2] + 4 * x[1] ** 2 * zeta[3] - 8 * zeta[3] * x[2] ** 2 + 4 * x[1] * x[2]) DM[0][2] = 2 * (-K ** 2 * k1 ** 2 * zeta[0] + complex(0, 2) * zeta[0] ** 2 * x[0] * x[2] + 2 * zeta[0] ** 2 * x[1] * x[2] + E * K * zeta[0] + complex(0, 2) * x[0] * x[2] + 4 * zeta[0] * x[2] ** 2 - 2 * x[1] * x[2]) / (4 * zeta[0] ** 3 * x[0] ** 2 + complex(0, -8) * zeta[0] ** 3 * x[0] * x[1] + 2 * K ** 2 * k1 ** 2 * zeta[0] - K ** 2 * zeta[0] ** 3 + 4 * x[0] ** 2 * zeta[0] + complex(0, -12) * zeta[0] ** 2 * x[0] * x[2] - 4 * zeta[0] ** 3 * x[1] ** 2 - 12 * zeta[0] ** 2 * x[1] * x[2] - K ** 2 * zeta[0] + complex(0, -4) * x[0] * x[2] + 4 * x[1] ** 2 * zeta[0] - 8 * zeta[0] * x[2] ** 2 + 4 * x[1] * x[2]) DM[1][2] = 2 * (-K ** 2 * k1 ** 2 * zeta[1] + complex(0, 2) * zeta[1] ** 2 * x[0] * x[2] + 2 * zeta[1] ** 2 * x[1] * x[2] + E * K * zeta[1] + complex(0, 2) * x[0] * x[2] + 4 * zeta[1] * x[2] ** 2 - 2 * x[1] * x[2]) / (4 * zeta[1] ** 3 * x[0] ** 2 + complex(0, -8) * zeta[1] ** 3 * x[0] * x[1] + 2 * K ** 2 * k1 ** 2 * zeta[1] - K ** 2 * zeta[1] ** 3 + 4 * x[0] ** 2 * zeta[1] + complex(0, -12) * zeta[1] ** 2 * x[0] * x[2] - 4 * zeta[1] ** 3 * x[1] ** 2 - 12 * zeta[1] ** 2 * x[1] * x[2] - K ** 2 * zeta[1] + complex(0, -4) * x[0] * x[2] + 4 * x[1] ** 2 * zeta[1] - 8 * zeta[1] * x[2] ** 2 + 4 * x[1] * x[2]) DM[2][2] = 2 * (-K ** 2 * k1 ** 2 * zeta[2] + complex(0, 2) * zeta[2] ** 2 * x[0] * x[2] + 2 * zeta[2] ** 2 * x[1] * x[2] + E * K * zeta[2] + complex(0, 2) * x[0] * x[2] + 4 * zeta[2] * x[2] ** 2 - 2 * x[1] * x[2]) / (4 * zeta[2] ** 3 * x[0] ** 2 + complex(0, -8) * zeta[2] ** 3 * x[0] * x[1] + 2 * K ** 2 * k1 ** 2 * zeta[2] - K ** 2 * zeta[2] ** 3 + 4 * x[0] ** 2 * zeta[2] + complex(0, -12) * zeta[2] ** 2 * x[0] * x[2] - 4 * zeta[2] ** 3 * x[1] ** 2 - 12 * zeta[2] ** 2 * x[1] * x[2] - K ** 2 * zeta[2] + complex(0, -4) * x[0] * x[2] + 4 * x[1] ** 2 * zeta[2] - 8 * zeta[2] * x[2] ** 2 + 4 * x[1] * x[2]) DM[3][2] = 2 * (-K ** 2 * k1 ** 2 * zeta[3] + complex(0, 2) * zeta[3] ** 2 * x[0] * x[2] + 2 * zeta[3] ** 2 * x[1] * x[2] + E * K * zeta[3] + complex(0, 2) * x[0] * x[2] + 4 * zeta[3] * x[2] ** 2 - 2 * x[1] * x[2]) / (4 * zeta[3] ** 3 * x[0] ** 2 + complex(0, -8) * zeta[3] ** 3 * x[0] * x[1] + 2 * K ** 2 * k1 ** 2 * zeta[3] - K ** 2 * zeta[3] ** 3 + 4 * x[0] ** 2 * zeta[3] + complex(0, -12) * zeta[3] ** 2 * x[0] * x[2] - 4 * zeta[3] ** 3 * x[1] ** 2 - 12 * zeta[3] ** 2 * x[1] * x[2] - K ** 2 * zeta[3] + complex(0, -4) * x[0] * x[2] + 4 * x[1] ** 2 * zeta[3] - 8 * zeta[3] * x[2] ** 2 + 4 * x[1] * x[2]) return DM
def test_compressed(self): s = readsav(path.join(DATA_PATH, "various_compressed.sav"), verbose=False) assert_identical(s.i8u, np.uint8(234)) assert_identical(s.f32, np.float32(-3.1234567e37)) assert_identical(s.c64, np.complex128(1.1987253647623157e112 - 5.1987258887729157e307j)) assert_equal(s.array5d.shape, (4, 3, 4, 6, 5)) assert_identical(s.arrays.a[0], np.array([1, 2, 3], dtype=np.int16)) assert_identical(s.arrays.b[0], np.array([4.0, 5.0, 6.0, 7.0], dtype=np.float32)) assert_identical(s.arrays.c[0], np.array([np.complex64(1 + 2j), np.complex64(7 + 8j)])) assert_identical(s.arrays.d[0], np.array([b"cheese", b"bacon", b"spam"], dtype=np.object))
def test_output_dtype(self): '''Test to see if the output_dtype property returns the correct thing ''' self.assertEqual(self.fft.output_dtype, self.output_array.dtype) new_input_array = numpy.complex64(self.input_array) new_output_array = numpy.complex64(self.output_array) new_fft = FFTW(new_input_array, new_output_array) self.assertEqual(new_fft.output_dtype, new_output_array.dtype)
def test_cublasCgemv(self): a = (np.random.rand(2, 3)+1j*np.random.rand(2, 3)).astype(np.complex64) x = (np.random.rand(3, 1)+1j*np.random.rand(3, 1)).astype(np.complex64) a_gpu = gpuarray.to_gpu(a.T.copy()) x_gpu = gpuarray.to_gpu(x) y_gpu = gpuarray.empty((2, 1), np.complex64) alpha = np.complex64(1.0) beta = np.complex64(0.0) cublas.cublasCgemv('n', 2, 3, alpha, a_gpu.gpudata, 2, x_gpu.gpudata, 1, beta, y_gpu.gpudata, 1) assert np.allclose(y_gpu.get(), np.dot(a, x))
def dzetas(zeta, x, k): K = complex64(ellipk(k**2)) E = complex64(ellipe(k**2)) cm= (2*E-K)/K k1 = sqrt(1-k**2) xp = x[0]+complex(0,1)*x[1] xm = x[0]-complex(0,1)*x[1] S = sqrt(K**2-4*xp*xm) SP = sqrt(K**2-4*xp**2) SM = sqrt(K**2-4*xm**2) SPM = sqrt(-k1**2*(K**2*k**2-4*xm*xp)+(xm-xp)**2) R = 2*K**2*k1**2-S**2-8*x[2]**2 RM = complex(0,1)*SM**2*(xm*(2*k1**2-1)+xp)-(16*complex(0,1))*xm*x[2]**2 RP = complex(0,1)*SM**2*(xp*(2*k1**2-1)+xm)+(16*complex(0,1))*xp*x[2]**2 RMBAR=-complex(0,1)*SP**2*( xp*(2*k1**2-1)+xm ) +16*complex(0,1)*xp*x[2]**2 RPBAR=-complex(0,1)*SP**2*( xm*(2*k1**2-1)+xp ) -16*complex(0,1)*xm*x[2]**2 r=sqrt(x[0]**2+x[1]**2+x[2]**2) DZ = [None]*4 DZ[0] = [None]*3 DZ[1] = [None]*3 DZ[2] = [None]*3 DZ[3] = [None]*3 DZ[0][0] = -2 * ((x[1] + complex(0, 1) * x[0]) * zeta[0] ** 2 + 2 * x[2] * zeta[0] - x[1] + complex(0, 1) * x[0]) * (complex(0, 1) * zeta[0] ** 2 + complex(0, 1)) / (2 * ((x[1] + complex(0, 1) * x[0]) * zeta[0] ** 2 + 2 * x[2] * zeta[0] - x[1] + complex(0, 1) * x[0]) * (2 * (x[1] + complex(0, 1) * x[0]) * zeta[0] + 2 * x[2]) + K ** 2 * (4 * zeta[0] ** 3 + 4 * (-2 * k1 ** 2 + 1) * zeta[0]) / 4) DZ[1][0] = -2 * ((x[1] + complex(0, 1) * x[0]) * zeta[1] ** 2 + 2 * zeta[1] * x[2] - x[1] + complex(0, 1) * x[0]) * (complex(0, 1) * zeta[1] ** 2 + complex(0, 1)) / (2 * ((x[1] + complex(0, 1) * x[0]) * zeta[1] ** 2 + 2 * zeta[1] * x[2] - x[1] + complex(0, 1) * x[0]) * (2 * (x[1] + complex(0, 1) * x[0]) * zeta[1] + 2 * x[2]) + K ** 2 * (4 * zeta[1] ** 3 + 4 * (-2 * k1 ** 2 + 1) * zeta[1]) / 4) DZ[2][0] = -2 * ((x[1] + complex(0, 1) * x[0]) * zeta[2] ** 2 + 2 * x[2] * zeta[2] - x[1] + complex(0, 1) * x[0]) * (complex(0, 1) * zeta[2] ** 2 + complex(0, 1)) / (2 * ((x[1] + complex(0, 1) * x[0]) * zeta[2] ** 2 + 2 * x[2] * zeta[2] - x[1] + complex(0, 1) * x[0]) * (2 * (x[1] + complex(0, 1) * x[0]) * zeta[2] + 2 * x[2]) + K ** 2 * (4 * zeta[2] ** 3 + 4 * (-2 * k1 ** 2 + 1) * zeta[2]) / 4) DZ[3][0] = -2 * ((x[1] + complex(0, 1) * x[0]) * zeta[3] ** 2 + 2 * zeta[3] * x[2] - x[1] + complex(0, 1) * x[0]) * (complex(0, 1) * zeta[3] ** 2 + complex(0, 1)) / (2 * ((x[1] + complex(0, 1) * x[0]) * zeta[3] ** 2 + 2 * zeta[3] * x[2] - x[1] + complex(0, 1) * x[0]) * (2 * (x[1] + complex(0, 1) * x[0]) * zeta[3] + 2 * x[2]) + K ** 2 * (4 * zeta[3] ** 3 + 4 * (-2 * k1 ** 2 + 1) * zeta[3]) / 4) DZ[0][1] = -2 * ((x[1] + complex(0, 1) * x[0]) * zeta[0] ** 2 + 2 * x[2] * zeta[0] - x[1] + complex(0, 1) * x[0]) * (zeta[0] ** 2 - 1) / (2 * ((x[1] + complex(0, 1) * x[0]) * zeta[0] ** 2 + 2 * x[2] * zeta[0] - x[1] + complex(0, 1) * x[0]) * (2 * (x[1] + complex(0, 1) * x[0]) * zeta[0] + 2 * x[2]) + K ** 2 * (4 * zeta[0] ** 3 + 4 * (-2 * k1 ** 2 + 1) * zeta[0]) / 4) DZ[1][1] = -2 * ((x[1] + complex(0, 1) * x[0]) * zeta[1] ** 2 + 2 * zeta[1] * x[2] - x[1] + complex(0, 1) * x[0]) * (zeta[1] ** 2 - 1) / (2 * ((x[1] + complex(0, 1) * x[0]) * zeta[1] ** 2 + 2 * zeta[1] * x[2] - x[1] + complex(0, 1) * x[0]) * (2 * (x[1] + complex(0, 1) * x[0]) * zeta[1] + 2 * x[2]) + K ** 2 * (4 * zeta[1] ** 3 + 4 * (-2 * k1 ** 2 + 1) * zeta[1]) / 4) DZ[2][1] = -2 * ((x[1] + complex(0, 1) * x[0]) * zeta[2] ** 2 + 2 * x[2] * zeta[2] - x[1] + complex(0, 1) * x[0]) * (zeta[2] ** 2 - 1) / (2 * ((x[1] + complex(0, 1) * x[0]) * zeta[2] ** 2 + 2 * x[2] * zeta[2] - x[1] + complex(0, 1) * x[0]) * (2 * (x[1] + complex(0, 1) * x[0]) * zeta[2] + 2 * x[2]) + K ** 2 * (4 * zeta[2] ** 3 + 4 * (-2 * k1 ** 2 + 1) * zeta[2]) / 4) DZ[3][1] = -2 * ((x[1] + complex(0, 1) * x[0]) * zeta[3] ** 2 + 2 * zeta[3] * x[2] - x[1] + complex(0, 1) * x[0]) * (zeta[3] ** 2 - 1) / (2 * ((x[1] + complex(0, 1) * x[0]) * zeta[3] ** 2 + 2 * zeta[3] * x[2] - x[1] + complex(0, 1) * x[0]) * (2 * (x[1] + complex(0, 1) * x[0]) * zeta[3] + 2 * x[2]) + K ** 2 * (4 * zeta[3] ** 3 + 4 * (-2 * k1 ** 2 + 1) * zeta[3]) / 4) DZ[0][2] = -4 * ((x[1] + complex(0, 1) * x[0]) * zeta[0] ** 2 + 2 * x[2] * zeta[0] - x[1] + complex(0, 1) * x[0]) * zeta[0] / (2 * ((x[1] + complex(0, 1) * x[0]) * zeta[0] ** 2 + 2 * x[2] * zeta[0] - x[1] + complex(0, 1) * x[0]) * (2 * (x[1] + complex(0, 1) * x[0]) * zeta[0] + 2 * x[2]) + K ** 2 * (4 * zeta[0] ** 3 + 4 * (-2 * k1 ** 2 + 1) * zeta[0]) / 4) DZ[1][2] = -4 * ((x[1] + complex(0, 1) * x[0]) * zeta[1] ** 2 + 2 * zeta[1] * x[2] - x[1] + complex(0, 1) * x[0]) * zeta[1] / (2 * ((x[1] + complex(0, 1) * x[0]) * zeta[1] ** 2 + 2 * zeta[1] * x[2] - x[1] + complex(0, 1) * x[0]) * (2 * (x[1] + complex(0, 1) * x[0]) * zeta[1] + 2 * x[2]) + K ** 2 * (4 * zeta[1] ** 3 + 4 * (-2 * k1 ** 2 + 1) * zeta[1]) / 4) DZ[2][2] = -4 * ((x[1] + complex(0, 1) * x[0]) * zeta[2] ** 2 + 2 * x[2] * zeta[2] - x[1] + complex(0, 1) * x[0]) * zeta[2] / (2 * ((x[1] + complex(0, 1) * x[0]) * zeta[2] ** 2 + 2 * x[2] * zeta[2] - x[1] + complex(0, 1) * x[0]) * (2 * (x[1] + complex(0, 1) * x[0]) * zeta[2] + 2 * x[2]) + K ** 2 * (4 * zeta[2] ** 3 + 4 * (-2 * k1 ** 2 + 1) * zeta[2]) / 4) DZ[3][2] = -4 * ((x[1] + complex(0, 1) * x[0]) * zeta[3] ** 2 + 2 * zeta[3] * x[2] - x[1] + complex(0, 1) * x[0]) * zeta[3] / (2 * ((x[1] + complex(0, 1) * x[0]) * zeta[3] ** 2 + 2 * zeta[3] * x[2] - x[1] + complex(0, 1) * x[0]) * (2 * (x[1] + complex(0, 1) * x[0]) * zeta[3] + 2 * x[2]) + K ** 2 * (4 * zeta[3] ** 3 + 4 * (-2 * k1 ** 2 + 1) * zeta[3]) / 4) return DZ
def testing_components_energy_density(k, x1, x2, x3): if (is_awc_multiple_root(k, x1, x2, x3) ): return 4 if (is_awc_branch_point(k, x1, x2, x3) ): return 4 zeta = calc_zeta(k ,x1, x2, x3) eta = calc_eta(k, x1, x2, x3) abel = calc_abel(k, zeta, eta) mu = calc_mu(k, x1, x2, x3, zeta, abel) x=[x1,x2,x3] K = complex64(ellipk(k**2)) E = complex64(ellipe(k**2)) cm= (2*E-K)/K k1 = sqrt(1-k**2) xp = x[0]+complex(0,1)*x[1] xm = x[0]-complex(0,1)*x[1] S = sqrt(K**2-4*xp*xm) SP = sqrt(K**2-4*xp**2) SM = sqrt(K**2-4*xm**2) SPM = sqrt(-k1**2*(K**2*k**2-4*xm*xp)+(xm-xp)**2) R = 2*K**2*k1**2-S**2-8*x[2]**2 RM = complex(0,1)*SM**2*(xm*(2*k1**2-1)+xp)-(16*complex(0,1))*xm*x[2]**2 RP = complex(0,1)*SM**2*(xp*(2*k1**2-1)+xm)+(16*complex(0,1))*xp*x[2]**2 RMBAR=-complex(0,1)*SP**2*( xp*(2*k1**2-1)+xm ) +16*complex(0,1)*xp*x[2]**2 RPBAR=-complex(0,1)*SP**2*( xm*(2*k1**2-1)+xp ) -16*complex(0,1)*xm*x[2]**2 r=sqrt(x[0]**2+x[1]**2+x[2]**2) DM = dmus(zeta, x, k) DZ = dzetas(zeta, x,k) DDM = ddmus(zeta, x, k) DDZ = ddzetas(zeta, x,k) GNUM = grams(zeta, mu, [x1, x2, x3], k) # DGS1 = dgrams1(zeta, mu, DM, DZ, x, k) # # DGS2 = dgrams2(zeta, mu, DM, DZ, x, k) # # DGS3 = dgrams3(zeta, mu, DM, DZ, x, k) # return exp(-6 * mu[0]) print zeta, '\n', abel, '\n', mu, '\n' #mu[0], abel[0], exp(-6*mu[0]) return
def test_compressed(self): with warnings.catch_warnings(): warnings.filterwarnings('ignore', message="warning: empty strings") s = readsav(path.join(DATA_PATH, 'various_compressed.sav'), verbose=False) assert_identical(s.i8u, np.uint8(234)) assert_identical(s.f32, np.float32(-3.1234567e+37)) assert_identical(s.c64, np.complex128(1.1987253647623157e+112-5.1987258887729157e+307j)) assert_equal(s.array5d.shape, (4, 3, 4, 6, 5)) assert_identical(s.arrays.a[0], np.array([1, 2, 3], dtype=np.int16)) assert_identical(s.arrays.b[0], np.array([4., 5., 6., 7.], dtype=np.float32)) assert_identical(s.arrays.c[0], np.array([np.complex64(1+2j), np.complex64(7+8j)])) assert_identical(s.arrays.d[0], np.array([b"cheese", b"bacon", b"spam"], dtype=np.object))
def test_cublasCgeam(self): a = (np.random.rand(2, 3)+1j*np.random.rand(2, 3)).astype(np.complex64) b = (np.random.rand(2, 3)+1j*np.random.rand(2, 3)).astype(np.complex64) a_gpu = gpuarray.to_gpu(a.copy()) b_gpu = gpuarray.to_gpu(b.copy()) c_gpu = gpuarray.zeros_like(a_gpu) alpha = np.complex64(np.random.rand()+1j*np.random.rand()) beta = np.complex64(np.random.rand()+1j*np.random.rand()) cublas.cublasCgeam(self.cublas_handle, 'n', 'n', 2, 3, alpha, a_gpu.gpudata, 2, beta, b_gpu.gpudata, 2, c_gpu.gpudata, 2) assert np.allclose(c_gpu.get(), alpha*a+beta*b)
def transform_raw_data(self, data, n_int, fill_conjugate=False): """ Transform dada data into a useful visibility matrix Parameters ---------- data: np.ndarray data array to transform into a visibility matrix n_int: number of integrations in data array fill_conjugate: bool Default False. Will compute upper half (conjugate) of full visibilty matrix if set to True. Notes ----- This function dominates data processing time. Unless you need a full visibility matrix, do not run this with fill_conjugate=True, as this approximately doubles the amount of processing time. TODO: This may break if system endianness is different TODO: Add support for outputting in upper/lower triangular format """ #print "#Converting", self.filename data = data.view(dtype=self.dtype).astype(np.float32) # Note: The real and imag components are stored separately data = data.reshape((n_int, 2, self.n_chans, self.matlen)) # Scatter values into new full matrix fullmatrix = np.zeros((n_int, self.n_chans, self.n_input, self.n_input), dtype=np.complex64) if not fill_conjugate: # Note cols then rows and conjugation (-1j) -- this is required data = data[..., 0, :, :] + np.complex64(-1j) * data[..., 1, :, :] fullmatrix[..., self.matcols, self.matrows] = data else: # Fill out the other (conjugate) triangle # Note rows then cols and no conjugation -- in contrast to above data = data[..., 0, :, :] + np.complex64(1j) * data[..., 1, :, :] fullmatrix[..., self.matrows, self.matcols] = data tri_inds = np.arange(self.n_input * (self.n_input + 1) / 2, dtype=np.uint32) rows, cols = self.triangular_coords(tri_inds) fullmatrix[..., cols, rows] = np.conj(fullmatrix[..., rows, cols]) # Reorder so that pol products change fastest fullmatrix = fullmatrix.reshape(n_int, self.n_chans, self.n_station, self.n_pol, self.n_station, self.n_pol) fullmatrix = fullmatrix.transpose([0, 2, 4, 1, 3, 5]) self.data = fullmatrix
def test_different_dtypes_fail(self): in_shape = self.input_shapes["2d"] out_shape = self.output_shapes["2d"] axes = (-1,) a, b = self.create_test_arrays(in_shape, out_shape) a_ = numpy.complex64(a) b_ = numpy.complex128(b) self.assertRaisesRegex(ValueError, "Invalid scheme", FFTW, *(a_, b_)) a_ = numpy.complex128(a) b_ = numpy.complex64(b) self.assertRaisesRegex(ValueError, "Invalid scheme", FFTW, *(a_, b_))
def testc(): print '-------------------------------------------' A = np.random.random((N,N))+1.0j*np.random.random((N,N)) B = np.random.random((N,N))+1.0j*np.random.random((N,N)) A = np.complex64(A) B = np.complex64(B) t1 = time.time() C_h = np.dot(A,B) t2 = time.time() print 'np.dot took %0.3f ms' % ((t2-t1)*1000.0) t1 = time.time() C = cuda_cdot(A,B) t2 = time.time() print 'cuda_dot took %0.3f ms' % ((t2-t1)*1000.0) print 'norm',np.linalg.norm(C-C_h)
def test_cublasCscal(self): x = (np.random.rand(5)+1j*np.random.rand(5)).astype(np.complex64) x_gpu = gpuarray.to_gpu(x) alpha = np.complex64(np.random.rand()+1j*np.random.rand()) cublas.cublasCscal(self.cublas_handle, x_gpu.size, alpha, x_gpu.gpudata, 1) assert np.allclose(x_gpu.get(), alpha*x)
def test_byteswap(self): import numpy as np assert np.int64(123).byteswap() == 8863084066665136128 a = np.complex64(1 + 2j).byteswap() assert repr(a.real).startswith("4.60060") assert repr(a.imag).startswith("8.96831")
def __init__(self, data_vec, harm=1): """ Initializes the pixel instance by parsing the provided data. Parameters ---------- data_vec : 1D float numpy array Data contained within each pixel harm: unsigned int Harmonic of the BE waveform. absolute value of the wave type used to normalize the response waveform. """ harm = abs(harm) if harm > 3 or harm < 1: harm = 1 warn( 'Error in BEPSndfPixel: invalid wave type / harmonic provided.' ) # Begin parsing data: self.spatial_index = int(data_vec[1]) - 1 self.spectrogram_length = int(data_vec[0]) # calculate indices for parsing s1 = int(data_vec[2]) # total rows in pixel s2 = int(data_vec[3]) # total cols in pixel data_vec1 = data_vec[2:self.spectrogram_length] data_mat1 = data_vec1.reshape(s1, s2) spect_size1 = int(data_mat1[1, 0]) # total rows in spectrogram set self.num_bins = int(spect_size1 / 2) # or, len(BE_bin_w) self.num_steps = int(data_mat1[1, 1]) # total cols in spectrogram set s3 = int(s1 - spect_size1) #row index of beginning of spectrogram set s4 = int(s2 - self.num_steps) #col index of beginning of spectrogram set self.wave_label = data_mat1[2, 0] # This is useless self.wave_modulation_type = data_mat1[ 2, 1] # this is the one with useful information #print 'Pixel #',self.spatial_index,' Wave label: ', self.wave_label, ', Wave Type: ', self.wave_modulation_type # First get the information from the columns: FFT_BE_wave_real = data_mat1[s3:s3 - 0 + self.num_bins, 1] #real part of excitation waveform FFT_BE_wave_imag = data_mat1[s3 + self.num_bins:s3 - 0 + spect_size1, 1] #imaginary part of excitation waveform # Though typecasting the combination of the real and imaginary data looks fine in HDFviewer and Spyder, Labview sees such data as an array of clusters having "r" and "i" elements #self.FFT_BE_wave = np.complex64(FFT_BE_wave_real + 1j*FFT_BE_wave_imag) #complex excitation waveform !!! due to a problem in the acquisition software, this may not be normalzed properly self.FFT_BE_wave = np.zeros(self.num_bins, dtype=np.complex64) self.FFT_BE_wave.real = FFT_BE_wave_real self.FFT_BE_wave.imag = FFT_BE_wave_imag del FFT_BE_wave_real, FFT_BE_wave_imag self.BE_bin_w = data_mat1[s3:s3 - 0 + self.num_bins, 2] # vector of band frequencies self.BE_bin_ind = data_mat1[ s3 + self.num_bins:s3 - 0 + spect_size1, 2] # vector of band indices (out of all accesible frequencies below Nyquist frequency) # Now look at the top few rows to get more information: self.DAQ_channel = data_mat1[2, 2] self.num_x_steps = int(data_mat1[3, 0]) self.num_y_steps = int(data_mat1[4, 0]) self.num_z_steps = int(data_mat1[5, 0]) self.z_index = int(data_mat1[5, 1] - 1) self.y_index = int(data_mat1[4, 1] - 1) self.x_index = int(data_mat1[3, 1] - 1) self.step_ind_vec = data_mat1[0, s4:] # vector of step indices self.DC_off_vec = data_mat1[1, s4:] # vector of dc offsets voltages self.AC_amp_vec = data_mat1[2, s4:] # vector of ac amplitude voltages self.noise_floor_mat = data_mat1[ 3:6, s4:] # matrix of noise floor data. Use this information to exclude bins during fitting #plot_group_list_mat = data_mat1[6:s3-2,s4:] # matrix of plot groups # Here come the optional parameter rows: self.deflVolt_vec = data_mat1[ s3 - 2, s4:] # vector of dc cantilever deflection # I think this is how the defl setpoint vec should be fixed: self.deflVolt_vec[np.isnan(self.deflVolt_vec)] = 0 # so far, this vector seemed to match the DC offset vector.... self.laser_spot_pos_vec = data_mat1[s3 - 1, s4:] # NEVER used # Actual data for this pixel: spectrogram_real_mat = data_mat1[ s3:s3 + self.num_bins, s4:] #real part of response spectrogram spectrogram_imag_mat = data_mat1[ s3 + self.num_bins:s3 + spect_size1, s4:] #imaginary part of response spectrogram # Be consistent and ensure that the data is also stored as 64 bit complex as in the array creation self.spectrogram_mat = np.complex64( spectrogram_real_mat + 1j * spectrogram_imag_mat) #complex part of response spectrogram del spectrogram_real_mat, spectrogram_imag_mat self.spectrogram_mat = normalizeBEresponse(self.spectrogram_mat, self.FFT_BE_wave, harm) # Reshape as one column (its free in Python anyway): temp_mat = self.spectrogram_mat.transpose() self.spectrogram_vec = temp_mat.reshape(self.spectrogram_mat.size)
def test_rec_read_c(self): self._test_rec_read(np.complex64(4.0 + 5.0j), record_read_c, 'c')
import bart #define forward and backward mappging between image space and k-space def k2i(K): X = np.fft.fftshift(np.fft.ifftn(np.fft.ifftshift(K.copy(),axes=(0,1,2)),axes=(0,1,2),norm="ortho"),axes=(0,1,2)) return X def i2k(X): K = np.fft.ifftshift(np.fft.fftn(np.fft.fftshift(X.copy(),axes=(0,1,2)),axes=(0,1,2),norm="ortho"),axes=(0,1,2)) return K #load kspace data and sensitivity maps f = h5py.File(os.path.join(sys.path[0], "data.h5"),'r') #f = h5py.File('data.h5','r') K = np.complex64(f["K"]) sMaps = np.complex64(f["sMaps"]) f.close() print('Sucessfuly loaded data, start recon') #combine coil data according to Roemer and take max intensity of image to scale regularization weight accordingly sos = np.sqrt(np.sum(np.abs(sMaps[:,:,:,:,None,None,None])**2,3))+1e-6 rcomb = np.sum(k2i(K)*np.conj(sMaps[:,:,:,:,None,None,None]),3)/sos regFactor = np.max(np.abs(rcomb.flatten())) print('scaling Factor for recon: ', regFactor) #set up Recon regWeight = 0.012 #lambda in Cost function blk = 16 #block size for locally low rank recon bart_string = 'pics -u1 -w 1 -H -d5 -e -i 80 -R L:7:7:%.2e -b %d' % (regFactor*regWeight,blk) #define Bart strings
def data(self): if self._infoonly: raise InfoOnlyArray() sz = self.size() dims = self.shape() def to_nd_array(c_pointer, dtype): return make_nd_array(c_pointer, sz, dims, dtype) if _libmx.mxIsChar_800(self._pm): s = cast(_libmx.mxGetChars_800(self._pm), POINTER(c_wchar * sz)).contents.value if sz == 0: return "" elif len(dims) == 2 and dims[0] == 1: # single string return s else: # array of characters return np.array(list(s)).reshape(dims) # return to_nd_array(_libmx.mxGetChars_800(self._pm), 'U1') elif _libmx.mxIsStruct_800(self._pm): nfields = _libmx.mxGetNumberOfFields_800(self._pm) if sz == 0: # create empty dictionary return dict() elif sz == 1: # create dictionary return dict([( _libmx.mxGetFieldNameByNumber_800(self._pm, i).decode("utf-8"), matlab_array( _libmx.mxGetFieldByNumber_800(self._pm, 0, i), False, False, ), ) for i in range(nfields)]) else: return np.array( [ matlab_array( _libmx.mxGetFieldByNumber_800(self._pm, 0, i), False, False) for i in range(sz) ], [( _libmx.mxGetFieldNameByNumber_800(self._pm, i).decode("utf-8"), np.object_, ) for i in range(nfields)], ).reshape(dims) elif _libmx.mxIsEmpty_800(self._pm): return None elif _libmx.mxIsCell_800(self._pm): # create ndarray of matlab_arrays def cellisstr(i): pcm = _libmx.mxGetCell_800(self._pm, i) return (_libmx.mxIsChar_800(pcm) and _libmx.mxGetNumberOfDimensions_800(pcm) == 2 and _libmx.mxGetDimensions_800(pcm)[0] == 1) if next((i for i in range(sz) if not cellisstr(i)), -1) < 0: # found cellstr return np.array([ cast( _libmx.mxGetChars_800(_libmx.mxGetCell_800( self._pm, i)), POINTER(c_wchar * sz), ).contents.value for i in range(sz) ]).reshape(dims) elif sz == 1: return matlab_array(_libmx.mxGetCell_800(self._pm, 0), False, False) else: return np.array( [ matlab_array(_libmx.mxGetCell_800(self._pm, i), False, False) for i in range(sz) ], np.object_, ).reshape(dims) elif _libmx.mxIsLogical_800(self._pm): if sz == 1: return _libmx.mxIsLogicalScalarTrue_800(self._pm) else: return to_nd_array(_libmx.mxGetLogicals_800(self._pm), np.bool) else: # numeric iscplx = _libmx.mxIsComplex_800(self._pm) cfgs = { 0: { "istype": _libmx.mxIsDouble_800, "getdata": _libmx.mxGetDoubles_800, "getcdata": _libmx.mxGetComplexDoubles_800, "type": np.float64, "ctype": np.complex128, }, 1: { "istype": _libmx.mxIsSingle_800, "getdata": _libmx.mxGetSingles_800, "getcdata": _libmx.mxGetComplexSingles_800, "type": np.float32, "ctype": np.complex64, }, 2: { "istype": _libmx.mxIsInt8_800, "getdata": _libmx.mxGetInt8s_800, "getcdata": _libmx.mxGetComplexInt8s_800, "type": np.int8, "ctype": np.dtype([("real", np.int8), ("imag", np.int8)]), }, 3: { "istype": _libmx.mxIsUint8_800, "getdata": _libmx.mxGetUint8s_800, "getcdata": _libmx.mxGetComplexUint8s_800, "type": np.uint8, "ctype": np.dtype([("real", np.uint8), ("imag", np.uint8)]), }, 4: { "istype": _libmx.mxIsInt16_800, "getdata": _libmx.mxGetInt16s_800, "getcdata": _libmx.mxGetComplexInt16s_800, "type": np.int16, "ctype": np.dtype([("real", np.int16), ("imag", np.int16)]), }, 5: { "istype": _libmx.mxIsUint16_800, "getdata": _libmx.mxGetUint16s_800, "getcdata": _libmx.mxGetComplexUint16s_800, "type": np.uint16, "ctype": np.dtype([("real", np.uint16), ("imag", np.uint16)]), }, 6: { "istype": _libmx.mxIsInt32_800, "getdata": _libmx.mxGetInt32s_800, "getcdata": _libmx.mxGetComplexInt32s_800, "type": np.int32, "ctype": np.dtype([("real", np.int32), ("imag", np.int32)]), }, 7: { "istype": _libmx.mxIsUint32_800, "getdata": _libmx.mxGetUint32s_800, "getcdata": _libmx.mxGetComplexUint32s_800, "type": np.uint32, "ctype": np.dtype([("real", np.uint32), ("imag", np.uint32)]), }, 8: { "istype": _libmx.mxIsInt64_800, "getdata": _libmx.mxGetInt64s_800, "getcdata": _libmx.mxGetComplexInt64s_800, "type": np.int64, "ctype": np.dtype([("real", np.int64), ("imag", np.int64)]), }, 9: { "istype": _libmx.mxIsUint64_800, "getdata": _libmx.mxGetUint64s_800, "getcdata": _libmx.mxGetComplexUint64s_800, "type": np.uint64, "ctype": np.dtype([("real", np.uint64), ("imag", np.uint64)]), }, } index = next( (i for i in range(len(cfgs)) if cfgs[i]["istype"](self._pm)), len(cfgs)) if index < len(cfgs): cfg = cfgs[index] pdata = (cfg["getcdata"](self._pm) if iscplx else cfg["getdata"](self._pm)) if sz == 1: if iscplx: if index == 0: return complex(pdata[0].real, pdata[0].imag) elif index == 1: return np.complex64( 1j * pdata[0].imag) + np.float32(pdata[0].real) else: return { "real": pdata[0].real, "imag": pdata[0].imag } else: return pdata[0] return to_nd_array(pdata, (cfg["ctype"] if iscplx else cfg["type"])) else: raise Exception("Unsupported data type")
def funarrayscalar(): import numpy return numpy.complex64(2 + 3j), numpy.float32(1.), numpy.int8( 123), numpy.bool8(True)
], [ "testarr", np.array([12, 14, 90]), "testarr in extra_keywords is a list, array or dict", "Extra keyword testarr is of <class 'numpy.ndarray'>", ], [ "test_long_key", True, "key test_long_key in extra_keywords is longer than 8 characters", None, ], [ "complex1", np.complex64(5.3 + 1.2j), None, "Extra keyword complex1 is of <class 'numpy.complex64'>", ], [ "complex2", 6.9 + 4.6j, None, "Extra keyword complex2 is of <class 'complex'>", ], ), ) def test_miriad_extra_keywords_errors( uv_in_paper, tmp_path, kwd_name, kwd_value, warnstr, errstr ): uv_in, uv_out, testfile = uv_in_paper
def test_complex(self): s = compute_fingerprint(1j) self.assertEqual(s, compute_fingerprint(1 + 0j)) s = compute_fingerprint(np.complex64()) self.assertEqual(compute_fingerprint(np.complex64(2.0)), s) self.assertNotEqual(compute_fingerprint(np.complex128()), s)
from typing import Any, List import numpy as np import numpy.typing as npt # Can't directly import `np.float128` as it is not available on all platforms f16: np.floating[npt._128Bit] c16 = np.complex128() f8 = np.float64() i8 = np.int64() u8 = np.uint64() c8 = np.complex64() f4 = np.float32() i4 = np.int32() u4 = np.uint32() dt = np.datetime64(0, "D") td = np.timedelta64(0, "D") b_ = np.bool_() b = bool() c = complex() f = float() i = int() AR_b: np.ndarray[Any, np.dtype[np.bool_]] AR_u: np.ndarray[Any, np.dtype[np.uint32]] AR_i: np.ndarray[Any, np.dtype[np.int64]] AR_f: np.ndarray[Any, np.dtype[np.float64]]
def test_byteswap(self): import numpy as np assert np.int64(123).byteswap() == 8863084066665136128 a = np.complex64(1+2j).byteswap() assert repr(a.real).startswith('4.60060') assert repr(a.imag).startswith('8.96831')
expected = np.array([True]) self._check_behavior(arr, expected) m8_units = ['as', 'ps', 'ns', 'us', 'ms', 's', 'm', 'h', 'D', 'W', 'M', 'Y'] na_vals = [ None, NaT, float('NaN'), complex('NaN'), np.nan, np.float64('NaN'), np.float32('NaN'), np.complex64(np.nan), np.complex128(np.nan), np.datetime64('NaT'), np.timedelta64('NaT'), ] + [np.datetime64('NaT', unit) for unit in m8_units ] + [np.timedelta64('NaT', unit) for unit in m8_units] inf_vals = [ float('inf'), float('-inf'), complex('inf'), complex('-inf'), np.inf, np.NINF, ]
def train_model(train_data): td = train_data summaries = tf.summary.merge_all() RestoreSession = False if not RestoreSession: td.sess.run(tf.global_variables_initializer()) # lrval = FLAGS.learning_rate_start learning_rate_start = myParams.myDict['learning_rate_start'] lrval = myParams.myDict['learning_rate_start'] start_time = time.time() last_summary_time = time.time() last_checkpoint_time = time.time() done = False batch = 0 print("lrval %f" % (lrval)) # assert FLAGS.learning_rate_half_life % 10 == 0 # Cache test features and labels (they are small) test_feature, test_label = td.sess.run([td.test_features, td.test_labels]) # test_label = td.sess.run([td.test_features, td.test_labels]) G_LossV = np.zeros((1000000), dtype=np.float32) filename = os.path.join(myParams.myDict['train_dir'], 'TrainSummary.mat') feed_dictOut = {td.gene_minput: test_feature} gene_output = td.sess.run(td.gene_moutput, feed_dict=feed_dictOut) # _summarize_progress(td, test_label, gene_output, batch, 'out') feed_dict = {td.learning_rate: lrval} opsx = [td.gene_minimize, td.gene_loss] _, gene_loss = td.sess.run(opsx, feed_dict=feed_dict) # opsy = [td.gene_loss] # gene_loss = td.sess.run(opsy, feed_dict=feed_dict) # ops = [td.gene_minimize, td.disc_minimize, td.gene_loss, td.disc_real_loss, td.disc_fake_loss] # _, _, gene_loss, disc_real_loss, disc_fake_loss = td.sess.run(ops, feed_dict=feed_dict) batch += 1 # run_metadata = tf.RunMetadata() gene_output = td.sess.run(td.gene_moutput, feed_dict=feed_dictOut) # gene_output = td.sess.run(td.gene_moutput, options=tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE, output_partition_graphs=True), feed_dict=feed_dictOut,run_metadata=run_metadata) # _summarize_progress(td, test_label, gene_output, batch, 'out') # with open("/tmp/run2.txt", "w") as out: # out.write(str(run_metadata)) # fetched_timeline = timeline.Timeline(run_metadata.step_stats) # chrome_trace = fetched_timeline.generate_chrome_trace_format() # with open('timeline_01.json', 'w') as f: # f.write(chrome_trace) # tl = timeline.Timeline(run_metadata.step_stats) # print(tl.generate_chrome_trace_format(show_memory=True)) # trace_file = tf.gfile.Open(name='timeline', mode='w') # trace_file.write(tl.generate_chrome_trace_format(show_memory=True)) feed_dict = {td.learning_rate: lrval} # ops = [td.gene_minimize, td.disc_minimize, td.gene_loss, td.disc_real_loss, td.disc_fake_loss] opsx = [td.gene_minimize, td.gene_loss] _, gene_loss = td.sess.run(opsx, feed_dict=feed_dict) batch += 1 gene_output = td.sess.run(td.gene_moutput, feed_dict=feed_dictOut) # _summarize_progress(td, test_label, gene_output, batch, 'out') # load model #saver.restore(sess,tf.train.latest_checkpoint('./')) # running model on data:test_feature RunOnData = False if RunOnData: filenames = tf.gfile.ListDirectory('DataAfterpMat') filenames = sorted(filenames) #filenames = [os.path.join('DataAfterpMat', f) for f in filenames] Ni = len(filenames) OutBase = myParams.myDict['SessionName'] + '_OutMat' tf.gfile.MakeDirs(OutBase) #pdb.set_trace() for index in range(Ni): print(index) print(filenames[index]) CurData = scipy.io.loadmat( os.path.join('DataAfterpMat', filenames[index])) Data = CurData['CurData'] Data = Data.reshape((1, 64, 64, 1)) test_feature = np.kron(np.ones((16, 1, 1, 1)), Data) #test_feature = np.array(np.random.choice([0, 1], size=(16,64,64,1)), dtype='float32') feed_dictOut = {td.gene_minput: test_feature} gene_output = td.sess.run(td.gene_moutput, feed_dict=feed_dictOut) filenameOut = os.path.join(OutBase, filenames[index][:-4] + '_out.mat') SOut = {} SOut['X'] = gene_output[0] scipy.io.savemat(filenameOut, SOut) # pdb.set_trace() #_summarize_progress(td, test_feature, test_label, gene_output, batch, 'out') # to get value of var: # ww=td.sess.run(td.gene_var_list[1]) if GT.getparam('ShowRealData') > 0: # ifilename=os.path.join('RealData', 'b.mat') if GT.getparam('InputMode') == 'RegridTry3F_B0T2S_ITS_MB': MB = GT.getparam('MB') nCh = GT.getparam('nccToUse') nTSC = GT.getparam('nTimeSegments') batch_size = myParams.myDict['batch_size'] channelsIn = myParams.myDict['channelsIn'] channelsOut = myParams.myDict['channelsOut'] LabelsH = myParams.myDict['LabelsH'] LabelsW = myParams.myDict['LabelsW'] H = LabelsH W = LabelsW TimePoints_ms = GT.getparam('TimePoints_ms') SN = GT.getparam('SN') # H,W,f8 P = GT.getparam('P') # H,W,f8 nTraj = GT.getparam('nTraj') cCAIPIVecZ = GT.getparam('cCAIPIVecZ') # MB,nTraj complex128 TSBF = GT.getparam('TSBF') # nTS,nTraj f64 Rec0FN = '/opt/data/RealDataMB/meas_MID426_gBP_2dSpiral_multiecho_ASL_2mm_iso_run1_FID34170_2Echos/Sli06_Rec0.mat' B0TSFFN = '/opt/data/RealDataMB/meas_MID426_gBP_2dSpiral_multiecho_ASL_2mm_iso_run1_FID34170_2Echos/Sli06/B0TS.mat' SensDataFN = '/opt/data/RealDataMB/meas_MID426_gBP_2dSpiral_multiecho_ASL_2mm_iso_run1_FID34170_2Echos/Sli06/SensCC1.mat' RealDtFN = '/opt/data/RealDataMB/meas_MID426_gBP_2dSpiral_multiecho_ASL_2mm_iso_run1_FID34170_2Echos/Sli06/RealDataForNN.mat' Rec0F = scipy.io.loadmat(Rec0FN) Rec0 = Rec0F['Rec0'] # (96, 192) complex128 Rec0MB = np.transpose(np.reshape(Rec0, [H, MB, W]), (0, 2, 1)) # H,W,MB complex128 B0TSF = scipy.io.loadmat(B0TSFFN) CurB0 = B0TSF['CurB0'] # (96, 96, 2) f8, in Hz # B0TSF.keys() SensData = scipy.io.loadmat(SensDataFN) # SensData.keys() SensCCA = SensData['SensCCA'] # (96, 96, 16) complex128 SensCCB = SensData['SensCCB'] # (96, 96, 16) complex128 RealSensCCMB = np.stack((SensCCA, SensCCB), axis=3) # (96, 96, 16,2) complex128 RealSensCCMB = RealSensCCMB[:, :, :nCh, :] # H,W,nCh,MB RealData = scipy.io.loadmat(RealDtFN) DataCC = RealData['DataCC'] # (10238, 16) (nTraj, ncc) complex64 DataCC = DataCC[:, :nCh] # (nTraj, nCh) complex64 CurB0_Hz = CurB0[:, :, np.newaxis, :] RealTSC0 = np.complex64( np.exp(1j * 2 * np.pi * CurB0_Hz * GT.NP_addDim(TimePoints_ms) / 1000)) # (96, 96, 7, 2) # Add T2* of 20 T2S_est_ms = 20 RealTSC0 = RealTSC0 * np.exp( -GT.NP_addDim(TimePoints_ms) / T2S_est_ms) WarmStart_ITS = Rec0MB[:, :, np.newaxis, :] * RealTSC0 # H,W,nTS,MB TSBFCAIPI = np.transpose(cCAIPIVecZ[:, :, np.newaxis], (1, 2, 0)) * np.transpose( TSBF[:, :, np.newaxis], (1, 0, 2)) # nTraj,nTS,MB c128 cTSBFCAIPI = np.conj( np.transpose( TSBFCAIPI[:, :, :, np.newaxis, np.newaxis], (0, 1, 3, 2, 4))) # nTraj,nTS,/nCh/,MB,/batch_size/ DataCCMB = DataCC[:, np.newaxis, :, np.newaxis, np.newaxis] # nTraj,/nTS/,nCh,/MB/,/batch_size/ DataCCMB = DataCCMB * cTSBFCAIPI # nTraj,nTS,nCh,MB,/batch_size/ # Padded=sps_x_dense_vecs(np.conj(np.transpose(P)),DataCCMB) Padded = np.conj(np.transpose(P)) * np.reshape( DataCCMB, (nTraj, -1)) Padded = np.reshape(Padded, (H * 2, W * 2, nTSC, nCh, MB, 1)) Padded = np.transpose(Padded, (2, 3, 4, 5, 0, 1)) # Padded=np.reshape(Padded,(nTSC,nCh,MB,1,H*2,W*2)) IFPadded = np.fft.ifft2(Padded, axes=(-2, -1)) Cropped = IFPadded[:, :, :, :, :H, : W] # nTS,nCh,MB,/batch_size/,H,W CroppedP = np.transpose( Cropped, (5, 4, 1, 2, 0, 3)) # H,W,nCh,MB,nTS,/batch_size/ Real_NUFFTHSig = np.sum( CroppedP * np.conj(RealSensCCMB[:, :, :, :, np.newaxis, np.newaxis]), axis=2) # H,W,MB,nTS,/batch_size/ # RealSensCCMB=RealSensCCMB[:,:,:nCh,:] # H,W,nCh,MB Real_NUFFTHSig = np.transpose(Real_NUFFTHSig, (4, 0, 1, 3, 2)) Real_NUFFTHSig = Real_NUFFTHSig * np.conj( SN[np.newaxis, :, :, np.newaxis, np.newaxis]) # /batch_size/,H,W,nTS,MB RealSensCCMB1D = GT.NP_ConcatRIOn0( np.reshape(RealSensCCMB, (-1, 1, 1))) Real_feature = RealSensCCMB1D RealTSC01D = GT.NP_ConcatRIOn0(np.reshape(RealTSC0, (-1, 1, 1))) Real_feature = np.concatenate((Real_feature, RealTSC01D), axis=0) WarmStart_ITS1D = GT.NP_ConcatRIOn0( np.reshape(WarmStart_ITS, (-1, 1, 1))) Real_feature = np.concatenate((Real_feature, WarmStart_ITS1D), axis=0) Real_NUFFTHSig1D = GT.NP_ConcatRIOn0( np.reshape(Real_NUFFTHSig, (-1, 1, 1))) Real_feature = np.concatenate((Real_feature, Real_NUFFTHSig1D), axis=0) Real_feature = np.tile(Real_feature, (batch_size, 1, 1, 1)) if myParams.myDict['InputMode'] == 'SPEN_FC': ifilename = myParams.myDict['RealDataFN'] RealData = scipy.io.loadmat(ifilename) RealData = RealData['Data'] # RealData=np.reshape(RealData,) # RealData=RealData Real_feature = RealData if myParams.myDict['InputMode'] == 'SPEN_Local': ifilename = myParams.myDict['RealDataFN'] RealData = scipy.io.loadmat(ifilename) RealData = RealData['Data'] # RealData=RealData Real_feature = RealData if False: if RealData.ndim == 2: RealData = RealData.reshape( (RealData.shape[0], RealData.shape[1], 1, 1)) if RealData.ndim == 3: RealData = RealData.reshape( (RealData.shape[0], RealData.shape[1], RealData.shape[2], 1)) if myParams.myDict['InputMode'] == 'RegridTry1' or myParams.myDict[ 'InputMode'] == 'RegridTry2': ifilename = myParams.myDict['RealDataFN'] RealData = scipy.io.loadmat(ifilename) RealData = RealData['Data'] # FullData=scipy.io.loadmat('/media/a/f38a5baa-d293-4a00-9f21-ea97f318f647/home/a/TF/NMapIndTesta.mat') FullData = scipy.io.loadmat(myParams.myDict['NMAP_FN']) NMapCR = FullData['NMapCR'] batch_size = myParams.myDict['batch_size'] Real_feature = np.reshape(RealData[0], [RealData.shape[1]]) Real_feature = np.take(Real_feature, NMapCR) Real_feature = np.tile(Real_feature, (batch_size, 1, 1, 1)) if myParams.myDict['InputMode'] == 'RegridTry3' or myParams.myDict[ 'InputMode'] == 'RegridTry3M' or myParams.myDict[ 'InputMode'] == 'RegridTry3F' or myParams.myDict[ 'InputMode'] == 'RegridTry3FMB' or myParams.myDict[ 'InputMode'] == 'RegridTry3FME': ifilename = myParams.myDict['RealDataFN'] RealData = scipy.io.loadmat(ifilename) RealData = RealData['Data'] batch_size = myParams.myDict['batch_size'] nTraj = myParams.myDict['nTraj'] RealDatancc = myParams.myDict['RealDatancc'] nccInData = myParams.myDict['nccInData'] # RealData=RealData # RealData=np.reshape(RealData,[batch_size,RealDatancc,nTraj,2]) # RealData=RealData[:,0:nccInData,:,:] # RealData=np.reshape(RealData,[batch_size,nTraj,RealDatancc,2]) # RealData=RealData[:,:,0:nccInData,:] # RealData=np.reshape(RealData,[batch_size,-1]) RealData = RealData[0, :] RealData = np.tile(RealData, (batch_size, 1)) Real_feature = np.reshape( RealData, [RealData.shape[0], RealData.shape[1], 1, 1]) Real_dictOut = {td.gene_minput: Real_feature} # LearningDecayFactor=np.power(2,(-1/FLAGS.learning_rate_half_life)) learning_rate_half_life = myParams.myDict['learning_rate_half_life'] LearningDecayFactor = np.power(2, (-1 / learning_rate_half_life)) # train_time=FLAGS.train_time train_time = myParams.myDict['train_time'] QuickFailureTimeM = myParams.myDict['QuickFailureTimeM'] QuickFailureThresh = myParams.myDict['QuickFailureThresh'] summary_period = myParams.myDict['summary_period'] # in Minutes checkpoint_period = myParams.myDict['checkpoint_period'] # in Minutes DiscStartMinute = myParams.myDict['DiscStartMinute'] gene_output = td.sess.run(td.gene_moutput, feed_dict=feed_dictOut) if myParams.myDict['ShowRealData'] > 0: gene_RealOutput = td.sess.run(td.gene_moutput, feed_dict=Real_dictOut) gene_output[0] = gene_RealOutput[0] Asuffix = 'out_%06.4f' % (gene_loss) _summarize_progress(td, test_label, gene_output, batch, Asuffix) print("Adding to saver:") var_listX = td.gene_var_list var_listX = [v for v in var_listX if "Bank" not in v.name] # var_listX = tf.sort(var_listX) for line in var_listX: print("Adding " + line.name + ' ' + str(line.shape.as_list())) print("Saver var list end") saver = tf.train.Saver(var_listX) # _save_checkpoint(td, batch,G_LossV,saver) tf.get_default_graph().finalize() while not done: batch += 1 gene_loss = disc_real_loss = disc_fake_loss = -1.234 # elapsed = int(time.time() - start_time)/60 CurTime = time.time() elapsed = (time.time() - start_time) / 60 # Update learning rate lrval *= LearningDecayFactor if (learning_rate_half_life < 1000): # in minutes lrval = learning_rate_start * np.power( 0.5, elapsed / learning_rate_half_life) #print("batch %d gene_l1_factor %f' " % (batch,FLAGS.gene_l1_factor)) # if batch==200: if elapsed > DiscStartMinute: FLAGS.gene_l1_factor = 0.9 RunDiscriminator = FLAGS.gene_l1_factor < 0.999 feed_dict = {td.learning_rate: lrval} if RunDiscriminator: ops = [ td.gene_minimize, td.disc_minimize, td.gene_loss, td.disc_real_loss, td.disc_fake_loss ] _, _, gene_loss, disc_real_loss, disc_fake_loss = td.sess.run( ops, feed_dict=feed_dict) else: ops = [ td.gene_minimize, td.gene_loss, td.MoreOut, td.MoreOut2, td.MoreOut3 ] _, gene_loss, MoreOut, MoreOut2, MoreOut3 = td.sess.run( ops, feed_dict=feed_dict) G_LossV[batch] = gene_loss # ggg: Force phase only var # VR = [v for v in tf.global_variables() if v.name == "gene/GEN_L004/add_Mult2DMCyCSharedOverFeat_weightR:0"][0] # VI = [v for v in tf.global_variables() if v.name == "gene/GEN_L004/add_Mult2DMCyCSharedOverFeat_weightI:0"][0] # VRX=td.sess.run(VR); # VIX=td.sess.run(VI); # VC=VRX+1J*VIX # Norm=np.abs(VC) # Norm[Norm == 0] = 0.00001 # VRX=VRX/Norm # VIX=VIX/Norm # VR.load(VRX, td.sess) # VI.load(VIX, td.sess) # VR = [v for v in tf.global_variables() if v.name == "gene/GEN_L005/add_Mult2DMCxCSharedOverFeat_weightR:0"][0] # VI = [v for v in tf.global_variables() if v.name == "gene/GEN_L005/add_Mult2DMCxCSharedOverFeat_weightI:0"][0] # VRX=td.sess.run(VR); # VIX=td.sess.run(VI); # VC=VRX+1J*VIX # Norm=np.abs(VC) # Norm[Norm == 0] = 0.00001 # VRX=VRX/Norm # VIX=VIX/Norm # VR.load(VRX, td.sess) # VI.load(VIX, td.sess) # VR = [v for v in tf.global_variables() if v.name == "gene/GEN_L004/einsum_weightR:0"][0] # VI = [v for v in tf.global_variables() if v.name == "gene/GEN_L004/einsum_weightI:0"][0] # VRX=td.sess.run(VR); # VIX=td.sess.run(VI); # HmngWnd=np.power(np.hamming(98),1) # HmngWnd=np.reshape(HmngWnd,[98,1,1]) # VC=VRX +1j*VIX # FVC=GT.gfft(VC,dim=0) # FVC=FVC*HmngWnd # VC=GT.gifft(FVC,dim=0) # VYR=np.real(VC) # VYI=np.imag(VC) # VR.load(VYR, td.sess) # VI.load(VYI, td.sess) if batch % 10 == 0: # pdb.set_trace() # Show we are alive #print('Progress[%3d%%], ETA[%4dm], Batch [%4d], G_Loss[%3.3f], D_Real_Loss[%3.3f], D_Fake_Loss[%3.3f]' % # (int(100*elapsed/train_time), train_time - int(elapsed), batch, gene_loss, disc_real_loss, disc_fake_loss)) print( 'Progress[%3d%%], ETA[%4dm], Batch [%4d], G_Loss[%3.3f], D_Real_Loss[%3.3f], D_Fake_Loss[%3.3f], MoreOut[%3.3f, %3.3f, %3.3f]' % (int(100 * elapsed / train_time), train_time - int(elapsed), batch, gene_loss, disc_real_loss, disc_fake_loss, MoreOut, MoreOut2, MoreOut3)) # VLen=td.gene_var_list.__len__() # for i in range(0, VLen): # print(td.gene_var_list[i].name); # print(VRX.dtype) # print(VRX) # exit() # var_23 = [v for v in tf.global_variables() if v.name == "gene/GEN_L020/C2D_weight:0"][0] # tmp=td.sess.run(td.gene_var_list[i]) # v.load([2, 3], td.sess) if np.isnan(gene_loss): print('NAN!!') done = True # ggg: quick failure test if elapsed > QuickFailureTimeM: if gene_loss > QuickFailureThresh: print('Quick failure!!') done = True else: QuickFailureTimeM = 10000000 # Finished? current_progress = elapsed / train_time if current_progress >= 1.0: done = True StopFN = '/media/a/f38a5baa-d293-4a00-9f21-ea97f318f647/home/a/TF/stop.a' if os.path.isfile(StopFN): print('Stop file used!!') done = True try: tf.gfile.Remove(StopFN) except: pass # Update learning rate # if batch % FLAGS.learning_rate_half_life == 0: # lrval *= .5 # if batch % FLAGS.summary_period == 0: if (CurTime - last_summary_time) / 60 > summary_period: # Show progress with test features # feed_dict = {td.gene_minput: test_feature} gene_output = td.sess.run(td.gene_moutput, feed_dict=feed_dictOut) if myParams.myDict['ShowRealData'] > 0: gene_RealOutput = td.sess.run(td.gene_moutput, feed_dict=Real_dictOut) gene_output[0] = gene_RealOutput[0] Asuffix = 'out_%06.4f' % (gene_loss) _summarize_progress(td, test_label, gene_output, batch, Asuffix) last_summary_time = time.time() # if batch % FLAGS.checkpoint_period == 0: SaveCheckpoint_ByTime = (CurTime - last_checkpoint_time) / 60 > checkpoint_period CheckpointFN = '/media/a/f38a5baa-d293-4a00-9f21-ea97f318f647/home/a/TF/save.a' SaveCheckPointByFile = os.path.isfile(CheckpointFN) if SaveCheckPointByFile: tf.gfile.Remove(CheckpointFN) if SaveCheckpoint_ByTime or SaveCheckPointByFile: last_checkpoint_time = time.time() # Save checkpoint _save_checkpoint(td, batch, G_LossV, saver) RunOnAllFN = '/media/a/f38a5baa-d293-4a00-9f21-ea97f318f647/home/a/TF/RunOnAll.a' RunOnAllFNByFile = os.path.isfile(RunOnAllFN) if RunOnAllFNByFile: tf.gfile.Remove(RunOnAllFN) for r in range(1, 81): ifilenamePrefix = myParams.myDict['LoadAndRunOnData_Prefix'] # ifilename=ifilenamePrefix + f'{r:02}' + '.mat' ifilename = ifilenamePrefix + '%02d.mat' % (r) RealData = scipy.io.loadmat(ifilename) RealData = RealData['Data'] if RealData.ndim == 2: RealData = RealData.reshape( (RealData.shape[0], RealData.shape[1], 1, 1)) if RealData.ndim == 3: RealData = RealData.reshape( (RealData.shape[0], RealData.shape[1], RealData.shape[2], 1)) Real_feature = RealData if myParams.myDict[ 'InputMode'] == 'RegridTry1' or myParams.myDict[ 'InputMode'] == 'RegridTry2': # FullData=scipy.io.loadmat('/media/a/f38a5baa-d293-4a00-9f21-ea97f318f647/home/a/TF/NMapIndTesta.mat') FullData = scipy.io.loadmat(myParams.myDict['NMAP_FN']) NMapCR = FullData['NMapCR'] batch_size = myParams.myDict['batch_size'] Real_feature = np.reshape(RealData[0], [RealData.shape[1]]) Real_feature = np.take(Real_feature, NMapCR) Real_feature = np.tile(Real_feature, (batch_size, 1, 1, 1)) Real_dictOut = {td.gene_minput: Real_feature} gene_RealOutput = td.sess.run(td.gene_moutput, feed_dict=Real_dictOut) OnRealData = {} OnRealDataM = gene_RealOutput # filenamex = 'OnRealData' + f'{r:02}' + '.mat' filenamex = 'OnRealData' + '%02d.mat' % (r) LoadAndRunOnData_OutP = myParams.myDict[ 'LoadAndRunOnData_OutP'] filename = os.path.join(LoadAndRunOnData_OutP, filenamex) OnRealData['x'] = OnRealDataM scipy.io.savemat(filename, OnRealData) print('Saved recon of real data') _save_checkpoint(td, batch, G_LossV, saver) print('Finished training!')
def complex(x, y): return x + np.complex64(1j) * y
def conj(x): return np.conj(x) + np.complex64(0)
def test_numpy_scalar_complex(self): x = np.complex64(np.random.rand() + 1j * np.random.rand()) x_rec = self.encode_decode(x) assert_equal(x, x_rec) assert_equal(type(x), type(x_rec))
def GiveModelTessel(self, Image, DicoImager, iFacet, NormIm, Sphe, SpacialWeight, ToGrid=False, ChanSel=None, ApplyNorm=True): nch, npol, NPixOut, _ = Image.shape N1 = DicoImager[iFacet]["NpixFacetPadded"] N1NonPadded = DicoImager[iFacet]["NpixFacetPadded"] dx = (N1 - N1NonPadded) // 2 xc, yc = DicoImager[iFacet]["pixCentral"] #x0,x1,y0,y1=DicoImager[iFacet]["pixExtent"] #xc,yc=(x0+x1)//2,(y0+y1)//2 Aedge, Bedge = GiveEdges(xc, yc, NPixOut, N1 // 2, N1 // 2, N1) #Bedge,Aedge=GiveEdges(N1//2,N1//2,N1,yc,xc,NPixOut) x0d, x1d, y0d, y1d = Aedge x0p, x1p, y0p, y1p = Bedge #print "xxA:",x0d,x1d #print "xxB:",x0p,x1p SumFlux = 1. ModelIm = np.zeros((nch, npol, N1, N1), dtype=np.float32) T = ClassTimeIt.ClassTimeIt("ClassImToGrid") T.disable() if ChanSel is None: CSel = range(nch) else: CSel = ChanSel SumFlux = 0 for ch in CSel: for pol in range(npol): #ModelIm[ch,pol][x0p:x1p,y0p:y1p]=Image[ch,pol].T[::-1,:].real[x0d:x1d,y0d:y1d] #ModelIm[ch,pol][x0p:x1p,y0p:y1p]=Image[ch,pol].real[x0d:x1d,y0d:y1d] ModelIm[ch, pol][x0p:x1p, y0p:y1p] = Image[ch, pol][x0d:x1d, y0d:y1d].real if (ModelIm[ch, pol] == 0).all(): continue T.timeit("0") M = ModelIm[ch, pol][dx:dx + N1NonPadded + 1, dx:dx + N1NonPadded + 1].copy() T.timeit("1") ModelIm[ch, pol].fill(0) T.timeit("2") ModelIm[ch, pol][dx:dx + N1NonPadded + 1, dx:dx + N1NonPadded + 1] = M[:, :] #ModelCutOrig=ModelIm[ch,pol].copy() T.timeit("3") #ind =np.where(np.abs(ModelIm)==np.max(np.abs(ModelIm))) ##print "!!!!!!!!!!!!!!!!!!!!!!" if ApplyNorm: # #print NormIm.max() # #print np.count_nonzero(np.isnan(NormIm)) # #print np.count_nonzero(np.isinf(NormIm)) # print NormIm.min() # np.save("NormIm",NormIm) # stop ModelIm[ch, pol][x0p:x1p, y0p:y1p] /= NormIm[x0d:x1d, y0d:y1d].real #ModelCutOrig_GNorm=NormIm[x0d:x1d,y0d:y1d].real.copy() T.timeit("4") if ApplyNorm: ModelIm[ch, pol][x0p:x1p, y0p:y1p] *= SpacialWeight[x0p:x1p, y0p:y1p] indPos = np.where(ModelIm[ch, pol] > 0) SumFlux += np.sum(ModelIm[ch, pol][indPos]) ModelCutOrig_SW = SpacialWeight[x0p:x1p, y0p:y1p].copy() #ModelCutOrig_GNorm_SW_Sphe_CorrT=ModelIm[ch,pol].copy() T.timeit("5") #SumFlux=np.sum(ModelIm) if ApplyNorm: ModelIm[ch, pol][x0p:x1p, y0p:y1p] /= Sphe[x0p:x1p, y0p:y1p].real # ModelIm[ch, pol][x0p:x1p, y0p:y1p] *= ModelCutOrig_SW / Sphe[x0p:x1p, # y0p:y1p].real # LB - added *SW #ModelCutOrig_Sphe=Sphe[x0p:x1p,y0p:y1p].real.copy() T.timeit("6") ModelIm[ch, pol][Sphe < 1e-3] = 0 T.timeit("7") ModelIm[ch, pol] = ModelIm[ch, pol].T[::-1, :] T.timeit("8") #ModelCutOrig_GNorm_SW_Sphe_CorrT=ModelIm[ch,pol].copy() #return True, ModelCutOrig, ModelCutOrig_GNorm, ModelCutOrig_SW, ModelCutOrig_Sphe, ModelCutOrig_GNorm_SW_Sphe_CorrT #print iFacet,DicoImager[iFacet]["l0m0"],DicoImager[iFacet]["NpixFacet"],DicoImager[iFacet]["NpixFacetPadded"],SumFlux # if np.max(np.abs(ModelIm))>1: # print ind #if np.abs(SumFlux)>1: stop # #print iFacet,np.max(ModelIm) # #return ModelIm, None # #Padding=self.GD["Image"]["Padding"] T.timeit("9") SumFlux /= nch if ToGrid: ModelIm *= (self.OverS * N1)**2 if SumFlux != 0: Grid = np.complex64( self.FFTWMachine.fft(np.complex64(ModelIm), ChanList=CSel)) else: Grid = np.complex64(ModelIm) return Grid, SumFlux elif ApplyNorm: ModelIm *= (self.OverS * N1)**2 return ModelIm, SumFlux else: return ModelIm, SumFlux
def energy_density(k, x1, x2, x3): # If there is a multiple root or branch point a value of maxint-1 will be returned; maxint is globally set. try: if (is_awc_multiple_root(k, x1, x2, x3) ): return -1 if (is_awc_branch_point(k, x1, x2, x3) ): return -2 zeta = calc_zeta(k ,x1, x2, x3) eta = calc_eta(k, x1, x2, x3) abel = calc_abel(k, zeta, eta) mu = calc_mu(k, x1, x2, x3, zeta, abel) x=[x1,x2,x3] K = complex64(ellipk(k**2)) E = complex64(ellipe(k**2)) cm= (2*E-K)/K k1 = sqrt(1-k**2) xp = x[0]+complex(0,1)*x[1] xm = x[0]-complex(0,1)*x[1] S = sqrt(K**2-4*xp*xm) SP = sqrt(K**2-4*xp**2) SM = sqrt(K**2-4*xm**2) SPM = sqrt(-k1**2*(K**2*k**2-4*xm*xp)+(xm-xp)**2) R = 2*K**2*k1**2-S**2-8*x[2]**2 RM = complex(0,1)*SM**2*(xm*(2*k1**2-1)+xp)-(16*complex(0,1))*xm*x[2]**2 RP = complex(0,1)*SM**2*(xp*(2*k1**2-1)+xm)+(16*complex(0,1))*xp*x[2]**2 RMBAR=-complex(0,1)*SP**2*( xp*(2*k1**2-1)+xm ) +16*complex(0,1)*xp*x[2]**2 RPBAR=-complex(0,1)*SP**2*( xm*(2*k1**2-1)+xp ) -16*complex(0,1)*xm*x[2]**2 r=sqrt(x[0]**2+x[1]**2+x[2]**2) DM = dmus(zeta, x, k) DZ = dzetas(zeta, x,k) DDM = ddmus(zeta, x, k) DDZ = ddzetas(zeta, x,k) GNUM = grams(zeta, mu, [x1, x2, x3], k) inv_gram = matrix(GNUM).I higgs = phis(zeta, mu, [x1, x2, x3], k) DGS1 = dgrams1(zeta, mu, DM, DZ, x, k) DGS2 = dgrams2(zeta, mu, DM, DZ, x, k) DGS3 = dgrams3(zeta, mu, DM, DZ, x, k) # Using the hermiticity properties its faster to evaluate the matrix entries just once and so if we evaluate # the *12 element the *21 is minus the conjugate of this # DHS1 = mat([[ dphis111(zeta, mu, DM, DZ, [x1, x2, x3], k), dphis112(zeta, mu, DM, DZ, [x1, x2, x3], k)], # [ dphis121(zeta, mu, DM, DZ, [x1, x2, x3], k), dphis122(zeta, mu, DM, DZ, [x1, x2, x3], k)]]) DH112 = dphis112(zeta, mu, DM, DZ, [x1, x2, x3], k) DHS1 = mat([[ dphis111(zeta, mu, DM, DZ, [x1, x2, x3], k), DH112 ], [ -conj(DH112), dphis122(zeta, mu, DM, DZ, [x1, x2, x3], k)]]) DH212 = dphis212(zeta, mu, DM, DZ, [x1, x2, x3], k) DHS2 = mat([[ dphis211(zeta, mu, DM, DZ, [x1, x2, x3], k), DH212 ], [ -conj(DH212), dphis222(zeta, mu, DM, DZ, [x1, x2, x3], k)]]) DH312 = dphis312(zeta, mu, DM, DZ, [x1, x2, x3], k) DHS3 = mat([[ dphis311(zeta, mu, DM, DZ, [x1, x2, x3], k), DH312 ], [ -conj(DH312), dphis322(zeta, mu, DM, DZ, [x1, x2, x3], k)]]) DDGS112 = ddgrams112(zeta, mu, DM, DZ, DDM, DDZ, [x1, x2, x3], k) DDGS1 = mat([[ ddgrams111(zeta, mu, DM, DZ, DDM, DDZ, [x1, x2, x3], k), DDGS112 ], [ -conj(DDGS112), ddgrams122(zeta, mu, DM, DZ, DDM, DDZ, [x1, x2, x3], k)]]) DDGS212 = ddgrams212(zeta, mu, DM, DZ, DDM, DDZ, [x1, x2, x3], k) DDGS2 = mat([[ ddgrams211(zeta, mu, DM, DZ, DDM, DDZ, [x1, x2, x3], k), DDGS212 ], [ -conj(DDGS212) , ddgrams222(zeta, mu, DM, DZ, DDM, DDZ, [x1, x2, x3], k)]]) DDGS312 = ddgrams312(zeta, mu, DM, DZ, DDM, DDZ, [x1, x2, x3], k) DDGS3 = mat([[ ddgrams311(zeta, mu, DM, DZ, DDM, DDZ, [x1, x2, x3], k), DDGS312 ], [ -conj(DDGS312), ddgrams322(zeta, mu, DM, DZ, DDM, DDZ, [x1, x2, x3], k)]]) DDHS111 = ddphis111(zeta, mu,DM, DZ, DDM, DDZ, [x1, x2, x3], k) DDHS112 = ddphis112(zeta, mu,DM, DZ, DDM, DDZ, [x1, x2, x3], k) # DDHS121 = ddphis121(zeta, mu,DM, DZ, DDM, DDZ, [x1, x2, x3], k) DDHS122 = ddphis122(zeta, mu,DM, DZ, DDM, DDZ, [x1, x2, x3], k) DDHS1 = mat( [[DDHS111, DDHS112], [ -conj(DDHS112),DDHS122]]) DDHS211 = ddphis211(zeta, mu,DM, DZ, DDM, DDZ, [x1, x2, x3], k) DDHS212 = ddphis212(zeta, mu,DM, DZ, DDM, DDZ, [x1, x2, x3], k) # DDHS221 = ddphis221(zeta, mu,DM, DZ, DDM, DDZ, [x1, x2, x3], k) DDHS222 = ddphis222(zeta, mu,DM, DZ, DDM, DDZ, [x1, x2, x3], k) DDHS2 = mat( [[DDHS211, DDHS212], [-conj(DDHS212),DDHS222]]) DDHS311 = ddphis311(zeta, mu,DM, DZ, DDM, DDZ, [x1, x2, x3], k) DDHS312 = ddphis312(zeta, mu,DM, DZ, DDM, DDZ, [x1, x2, x3], k) # DDHS321 = ddphis321(zeta, mu,DM, DZ, DDM, DDZ, [x1, x2, x3], k) DDHS322 = ddphis322(zeta, mu, DM, DZ, DDM, DDZ, [x1, x2, x3], k) DDHS3 = mat( [[DDHS311, DDHS312], [-conj(DDHS312),DDHS322]]) ed1 = trace(matmul( matmul(DDHS1, inv_gram) -2* matmul( matmul(DHS1 , inv_gram), matmul(DGS1, inv_gram)) \ + matmul(higgs, matmul( 2* matmul(matmul(inv_gram,DGS1), matmul(inv_gram, DGS1)), inv_gram) - matmul(matmul(inv_gram, DDGS1), inv_gram)), matmul(higgs,inv_gram)) ) \ + trace( matmul(matmul(DHS1, inv_gram) - matmul(matmul(higgs, inv_gram), matmul(DGS1, inv_gram)), matmul(DHS1, inv_gram) - matmul(matmul(higgs, inv_gram), matmul(DGS1, inv_gram)))) ed2 = trace(matmul( matmul(DDHS2, inv_gram) -2* matmul( matmul(DHS2 , inv_gram), matmul(DGS2, inv_gram)) \ + matmul(higgs, matmul( 2* matmul(matmul(inv_gram,DGS2), matmul(inv_gram, DGS2)), inv_gram) - matmul(matmul(inv_gram, DDGS2), inv_gram)), matmul(higgs,inv_gram)) ) \ + trace( matmul(matmul(DHS2, inv_gram) - matmul(matmul(higgs, inv_gram), matmul(DGS2, inv_gram)), matmul(DHS2, inv_gram) - matmul(matmul(higgs, inv_gram), matmul(DGS2, inv_gram)))) ed3 = trace(matmul( matmul(DDHS3, inv_gram) -2* matmul( matmul(DHS3 , inv_gram), matmul(DGS3, inv_gram)) \ + matmul(higgs, matmul( 2* matmul(matmul(inv_gram,DGS3), matmul(inv_gram, DGS3)), inv_gram) - matmul(matmul(inv_gram, DDGS3), inv_gram)), matmul(higgs,inv_gram)) ) \ + trace( matmul(matmul(DHS3, inv_gram) - matmul(matmul(higgs, inv_gram), matmul(DGS3, inv_gram)), matmul(DHS3, inv_gram) - matmul(matmul(higgs, inv_gram), matmul(DGS3, inv_gram)))) # energy_density = -(ed1 + ed2 + ed3).real return -(ed1 + ed2 + ed3).real except: return -3
def _train(): # LoadAndRunOnData=False LoadAndRunOnData = myParams.myDict['LoadAndRunOnData'] > 0 if LoadAndRunOnData: # Setup global tensorflow state sess, summary_writer = setup_tensorflow() # Prepare directories # filenames = prepare_dirs(delete_train_dir=False) # Setup async input queues # features, labels = srez_input.setup_inputs(sess, filenames) features, labels = srez_input.setup_inputs(sess, 1) # Create and initialize model [gene_minput, gene_moutput, gene_output, gene_var_list, disc_real_output, disc_fake_output, disc_var_list] = \ srez_modelBase.create_model(sess, features, labels) # Restore variables from checkpoint print("Adding to saver:") var_listX = gene_var_list var_listX = [v for v in var_listX if "Bank" not in v.name] for line in var_listX: print("Adding " + line.name + ' ' + str(line.shape.as_list())) print("Saver var list end") saver = tf.train.Saver(var_listX) # saver = tf.train.Saver() filename = 'checkpoint_new' # filename = os.path.join('/media/a/f38a5baa-d293-4a00-9f21-ea97f318f647/home/a/TF/srez/RegridTry1C2_TS2_dataNeighborhoodRCB0__2018-06-08_16-17-56_checkpoint', filename) # filename = os.path.join('/media/a/f38a5baa-d293-4a00-9f21-ea97f318f647/home/a/TF/srez/RegridTry1C2_TS2_dataNeighborhoodRCB0__2018-06-09_19-44-17_checkpoint', filename) # filename = os.path.join('/media/a/f38a5baa-d293-4a00-9f21-ea97f318f647/home/a/TF/srez/RegridTry1C2_TS__2018-06-29_10-39-13_checkpoint', filename) checkpointP = myParams.myDict['LoadAndRunOnData_checkpointP'] filename = os.path.join(checkpointP, filename) saver.restore(sess, filename) if myParams.myDict['Mode'] == 'RegridTry1' or myParams.myDict[ 'Mode'] == 'RegridTry1C' or myParams.myDict[ 'Mode'] == 'RegridTry1C2' or myParams.myDict[ 'Mode'] == 'RegridTry1C2_TS' or myParams.myDict[ 'Mode'] == 'RegridTry1C2_TS2': FullData = scipy.io.loadmat(myParams.myDict['NMAP_FN']) NMapCR = FullData['NMapCR'] for r in range(1, myParams.myDict['HowManyToRun']): # ifilename='/media/a/f38a5baa-d293-4a00-9f21-ea97f318f647/home/a/TF/srez/RealData/b_Ben14May_Sli5_r' + f'{r:02}' + '.mat' # ifilename='/media/a/DATA/14May18/Ben/meas_MID109_gBP_VD11_U19_4min_FID17944/RealData/Sli11_r' + f'{r:02}' + '.mat' if myParams.myDict['InputMode'] == 'Cart3SB': # print('Loaded SensMaps, Shape %d %d %d %d' % (SensMapsSz[0],SensMapsSz[1],SensMapsSz[2],SensMapsSz[3])) print('Cart3SB running on real data %d' % r) # feature shape: (1048576, 1, 1) <dtype: 'float32'> batch_size = myParams.myDict['batch_size'] # RealData=np.zeros((batch_size,1048576, 1, 1),np.float32) # RealData=np.zeros((batch_size,640000, 1, 1),np.float32) # Simulating RealData from ITS, Sens MB = GT.getparam('MB') TimePoints_ms = GT.getparam('TimePoints_ms') nTSC = TimePoints_ms.shape[0] nCh = GT.getparam('nccToUse') LabelsH = myParams.myDict['LabelsH'] LabelsW = myParams.myDict['LabelsW'] H = LabelsH W = LabelsW SnsFN = '/opt/data/CCSensMaps.mat' fS = h5py.File(SnsFN, 'r') SensMaps = fS['SensCC'] SensMaps = SensMaps['real'] + 1j * SensMaps['imag'] SensMapsSz = SensMaps.shape print('r Loaded SensMaps, Shape %d %d %d %d' % (SensMapsSz[0], SensMapsSz[1], SensMapsSz[2], SensMapsSz[3])) SensMaps = SensMaps[:, :, :, :nCh] NumSensMapsInFile = SensMaps.shape[0] # IdxS=15 for b in range(0, MB): # if b==1: # IdxB2=tf.random_uniform([1],minval=12,maxval=19,dtype=tf.int32) # IdxS=IdxS+IdxB2[0] # IdxS=tf.cond(IdxS[0]>=NumSensMapsInFile, lambda: IdxS-NumSensMapsInFile, lambda: IdxS) # Sens=np.squeeze(SensMaps[IdxS,:,:,:],axis=0) Sens = (SensMaps[15, :, :, :]) Sens = Sens[:H, :W, :nCh] # Sens = tf.image.random_flip_left_right(Sens) # Sens = tf.image.random_flip_up_down(Sens) # uS=tf.random_uniform([1]) # Sens=tf.cond(uS[0]<0.5, lambda: tf.identity(Sens), lambda: tf.image.rot90(Sens)) SensMsk = GT.NP_addDim( np.sum(np.abs(Sens), axis=2) > 0).astype(np.complex64) Sens = GT.NP_addDim(Sens) if b == 0: SensMB = Sens SensMskMB = SensMsk # else: # SensMB=tf.concat([SensMB,Sens],axis=3) # SensMB H W nCh MB # SensMskMB=tf.concat([SensMskMB,SensMsk],axis=2) # SensMskMB H W MB # nToLoad=myParams.myDict['nToLoad'] # LoadAndRunOnData=myParams.myDict['LoadAndRunOnData']>0 # if LoadAndRunOnData: nToLoad = 300 print('r loading images ' + time.strftime("%Y-%m-%d %H:%M:%S")) GREBaseP = '/opt/data/' SFN = GREBaseP + 'All_Orientation-0x.mat' f = h5py.File(SFN, 'r') I = f['CurSetAll'][0:nToLoad] print('r Loaded images ' + time.strftime("%Y-%m-%d %H:%M:%S")) SendTSCest = GT.getparam('SendTSCest') > 0 HamPow = GT.getparam('HamPow') # def TFexpix(X): return tf.exp(tf.complex(tf.zeros_like(X),X)) def NPexpix(X): return np.exp(1j * X) for b in range(0, MB): # TFI = tf.constant(np.int16(I)) # Idx=tf.random_uniform([1],minval=0,maxval=I.shape[0],dtype=tf.int32) Idx = 133 Data4 = (I[Idx, :, :, :]) # Data4=tf.squeeze(tf.slice(I,[Idx[0],0,0,0],[1,-1,-1,-1]),axis=0) # Data4 = tf.image.random_flip_left_right(Data4) # Data4 = tf.image.random_flip_up_down(Data4) # u1=tf.random_uniform([1]) # Data4=tf.cond(u1[0]<0.5, lambda: tf.identity(Data4), lambda: tf.image.rot90(Data4)) # Data4 = tf.random_crop(Data4, [H, W, 4]) # Data4 = tf.random_crop(Data4, [:H, :W, 4]) Data4 = Data4[:H, :W, :] # M=tf.slice(Data4,[0,0,0],[-1,-1,1]) # Ph=tf.slice(Data4,[0,0,1],[-1,-1,1]) # feature=tf.cast(M,tf.complex64)*TFexpix(Ph) M = Data4[:, :, 0] Ph = Data4[:, :, 1] feature = M.astype(np.complex64) * NPexpix(Ph) feature = GT.NP_addDim(feature) * SensMskMB[:, :, b:b + 1] T2S_ms = Data4[:, :, 2] # T2S_ms = tf.where( T2S_ms<1.5, 10000 * tf.ones_like( T2S_ms ), T2S_ms ) T2S_ms[T2S_ms < 1.5] = 10000 B0_Hz = Data4[:, :, 3] # B0_Hz=M*0 # T2S_ms = tf.where( tf.is_nan(T2S_ms), 10000 * tf.ones_like( T2S_ms ), T2S_ms ) T2S_ms[np.isnan(T2S_ms)] = 10000 # B0_Hz = tf.where( tf.is_nan(B0_Hz), tf.zeros_like( B0_Hz ), B0_Hz ) B0_Hz[np.isnan(B0_Hz)] = 0 if SendTSCest: # HamPowA=10 HamPowA = HamPow HamA = np.roll(np.hamming(H), np.int32(H / 2)) HamA = np.power(HamA, HamPowA) HamXA = np.reshape(HamA, (1, H, 1)) HamYA = np.reshape(HamA, (1, 1, W)) B0_Hz_Smoothed = np.transpose( GT.NP_addDim(B0_Hz.astype(np.complex64)), (2, 0, 1)) B0_Hz_Smoothed = np.fft.fft2(B0_Hz_Smoothed) B0_Hz_Smoothed = B0_Hz_Smoothed * HamXA B0_Hz_Smoothed = B0_Hz_Smoothed * HamYA B0_Hz_Smoothed = np.fft.ifft2(B0_Hz_Smoothed) B0_Hz_Smoothed = np.transpose(B0_Hz_Smoothed, (1, 2, 0)) B0_Hz_Smoothed = np.real(B0_Hz_Smoothed) TSCest = np.exp(1j * 2 * np.pi * (B0_Hz_Smoothed * TimePoints_ms / 1000).astype(np.complex64)) # TSCest=np.ones(TSCest.shape).astype(np.complex64) print('TSCest shape: ' + str(TSCest.shape)) # TSCest=TSCest*0+1 # print('TSCest shape: ' + str(TSCest.shape)) # print('reducing B0') # print('B0_Hz shape: ' + str(B0_Hz.shape)) # print('B0_Hz_Smoothed shape: ' + str(B0_Hz_Smoothed.shape)) # B0_Hz=B0_Hz-np.squeeze(B0_Hz_Smoothed) # print('B0_Hz shape: ' + str(B0_Hz.shape)) # urand_ms=tf.random_uniform([1])*12 # urand_sec=(tf.random_uniform([1])*2-1)*3/1000 # feature=feature*tf.cast(tf.exp(-urand_ms/T2S_ms),tf.complex64) # feature=feature*TFexpix(2*np.pi*B0_Hz*urand_sec) mx = M.max() mx = np.maximum(mx, 1) mx = mx.astype(np.complex64) feature = feature / mx CurIWithPhase = feature TSCM = np.exp(-TimePoints_ms / GT.NP_addDim(T2S_ms)) TSCP = np.exp(1j * 2 * np.pi * (GT.NP_addDim(B0_Hz) * TimePoints_ms / 1000).astype(np.complex64)) TSC = TSCM.astype(np.complex64) * TSCP ITSbase = CurIWithPhase * TSC # ITSbase is H,W,nTSC TSC = GT.NP_addDim(TSC) ITSbase = GT.NP_addDim(ITSbase) if b == 0: CurIWithPhaseMB = CurIWithPhase TSCMB = TSC ITSbaseMB = ITSbase if SendTSCest: TSCest = GT.NP_addDim(TSCest) TSCMBest = TSCest # else: # CurIWithPhaseMB=tf.concat([CurIWithPhaseMB,CurIWithPhase],axis=2) # CurIWithPhaseMB H W MB # TSCMB=tf.concat([TSCMB,TSC],axis=3) # TSCMB H W nTSC MB # ITSbaseMB=tf.concat([ITSbaseMB,ITSbase],axis=3) # ITSbaseMB H W nTSC MB # if SendTSCest: # TSCMBest=tf.stack([TSCMBest,TSCest],axis=3) print('r ok 2') ITS_P = np.transpose( GT.NP_addDim(ITSbaseMB), (4, 0, 1, 2, 3)) # /batch_size/,H,W,nTSC,MB Msk3 = np.zeros((H, W, nTSC, 1, 1, 1)) PEShifts = GT.getparam('PEShifts') PEJump = GT.getparam('PEJump') print('r Using PEShifts') for i in range(nTSC): Msk3[PEShifts[i]::PEJump, :, i, :, :, :] = 1 Msk3 = np.complex64(Msk3) # GT.setparam('CartMask',Msk3) Sens6 = SensMB[:, :, np.newaxis, :, :, np.newaxis] # H,W,/nTS/,nCh,MB,/batch_size/ # AHA_ITS=GT.Cartesian_OPHOP_ITS_MB(ITS_P,Sens6,Msk3) ITS = np.transpose(ITSbaseMB, (0, 3, 2, 1)) # H, nTSC, W ITS = np.reshape(ITS, (H, W * nTSC * MB, 1)) ITS_RI = GT.NP_ConcatRIOn2(ITS) Sensc = SensMB Sens1D = GT.NP_ConcatRIOn0(np.reshape(Sensc, (-1, 1, 1))) feature = Sens1D AHA_ITS = GT.NP_Cartesian_OPHOP_ITS_MB(ITS_P, Sens6, Msk3) # new simpler approach if SendTSCest: TSCMBest_P = np.transpose( GT.NP_addDim(TSCMBest), (4, 0, 1, 2, 3)) # /batch_size/,H,W,nTSC,MB AHA_ITS = AHA_ITS * np.conj(TSCMBest_P) # send AHA_ITS AHA_ITS_1D = GT.NP_ConcatRIOn0(np.reshape(AHA_ITS, (-1, 1, 1))) feature = np.concatenate((feature, AHA_ITS_1D), axis=0) if SendTSCest: TSCest1D = GT.NP_ConcatRIOn0( np.reshape(TSCMBest_P, (-1, 1, 1))) feature = np.concatenate((feature, TSCest1D), axis=0) RealData = np.tile(feature, (batch_size, 1, 1, 1)) # End simulating RealData Real_feature = RealData else: ifilenamePrefix = myParams.myDict['LoadAndRunOnData_Prefix'] # ifilename=ifilenamePrefix + f'{r:02}' + '.mat' ifilename = ifilenamePrefix + '%02d.mat' % (r) RealData = scipy.io.loadmat(ifilename) RealData = RealData['Data'] if RealData.ndim == 2: RealData = RealData.reshape( (RealData.shape[0], RealData.shape[1], 1, 1)) if RealData.ndim == 3: RealData = RealData.reshape( (RealData.shape[0], RealData.shape[1], RealData.shape[2], 1)) Real_feature = RealData # if myParams.myDict['Mode'] == 'RegridTry1' or myParams.myDict['Mode'] == 'RegridTry1C' or myParams.myDict['Mode'] == 'RegridTry1C2' or myParams.myDict['Mode'] == 'RegridTry1C2_TS' or myParams.myDict['Mode'] == 'RegridTry1C2_TS2': # batch_size=myParams.myDict['batch_size'] # Real_feature=np.reshape(RealData[0],[RealData.shape[1]]) # Real_feature=np.take(Real_feature,NMapCR) # Real_feature=np.tile(Real_feature, (batch_size,1,1,1)) if myParams.myDict['InputMode'] == 'RegridTry1' or myParams.myDict[ 'InputMode'] == 'RegridTry2': # FullData=scipy.io.loadmat('/media/a/f38a5baa-d293-4a00-9f21-ea97f318f647/home/a/TF/NMapIndTesta.mat') FullData = scipy.io.loadmat(myParams.myDict['NMAP_FN']) NMapCR = FullData['NMapCR'] batch_size = myParams.myDict['batch_size'] Real_feature = np.reshape(RealData[0], [RealData.shape[1]]) Real_feature = np.take(Real_feature, NMapCR) Real_feature = np.tile(Real_feature, (batch_size, 1, 1, 1)) Real_dictOut = {gene_minput: Real_feature} gene_RealOutput = sess.run(gene_moutput, feed_dict=Real_dictOut) OnRealData = {} OnRealDataM = gene_RealOutput # filenamex = 'OnRealData' + f'{r:02}' + '.mat' filenamexBase = 'OnRealData' + '%02d' % (r) filenamex = filenamexBase + '.mat' LoadAndRunOnData_OutP = myParams.myDict['LoadAndRunOnData_OutP'] filename = os.path.join(LoadAndRunOnData_OutP, filenamex) OnRealData['x'] = OnRealDataM scipy.io.savemat(filename, OnRealData) image = np.sqrt( np.square(OnRealDataM[0, -H:, :(W * 3), 0]) + np.square(OnRealDataM[0, -H:, :(W * 3), 1])) filenamep = filenamexBase + '.png' filename = os.path.join(LoadAndRunOnData_OutP, filenamep) imageio.imwrite(filename, image) print('Saved recon of real data') exit() # Setup global tensorflow state sess, summary_writer = setup_tensorflow() # Prepare directories all_filenames = prepare_dirs(delete_train_dir=True) # Separate training and test sets #train_filenames = all_filenames[:-FLAGS.test_vectors] train_filenames = all_filenames #test_filenames = all_filenames[-FLAGS.test_vectors:] # TBD: Maybe download dataset here #pdb.set_trace() # ggg Signal Bank stuff: if myParams.myDict['BankSize'] > 0: if myParams.myDict['InputMode'] == 'RegridTry3FMB': BankSize = myParams.myDict['BankSize'] * 2 # BankInit=np.zeros([BankSize,myParams.myDict['DataH'],1,1]) # LBankInit=np.zeros([BankSize,myParams.myDict['LabelsH'],myParams.myDict['LabelsW'], 2]) with tf.variable_scope("aaa"): Bank = tf.get_variable( "Bank", shape=[BankSize, myParams.myDict['DataH'], 1, 1], dtype=tf.float32, trainable=False) LBank = tf.get_variable("LBank", shape=[ BankSize, myParams.myDict['LabelsH'], myParams.myDict['LabelsW'], 2 ], dtype=tf.float32, trainable=False) # LBank=tf.get_variable("LBank",initializer=tf.cast(LBankInit, tf.float32),dtype=tf.float32,trainable=False) else: BankSize = myParams.myDict['BankSize'] BankInit = np.zeros([BankSize, myParams.myDict['DataH'], 1, 1]) LBankInit = np.zeros([ BankSize, myParams.myDict['LabelsH'], myParams.myDict['LabelsW'], 2 ]) with tf.variable_scope("aaa"): # Bank=tf.get_variable("Bank",initializer=tf.cast(BankInit, tf.float32),dtype=tf.float32) Bank = tf.get_variable( "Bank", shape=[BankSize, myParams.myDict['DataH'], 1, 1], dtype=tf.float32, trainable=False) LBank = tf.get_variable("LBank", shape=[ BankSize, myParams.myDict['LabelsH'], myParams.myDict['LabelsW'], 2 ], dtype=tf.float32, trainable=False) # LBank=tf.get_variable("LBank",initializer=tf.cast(LBankInit, tf.float32),dtype=tf.float32) init_new_vars_op = tf.variables_initializer([Bank, LBank]) sess.run(init_new_vars_op) # ggg end Signal Bank stuff: # Setup async input queues train_features, train_labels = srez_input.setup_inputs( sess, train_filenames) # test_features, test_labels = srez_input.setup_inputs(sess, train_filenames,TestStuff=True) test_features = train_features test_labels = train_labels #test_features, test_labels = srez_input.setup_inputs(sess, test_filenames) print('starting' + time.strftime("%Y-%m-%d %H:%M:%S")) print('train_features %s' % (train_features)) print('train_labels %s' % (train_labels)) # Add some noise during training (think denoising autoencoders) noise_level = myParams.myDict['noise_level'] AddNoise = noise_level > 0.0 if AddNoise: noisy_train_features = train_features + tf.random_normal( train_features.get_shape(), stddev=noise_level) else: noisy_train_features = train_features # Create and initialize model [gene_minput, gene_moutput, gene_output, gene_var_list, disc_real_output, disc_fake_output, disc_var_list] = \ srez_modelBase.create_model(sess, noisy_train_features, train_labels) # gene_VarNamesL=[]; # for line in gene_var_list: gene_VarNamesL.append(line.name+' ' + str(line.shape.as_list())) # gene_VarNamesL.sort() # for line in gene_VarNamesL: print(line) # # var_23 = [v for v in tf.global_variables() if v.name == "gene/GEN_L020/C2D_weight:0"][0] # for line in sess.graph.get_operations(): print(line) # Gen3_ops=[] # for line in sess.graph.get_operations(): # if 'GEN_L003' in line.name: # Gen3_ops.append(line) # # LL=QQQ.outputs[0] # for x in Gen3_ops: print(x.name +' ' + str(x.outputs[0].shape)) # GenC2D_ops= [v for v in sess.graph.get_operations()] # GenC2D_ops= [v for v in tf.get_operations() if "weight" in v.name] # GenC2D_ops= [v for v in GenC2D_ops if "C2D" in v.name] # for x in GenC2D_ops: print(x.name +' ' + str(x.outputs[0].shape)) # for x in GenC2D_ops: print(x.name) AEops = [ v for v in sess.graph.get_operations() if "AE" in v.name and not ("_1/" in v.name) ] # AEops = [v for v in td.sess.graph.get_operations() if "Pixel" in v.name and not ("_1/" in v.name) and not ("opti" in v.name) and not ("Assign" in v.name) and not ("read" in v.name) and not ("Adam" in v.name)] AEouts = [v.outputs[0] for v in AEops] varsForL1 = AEouts # varsForL1=AEouts[0:-1] # varsForL1=AEouts[1:] # for line in sess.graph.get_operations(): # if 'GEN_L003' in line.name: # Gen3_ops.append(line) # # LL=QQQ.outputs[0] # for x in Gen3_ops: print(x.name +' ' + str(x.outputs[0].shape)) print("Vars for l2 loss:") varws = [ v for v in tf.global_variables() if (("weight" in v.name) or ("ConvNet" in v.name)) ] varsForL2 = [v for v in varws if "C2D" in v.name] varsForL2 = [v for v in varws if "disc" not in v.name] varsForL2 = [v for v in varws if "bias" not in v.name] for line in varsForL2: print(line.name + ' ' + str(line.shape.as_list())) print("Vars for Phase-only loss:") varws = [v for v in tf.global_variables() if "weight" in v.name] varsForPhaseOnly = [v for v in varws if "SharedOverFeat" in v.name] for line in varsForPhaseOnly: print(line.name + ' ' + str(line.shape.as_list())) # pdb.set_trace() gene_loss, MoreOut, MoreOut2, MoreOut3 = srez_modelBase.create_generator_loss( disc_fake_output, gene_output, train_features, train_labels, varsForL1, varsForL2, varsForPhaseOnly) disc_real_loss, disc_fake_loss = \ srez_modelBase.create_discriminator_loss(disc_real_output, disc_fake_output) disc_loss = tf.add(disc_real_loss, disc_fake_loss, name='disc_loss') (global_step, learning_rate, gene_minimize, disc_minimize) = \ srez_modelBase.create_optimizers(gene_loss, gene_var_list, disc_loss, disc_var_list) # Train model train_data = TrainData(locals()) #pdb.set_trace() # ggg: to restore session RestoreSession = False if RestoreSession: saver = tf.train.Saver() filename = 'checkpoint_new' filename = os.path.join(myParams.myDict['checkpoint_dir'], filename) saver.restore(sess, filename) srez_train.train_model(train_data)
import os import sys import argparse import datetime as dt import h5py import numpy as np from mintpy.objects import timeseries, geometry, sensor from mintpy.defaults.template import get_template_content from mintpy.utils import ptime, readfile from mintpy import info BOOL_ZERO = np.bool_(0) INT_ZERO = np.int16(0) FLOAT_ZERO = np.float32(0.0) CPX_ZERO = np.complex64(0.0) COMPRESSION = 'lzf' ################################################################ TEMPALTE = TEMPLATE = get_template_content('hdfeos5') EXAMPLE = """example: save_hdfeos5.py geo/geo_timeseries_ERA5_ramp_demErr.h5 save_hdfeos5.py timeseries_ERA5_ramp_demErr.h5 --tc temporalCoherence.h5 --asc avgSpatialCoh.h5 -m maskTempCoh.h5 -g inputs/geometryGeo.h5 """ def create_parser(): parser = argparse.ArgumentParser( description='Convert MintPy timeseries product into HDF-EOS5 format\n' +
def multiply(masname, slvname, outname, rngname, fact, masterFrame, flatten=True, alks=3, rlks=7, virtual=True): masImg = isceobj.createSlcImage() masImg.load(masname + '.xml') width = masImg.getWidth() length = masImg.getLength() if not virtual: master = np.memmap(masname, dtype=np.complex64, mode='r', shape=(length, width)) else: master = loadVirtualArray(masname + '.vrt') slave = np.memmap(slvname, dtype=np.complex64, mode='r', shape=(length, width)) if os.path.exists(rngname): rng2 = np.memmap(rngname, dtype=np.float32, mode='r', shape=(length, width)) else: print('No range offsets provided') rng2 = np.zeros((length, width)) cJ = np.complex64(-1j) #Zero out anytging outside the valid region: ifg = np.memmap(outname, dtype=np.complex64, mode='w+', shape=(length, width)) firstS = masterFrame.firstValidSample lastS = masterFrame.firstValidSample + masterFrame.numValidSamples - 1 firstL = masterFrame.firstValidLine lastL = masterFrame.firstValidLine + masterFrame.numValidLines - 1 for kk in range(firstL, lastL + 1): ifg[kk, firstS:lastS + 1] = master[kk, firstS:lastS + 1] * np.conj( slave[kk, firstS:lastS + 1]) if flatten: phs = np.exp(cJ * fact * rng2[kk, firstS:lastS + 1]) ifg[kk, firstS:lastS + 1] *= phs #### master = None slave = None ifg = None objInt = isceobj.createIntImage() objInt.setFilename(outname) objInt.setWidth(width) objInt.setLength(length) objInt.setAccessMode('READ') objInt.renderHdr() try: takeLooks(objInt, alks, rlks) except: raise Exception('Failed to multilook ifg: {0}'.format(objInt.filename)) return objInt
def test_numpy_scalar_complex(self): x = np.complex64(np.random.rand() + 1j * np.random.rand()) x_rec = self.encode_decode(x) self.assert_(np.allclose(x, x_rec) and type(x) == type(x_rec))
def test_extra_keywords(): beam_in = UVBeam() beam_out = UVBeam() casa_file = os.path.join(DATA_PATH, 'HERABEAM.FITS') testfile = os.path.join(DATA_PATH, 'test/outtest_beam.fits') beam_in.read_beamfits(casa_file, run_check=False) # fill in missing parameters beam_in.data_normalization = 'peak' beam_in.feed_name = 'casa_ideal' beam_in.feed_version = 'v0' beam_in.model_name = 'casa_airy' beam_in.model_version = 'v0' # this file is actually in sine projection RA/DEC at zenith at a particular time. # For now pretend it's in sine projection of az/za beam_in.pixel_coordinate_system = 'sin_zenith' # check for warnings & errors with extra_keywords that are dicts, lists or arrays beam_in.extra_keywords['testdict'] = {'testkey': 23} uvtest.checkWarnings( beam_in.check, message=['testdict in extra_keywords is a ' 'list, array or dict']) nt.assert_raises(TypeError, beam_in.write_beamfits, testfile, run_check=False) beam_in.extra_keywords.pop('testdict') beam_in.extra_keywords['testlist'] = [12, 14, 90] uvtest.checkWarnings( beam_in.check, message=['testlist in extra_keywords is a ' 'list, array or dict']) nt.assert_raises(TypeError, beam_in.write_beamfits, testfile, run_check=False) beam_in.extra_keywords.pop('testlist') beam_in.extra_keywords['testarr'] = np.array([12, 14, 90]) uvtest.checkWarnings( beam_in.check, message=['testarr in extra_keywords is a ' 'list, array or dict']) nt.assert_raises(TypeError, beam_in.write_beamfits, testfile, run_check=False) beam_in.extra_keywords.pop('testarr') # check for warnings with extra_keywords keys that are too long beam_in.extra_keywords['test_long_key'] = True uvtest.checkWarnings(beam_in.check, message=[ 'key test_long_key in extra_keywords ' 'is longer than 8 characters' ]) uvtest.checkWarnings( beam_in.write_beamfits, [testfile], { 'run_check': False, 'clobber': True }, message=[ 'key test_long_key in extra_keywords is longer than 8 characters' ]) beam_in.extra_keywords.pop('test_long_key') # check handling of boolean keywords beam_in.extra_keywords['bool'] = True beam_in.extra_keywords['bool2'] = False beam_in.write_beamfits(testfile, clobber=True) beam_out.read_beamfits(testfile, run_check=False) nt.assert_equal(beam_in, beam_out) beam_in.extra_keywords.pop('bool') beam_in.extra_keywords.pop('bool2') # check handling of int-like keywords beam_in.extra_keywords['int1'] = np.int(5) beam_in.extra_keywords['int2'] = 7 beam_in.write_beamfits(testfile, clobber=True) beam_out.read_beamfits(testfile, run_check=False) nt.assert_equal(beam_in, beam_out) beam_in.extra_keywords.pop('int1') beam_in.extra_keywords.pop('int2') # check handling of float-like keywords beam_in.extra_keywords['float1'] = np.int64(5.3) beam_in.extra_keywords['float2'] = 6.9 beam_in.write_beamfits(testfile, clobber=True) beam_out.read_beamfits(testfile, run_check=False) nt.assert_equal(beam_in, beam_out) beam_in.extra_keywords.pop('float1') beam_in.extra_keywords.pop('float2') # check handling of complex-like keywords beam_in.extra_keywords['complex1'] = np.complex64(5.3 + 1.2j) beam_in.extra_keywords['complex2'] = 6.9 + 4.6j beam_in.write_beamfits(testfile, clobber=True) beam_out.read_beamfits(testfile, run_check=False) nt.assert_equal(beam_in, beam_out)
def main(_): # CHECK-LABEL: TEST: abs int32[] # CHECK: mhlo.abs # CHECK-SAME: tensor<i32> print_ir(np.int32(0))(lax.abs) # CHECK-LABEL: TEST: add float32[] float32[] # CHECK: mhlo.add # CHECK-SAME: tensor<f32> print_ir(np.float32(1), np.float32(2))(lax.add) # CHECK-LABEL: TEST: acos float32[] # CHECK: mhlo.atan2 # CHECK-SAME: tensor<f32> print_ir(np.float32(1))(lax.acos) # CHECK-LABEL: TEST: acosh float32[] # CHECK: chlo.acosh # CHECK-SAME: tensor<f32> print_ir(np.float32(0))(lax.acosh) # CHECK-LABEL: TEST: asin float32[] # CHECK: mhlo.atan2 # CHECK-SAME: tensor<f32> print_ir(np.float32(1))(lax.asin) # CHECK-LABEL: TEST: asinh float32[] # CHECK: chlo.asinh # CHECK-SAME: tensor<f32> print_ir(np.float32(0))(lax.asinh) # CHECK-LABEL: TEST: atan float32[] # CHECK: mhlo.atan2 # CHECK-SAME: tensor<f32> print_ir(np.float32(1))(lax.atan) # CHECK-LABEL: TEST: atanh float32[] # CHECK: chlo.atanh # CHECK-SAME: tensor<f32> print_ir(np.float32(0))(lax.atanh) # CHECK-LABEL: TEST: atan2 float64[] float64[] # CHECK: mhlo.atan2 # CHECK-SAME: tensor<f64> print_ir(np.float64(1), np.float64(2))(lax.atan2) # CHECK-LABEL: TEST: bessel_i0e float32[] # CHECK: xla_fallback_bessel_i0e # CHECK-SAME: tensor<f32> print_ir(np.float32(0))(lax.bessel_i0e) # CHECK-LABEL: TEST: bessel_i1e float32[] # CHECK: xla_fallback_bessel_i1e # CHECK-SAME: tensor<f32> print_ir(np.float32(0))(lax.bessel_i1e) # CHECK-LABEL: TEST: betainc float32[] float32[] float32[] # CHECK: xla_fallback_regularized_incomplete_beta # CHECK-SAME: tensor<f32> print_ir(np.float32(0), np.float32(0), np.float32(0))(lax.betainc) # CHECK-LABEL: TEST: bitcast_convert_type uint32[7] # CHECK: mhlo.bitcast_convert # CHECK-SAME: tensor<7xui32> # CHECK-SAME: tensor<7xf32> print_ir(np.empty((7, ), np.uint32))(partial(lax.bitcast_convert_type, new_dtype=np.float32)) # CHECK-LABEL: TEST: bitwise_and int32[] int32[] # CHECK: mhlo.and # CHECK-SAME: tensor<i32> print_ir(np.int32(1), np.int32(2))(lax.bitwise_and) # CHECK-LABEL: TEST: bitwise_and bool[] bool[] # CHECK: mhlo.and # CHECK-SAME: tensor<i1> print_ir(np.bool_(0), np.bool_(0))(lax.bitwise_and) # CHECK-LABEL: TEST: bitwise_or int32[] int32[] # CHECK: mhlo.or # CHECK-SAME: tensor<i32> print_ir(np.int32(1), np.int32(2))(lax.bitwise_or) # CHECK-LABEL: TEST: bitwise_or bool[] bool[] # CHECK: mhlo.or # CHECK-SAME: tensor<i1> print_ir(np.bool_(0), np.bool_(0))(lax.bitwise_or) # CHECK-LABEL: TEST: bitwise_xor int32[] int32[] # CHECK: mhlo.xor # CHECK-SAME: tensor<i32> print_ir(np.int32(1), np.int32(2))(lax.bitwise_xor) # CHECK-LABEL: TEST: bitwise_xor bool[] bool[] # CHECK: mhlo.xor # CHECK-SAME: tensor<i1> print_ir(np.bool_(0), np.bool_(0))(lax.bitwise_xor) # CHECK-LABEL: TEST: cbrt bfloat16[] # CHECK: mhlo.cbrt # CHECK-SAME: tensor<bf16> print_ir(jnp.bfloat16(0))(lax.cbrt) # CHECK-LABEL: TEST: clamp bfloat16[] bfloat16[] bfloat16[] # CHECK: mhlo.clamp # CHECK-SAME: tensor<bf16> print_ir(jnp.bfloat16(0), jnp.bfloat16(0), jnp.bfloat16(0))(lax.clamp) # CHECK-LABEL: TEST: ceil float16[7] # CHECK: mhlo.ceil # CHECK-SAME: tensor<7xf16> print_ir(np.empty((7, ), np.float16))(lax.ceil) # CHECK-LABEL: TEST: convert_element_type float16[7] # CHECK: mhlo.convert # CHECK-SAME: tensor<7xf16> # CHECK-SAME: tensor<7xf32> print_ir(np.empty((7, ), np.float16))(partial(lax.convert_element_type, new_dtype=np.float32)) # CHECK-LABEL: TEST: convert_element_type complex64[7] # CHECK: mhlo.real # CHECK-SAME: tensor<7xcomplex<f32>> # CHECK-SAME: tensor<7xf32> print_ir(np.empty((7, ), np.complex64))(partial(lax.convert_element_type, new_dtype=np.float32)) # CHECK-LABEL: TEST: convert_element_type float32[7] # CHECK: mhlo.compare # CHECK-SAME: tensor<7xf32> # CHECK-SAME: tensor<7xi1> print_ir(np.empty((7, ), np.float32))(partial(lax.convert_element_type, new_dtype=np.bool_)) # CHECK-LABEL: TEST: clz uint32[] # CHECK: mhlo.count_leading_zeros # CHECK-SAME: tensor<ui32> print_ir(np.uint32(0))(lax.clz) # CHECK-LABEL: TEST: conj complex64[] # CHECK-DAG: mhlo.real # CHECK-DAG: mhlo.imag # CHECK-DAG: mhlo.neg # CHECK-DAG: mhlo.complex # CHECK-SAME: tensor<complex<f32>> print_ir(np.complex64(0))(lax.conj) # CHECK-LABEL: TEST: cos float32[] # CHECK: mhlo.cos # CHECK-SAME: tensor<f32> print_ir(np.float32(0))(lax.cos) # CHECK-LABEL: TEST: cosh float32[] # CHECK: chlo.cosh # CHECK-SAME: tensor<f32> print_ir(np.float32(0))(lax.cosh) # CHECK-LABEL: TEST: digamma float32[] # CHECK: chlo.digamma # CHECK-SAME: tensor<f32> print_ir(np.float32(0))(lax.digamma) # CHECK-LABEL: TEST: div float32[] float32[] # CHECK: mhlo.div # CHECK-SAME: tensor<f32> print_ir(np.float32(1), np.float32(2))(lax.div) # CHECK-LABEL: TEST: eq float32[] float32[] # CHECK: mhlo.compare # CHECK-SAME: compare_type = #mhlo<"comparison_type FLOAT"> # CHECK-SAME: comparison_direction = #mhlo<"comparison_direction EQ"> # CHECK-SAME: tensor<f32> print_ir(np.float32(1), np.float32(2))(lax.eq) # CHECK-LABEL: TEST: eq complex128[] complex128[] # CHECK: mhlo.compare # CHECK-SAME: compare_type = #mhlo<"comparison_type FLOAT"> # CHECK-SAME: comparison_direction = #mhlo<"comparison_direction EQ"> # CHECK-SAME: tensor<complex<f64>> print_ir(np.complex128(1), np.complex128(2))(lax.eq) # CHECK-LABEL: TEST: eq int64[] int64[] # CHECK: mhlo.compare # CHECK-SAME: compare_type = #mhlo<"comparison_type SIGNED"> # CHECK-SAME: comparison_direction = #mhlo<"comparison_direction EQ"> # CHECK-SAME: tensor<i64> print_ir(np.int64(1), np.int64(2))(lax.eq) # CHECK-LABEL: TEST: eq uint16[] uint16[] # CHECK: mhlo.compare # CHECK-SAME: compare_type = #mhlo<"comparison_type UNSIGNED"> # CHECK-SAME: comparison_direction = #mhlo<"comparison_direction EQ"> # CHECK-SAME: tensor<ui16> print_ir(np.uint16(1), np.uint16(2))(lax.eq) # CHECK-LABEL: TEST: erf float32[] # CHECK: chlo.erf # CHECK-SAME: tensor<f32> print_ir(np.float32(0))(lax.erf) # CHECK-LABEL: TEST: erfc float32[] # CHECK: chlo.erfc # CHECK-SAME: tensor<f32> print_ir(np.float32(0))(lax.erfc) # CHECK-LABEL: TEST: erf_inv float32[] # CHECK: xla_fallback_erf_inv # CHECK-SAME: tensor<f32> print_ir(np.float32(0))(lax.erf_inv) # CHECK-LABEL: TEST: exp float16[] # CHECK: mhlo.exp # CHECK-SAME: tensor<f16> print_ir(np.float16(0))(lax.exp) # CHECK-LABEL: TEST: expm1 bfloat16[] # CHECK: mhlo.exponential_minus_one # CHECK-SAME: tensor<bf16> print_ir(jnp.bfloat16(0))(lax.expm1) # CHECK-LABEL: TEST: floor bfloat16[2,3] # CHECK: mhlo.floor # CHECK-SAME: tensor<2x3xbf16> print_ir(np.empty((2, 3), jnp.bfloat16))(lax.floor) # CHECK-LABEL: TEST: ge float32[] float32[] # CHECK: mhlo.compare # CHECK-SAME: compare_type = #mhlo<"comparison_type FLOAT"> # CHECK-SAME: comparison_direction = #mhlo<"comparison_direction GE"> # CHECK-SAME: tensor<f32> print_ir(np.float32(1), np.float32(2))(lax.ge) # CHECK-LABEL: TEST: gt float32[] float32[] # CHECK: mhlo.compare # CHECK-SAME: compare_type = #mhlo<"comparison_type FLOAT"> # CHECK-SAME: comparison_direction = #mhlo<"comparison_direction GT"> # CHECK-SAME: tensor<f32> print_ir(np.float32(1), np.float32(2))(lax.gt) # CHECK-LABEL: TEST: igamma float32[] float32[] # CHECK: xla_fallback_igamma # CHECK-SAME: tensor<f32> print_ir(np.float32(0), np.float32(0))(lax.igamma) # CHECK-LABEL: TEST: igammac float32[] float32[] # CHECK: xla_fallback_igammac # CHECK-SAME: tensor<f32> print_ir(np.float32(0), np.float32(0))(lax.igammac) # CHECK-LABEL: TEST: igamma_grad_a float32[] float32[] # CHECK: xla_fallback_igamma_grad_a # CHECK-SAME: tensor<f32> print_ir(np.float32(0), np.float32(0))(lax.igamma_grad_a) # CHECK-LABEL: TEST: imag complex64[] # CHECK: mhlo.imag # CHECK-SAME: tensor<complex<f32>> print_ir(np.complex64(0))(lax.imag) # CHECK-LABEL: TEST: integer_pow float32[] # CHECK-DAG: mhlo.mul # CHECK-SAME: tensor<f32> @print_ir(np.float32(1)) def integer_pow(x): return lax.integer_pow(x, 3) # CHECK-LABEL: TEST: is_finite float64[] # CHECK: mhlo.is_finite # CHECK-SAME: tensor<f64> print_ir(np.float64(0))(lax.is_finite) # CHECK-LABEL: TEST: le float32[] float32[] # CHECK: mhlo.compare # CHECK-SAME: compare_type = #mhlo<"comparison_type FLOAT"> # CHECK-SAME: comparison_direction = #mhlo<"comparison_direction LE"> # CHECK-SAME: tensor<f32> print_ir(np.float32(1), np.float32(2))(lax.le) # CHECK-LABEL: TEST: lgamma float32[] # CHECK: chlo.lgamma # CHECK-SAME: tensor<f32> print_ir(np.float32(0))(lax.lgamma) # CHECK-LABEL: TEST: log float32[] # CHECK: mhlo.log # CHECK-SAME: tensor<f32> print_ir(np.float32(0))(lax.log) # CHECK-LABEL: TEST: log1p float32[] # CHECK: mhlo.log_plus_one # CHECK-SAME: tensor<f32> print_ir(np.float32(0))(lax.log1p) # CHECK-LABEL: TEST: lt float32[] float32[] # CHECK: mhlo.compare # CHECK-SAME: compare_type = #mhlo<"comparison_type FLOAT"> # CHECK-SAME: comparison_direction = #mhlo<"comparison_direction LT"> # CHECK-SAME: tensor<f32> print_ir(np.float32(1), np.float32(2))(lax.lt) # CHECK-LABEL: TEST: max float32[] float32[] # CHECK: mhlo.max # CHECK-SAME: tensor<f32> print_ir(np.float32(1), np.float32(2))(lax.max) # CHECK-LABEL: TEST: min float32[] float32[] # CHECK: mhlo.min # CHECK-SAME: tensor<f32> print_ir(np.float32(1), np.float32(2))(lax.min) # CHECK-LABEL: TEST: mul float32[] float32[] # CHECK: mhlo.mul # CHECK-SAME: tensor<f32> print_ir(np.float32(1), np.float32(2))(lax.mul) # CHECK-LABEL: TEST: ne float32[] float32[] # CHECK: mhlo.compare # CHECK-SAME: compare_type = #mhlo<"comparison_type FLOAT"> # CHECK-SAME: comparison_direction = #mhlo<"comparison_direction NE"> # CHECK-SAME: tensor<f32> print_ir(np.float32(1), np.float32(2))(lax.ne) # CHECK-LABEL: TEST: neg int64[] # CHECK: mhlo.negate # CHECK-SAME: tensor<i64> print_ir(np.int64(0))(lax.neg) # CHECK-LABEL: TEST: nextafter float32[] float32[] # CHECK: chlo.next_after # CHECK-SAME: tensor<f32> print_ir(np.float32(0), np.float32(0))(lax.nextafter) # CHECK-LABEL: TEST: bitwise_not int64[] # CHECK: mhlo.not # CHECK-SAME: tensor<i64> print_ir(np.int64(0))(lax.bitwise_not) # CHECK-LABEL: TEST: bitwise_not bool[] # CHECK: mhlo.not # CHECK-SAME: tensor<i1> print_ir(np.bool_(0))(lax.bitwise_not) # CHECK-LABEL: TEST: population_count uint32[] # CHECK: mhlo.popcnt # CHECK-SAME: tensor<ui32> print_ir(np.uint32(0))(lax.population_count) # CHECK-LABEL: TEST: pow float32[] float32[] # CHECK: mhlo.power # CHECK-SAME: tensor<f32> print_ir(np.float32(1), np.float32(2))(lax.pow) # CHECK-LABEL: TEST: random_gamma_grad float32[] float32[] # CHECK: xla_fallback_random_gamma_grad # CHECK-SAME: tensor<f32> print_ir(np.float32(0), np.float32(0))(lax.random_gamma_grad) # CHECK-LABEL: TEST: real complex128[] # CHECK: mhlo.real # CHECK-SAME: tensor<complex<f64>> print_ir(np.complex128(0))(lax.real) # CHECK-LABEL: TEST: reduce_precision bfloat16[] # CHECK: mhlo.reduce_precision # CHECK-SAME: tensor<bf16> print_ir(jnp.bfloat16(0))(partial(lax.reduce_precision, exponent_bits=2, mantissa_bits=2)) # CHECK-LABEL: TEST: rem float32[] float32[] # CHECK: mhlo.rem # CHECK-SAME: tensor<f32> print_ir(np.float32(1), np.float32(2))(lax.rem) # CHECK-LABEL: TEST: round float64[7,1] # CHECK: mhlo.round # CHECK-SAME: tensor<7x1xf64> print_ir(np.empty((7, 1), np.float64))(partial( lax.round, rounding_method=lax.RoundingMethod.AWAY_FROM_ZERO)) # CHECK-LABEL: TEST: rsqrt complex64[] # CHECK: mhlo.rsqrt # CHECK-SAME: tensor<complex<f32>> print_ir(jnp.complex64(0))(lax.rsqrt) # CHECK-LABEL: TEST: shift_left uint32[] uint32[] # CHECK: mhlo.shift_left # CHECK-SAME: tensor<ui32> print_ir(np.uint32(0), np.uint32(0))(lax.shift_left) # CHECK-LABEL: TEST: shift_right_arithmetic uint8[] uint8[] # CHECK: mhlo.shift_right_arithmetic # CHECK-SAME: tensor<ui8> print_ir(np.uint8(0), np.uint8(0))(lax.shift_right_arithmetic) # CHECK-LABEL: TEST: shift_right_logical uint16[] uint16[] # CHECK: mhlo.shift_right_logical # CHECK-SAME: tensor<ui16> print_ir(np.uint16(0), np.uint16(0))(lax.shift_right_logical) # CHECK-LABEL: TEST: sign int64[] # CHECK: mhlo.sign # CHECK-SAME: tensor<i64> print_ir(np.int64(0))(lax.sign) # CHECK-LABEL: TEST: sign uint32[] # CHECK: mhlo.compare # CHECK-SAME: tensor<ui32> print_ir(np.uint32(0))(lax.sign) # CHECK-LABEL: TEST: sin float32[] # CHECK: mhlo.sin # CHECK-SAME: tensor<f32> print_ir(np.float32(0))(lax.sin) # CHECK-LABEL: TEST: sinh float32[] # CHECK: chlo.sinh # CHECK-SAME: tensor<f32> print_ir(np.float32(0))(lax.sinh) # CHECK-LABEL: TEST: sub float32[] float32[] # CHECK: mhlo.sub # CHECK-SAME: tensor<f32> print_ir(np.float32(1), np.float32(2))(lax.sub) # CHECK-LABEL: TEST: sqrt bfloat16[] # CHECK: mhlo.sqrt # CHECK-SAME: tensor<bf16> print_ir(jnp.bfloat16(0))(lax.sqrt) # CHECK-LABEL: TEST: tan float16[] # CHECK: chlo.tan # CHECK-SAME: tensor<f16> print_ir(np.float16(0))(lax.tan) # CHECK-LABEL: TEST: tanh float32[] # CHECK: mhlo.tanh # CHECK-SAME: tensor<f32> print_ir(np.float32(0))(lax.tanh)
import pytest import sympy import cirq @pytest.mark.parametrize( 'val', [ 3.2, np.float32(3.2), int(1), np.int32(45), np.float64(6.3), np.int32(2), np.complex64(1j), np.complex128(2j), complex(1j), fractions.Fraction(3, 2), ], ) def test_value_of_pass_through_types(val): _assert_consistent_resolution(val, val) @pytest.mark.parametrize( 'val,resolved', [(sympy.pi, np.pi), (sympy.S.NegativeOne, -1), (sympy.S.Half, 0.5), (sympy.S.One, 1)], ) def test_value_of_transformed_types(val, resolved):
# stubs should instead do # # np.array([1.0, 0.0, 0.0], dtype=np.float32) # np.array([], dtype=np.complex64) # # See e.g. the discussion on the mailing list # # https://mail.python.org/pipermail/numpy-discussion/2020-April/080566.html # # and the issue # # https://github.com/numpy/numpy-stubs/issues/41 # # for more context. np.float32([1.0, 0.0, 0.0]) # E: incompatible type np.complex64([]) # E: incompatible type np.complex64(1, 2) # E: Too many arguments # TODO: protocols (can't check for non-existent protocols w/ __getattr__) np.datetime64(0) # E: non-matching overload class A: def __float__(self): return 1.0 np.int8(A()) # E: incompatible type np.int16(A()) # E: incompatible type np.int32(A()) # E: incompatible type
def test_complex32(self): s = readsav(path.join(DATA_PATH, 'scalar_complex32.sav'), verbose=False) assert_identical(s.c32, np.complex64(3.124442e13 - 2.312442e31j))
uv_in.write_uvfits(testfile, run_check=False) else: with pytest.warns(UserWarning, match=warnstr): uv_in.write_uvfits(testfile, run_check=False) @pytest.mark.filterwarnings( "ignore:The uvw_array does not match the expected values") @pytest.mark.filterwarnings("ignore:Telescope EVLA is not") @pytest.mark.parametrize( "kwd_names,kwd_values", ( [["bool", "bool2"], [True, False]], [["int1", "int2"], [np.int(5), 7]], [["float1", "float2"], [np.int64(5.3), 6.9]], [["complex1", "complex2"], [np.complex64(5.3 + 1.2j), 6.9 + 4.6j]], [ ["str", "comment"], [ "hello", "this is a very long comment that will be broken into several " "lines\nif everything works properly.", ], ], ), ) def test_extra_keywords(casa_uvfits, tmp_path, kwd_names, kwd_values): uv_in = casa_uvfits uv_out = UVData() testfile = str(tmp_path / "outtest_casa.uvfits")
if not fixed: converter = converter.vararray_type(field, converter, arraysize, config) return converter numpy_dtype_to_field_mapping = { np.float64().dtype.num: 'double', np.float32().dtype.num: 'float', np.bool_().dtype.num: 'bit', np.uint8().dtype.num: 'unsignedByte', np.int16().dtype.num: 'short', np.int32().dtype.num: 'int', np.int64().dtype.num: 'long', np.complex64().dtype.num: 'floatComplex', np.complex128().dtype.num: 'doubleComplex', np.unicode_().dtype.num: 'unicodeChar' } numpy_dtype_to_field_mapping[np.bytes_().dtype.num] = 'char' def _all_bytes(column): for x in column: if not isinstance(x, bytes): return False return True def _all_unicode(column):
lk = 1 #total length k space dk = lk / N h = np.array(range(0, int(N / 2) + 1), dtype=np.float64) # vector of wavenumbers h = np.append(h, np.array(range(1 - int(N / 2), 0), dtype=np.float64)) h = h * dk k = h l = h H, K, L = np.meshgrid(h, k, l) # reciprocal space coordinates HH = H * b1[0] + K * b2[0] + L * b3[0] KK = H * b1[1] + K * b2[1] + L * b3[1] LL = H * b1[2] + K * b2[2] + L * b3[2] '''Initial condition ''' nr0 = np.complex64(c + 0.05 * (np.random.rand(h.shape[0], h.shape[0], h.shape[0]) - 0.5)) nk0 = np.complex64(np.fft.fftn(nr0)) '''Parameters''' R = 8.3144598 T = 600 T0 = 1100 Tr1 = T / T0 w1 = (592 + T / R + 205 * (c - c2) / 2) pi = tf.constant(math.pi, dtype=tf.complex64) ' ' 'Lk=-2 sum(L1*sin^2(1/2*k*r))' '' Lk1 = 0 coordl = [-1, 1] for xx in coordl: Lk1 = Lk1 - 2 * ((np.sin(math.pi * (HH * xx)))**2) Lk1 = Lk1 - 2 * ((np.sin(math.pi * (KK * xx)))**2)
def sc_complex_dot_batched(bx_gpu, by_gpu, bc_gpu, transa='N', transb='N', handle=None): """ Uses cublasCgemmBatched to compute a bunch of complex dot products in parallel. """ if handle is None: handle = scikits.cuda.misc._global_cublas_handle assert len(bx_gpu.shape) == 3 assert len(by_gpu.shape) == 3 assert len(bc_gpu.shape) == 3 assert bx_gpu.dtype == np.complex64 assert by_gpu.dtype == np.complex64 assert bc_gpu.dtype == np.complex64 # Get the shapes of the arguments bx_shape = bx_gpu.shape by_shape = by_gpu.shape # Perform matrix multiplication for 2D arrays: alpha = np.complex64(1.0) beta = np.complex64(0.0) transa = string.lower(transa) transb = string.lower(transb) if transb in ['t', 'c']: N, m, k = by_shape elif transb in ['n']: N, k, m = by_shape else: raise ValueError('invalid value for transb') if transa in ['t', 'c']: N2, l, n = bx_shape elif transa in ['n']: N2, n, l = bx_shape else: raise ValueError('invalid value for transa') if l != k: raise ValueError('objects are not aligned') if N != N2: raise ValueError('batch sizes are not the same') if transb == 'n': lda = max(1, m) else: lda = max(1, k) if transa == 'n': ldb = max(1, k) else: ldb = max(1, n) ldc = max(1, m) # construct pointer arrays needed for cublasCgemmBatched bx_arr = bptrs(bx_gpu) by_arr = bptrs(by_gpu) bc_arr = bptrs(bc_gpu) cublas.cublasCgemmBatched(handle, transb, transa, m, n, k, alpha, by_arr.gpudata, lda, bx_arr.gpudata, ldb, beta, bc_arr.gpudata, ldc, N)
def __initializeDataSet(self, num_pix, current_pixels): """ Creates and initializes the primary (and auxillary) datasets and datagroups to hold the raw data for the current set of experimental parameters. Parameters ---------- num_pix : unsigned int Number of pixels this datagroup is expected to hold current_pixels : dictionary of BEPSndfPixel objects Extracted data for the first pixel in this group Returns --------- h5_refs : list of HDF5group and HDF5Dataset references references of the written H5 datasets """ tot_bins = 0 tot_pts = 0 # Each wavetype can have different number of bins for pixl in current_pixels.values(): tot_bins += pixl.num_bins tot_pts += pixl.num_bins * pixl.num_steps # Need to halve the number of steps when only in / out field is acquired: if self.halve_udvs_steps: tot_pts = int(tot_pts / 2) # Populate information from the columns within the pixels such as the FFT, bin freq, indices, etc. bin_freqs = np.zeros(shape=(tot_bins), dtype=np.float32) bin_inds = np.zeros(shape=(tot_bins), dtype=np.uint32) bin_FFT = np.zeros(shape=(tot_bins), dtype=np.complex64) exec_bin_vec = np.zeros(shape=(tot_bins), dtype=np.int32) pixel_bins = {} # Might be useful later stind = 0 for wave_type in self.__unique_waves__: pixl = current_pixels[wave_type] exec_bin_vec[stind:stind + pixl.num_bins] = wave_type * np.ones(pixl.num_bins) bin_inds[stind:stind + pixl.num_bins] = pixl.BE_bin_ind bin_freqs[stind:stind + pixl.num_bins] = pixl.BE_bin_w bin_FFT[stind:stind + pixl.num_bins] = pixl.FFT_BE_wave pixel_bins[wave_type] = [stind, pixl.num_bins] stind += pixl.num_bins del pixl, stind # Make the index matrix that has the UDVS step number and bin indices spec_inds = np.zeros(shape=(2, tot_pts), dtype=np.uint32) stind = 0 # Need to go through the UDVS file and reconstruct chronologically for step_index, wave_type in enumerate(self.excit_type_vec): if self.halve_udvs_steps and self.udvs_mat[ step_index, 2] < 1E-3: # invalid AC amplitude continue # skip vals = pixel_bins[wave_type] spec_inds[1, stind:stind + vals[1]] = step_index * np.ones(vals[1]) # UDVS step spec_inds[0, stind:stind + vals[1]] = np.arange( vals[0], vals[0] + vals[1]) # Bin step stind += vals[1] del stind, wave_type, step_index self.spec_inds = spec_inds # will need this for plot group generation ds_ex_wfm = MicroDataset('Excitation_Waveform', self.BE_wave) ds_bin_freq = MicroDataset('Bin_Frequencies', bin_freqs) ds_bin_inds = MicroDataset( 'Bin_Indices', bin_inds - 1, dtype=np.uint32) # From Matlab (base 1) to Python (base 0) ds_bin_FFT = MicroDataset('Bin_FFT', bin_FFT) ds_wfm_typ = MicroDataset('Bin_Wfm_Type', exec_bin_vec) ds_bin_steps = MicroDataset('Bin_Step', np.arange(tot_bins, dtype=np.uint32)) curr_parm_dict = self.parm_dict # Some very basic information that can help the processing crew curr_parm_dict['num_bins'] = tot_bins curr_parm_dict['num_pix'] = num_pix # technically should change the date, etc. self.current_group = '{:s}'.format('Measurement_') meas_grp = MicroDataGroup(self.current_group, '/') meas_grp.attrs = curr_parm_dict chan_grp = MicroDataGroup('Channel_') chan_grp.attrs['Channel_Input'] = curr_parm_dict['IO_Analog_Input_1'] meas_grp.addChildren([chan_grp]) udvs_slices = dict() for col_ind, col_name in enumerate(self.udvs_labs): udvs_slices[col_name] = (slice(None), slice(col_ind, col_ind + 1)) #print('UDVS column index {} = {}'.format(col_ind,col_name)) ds_UDVS = MicroDataset('UDVS', self.udvs_mat) ds_UDVS.attrs['labels'] = udvs_slices ds_UDVS.attrs['units'] = self.udvs_units actual_udvs_steps = self.num_udvs_steps if self.halve_udvs_steps: actual_udvs_steps = actual_udvs_steps / 2 curr_parm_dict['num_udvs_steps'] = actual_udvs_steps ds_UDVS_inds = MicroDataset('UDVS_Indices', self.spec_inds[1]) # ds_UDVS_inds.attrs['labels'] = {'UDVS_step':(slice(None),)} """ Create the Spectroscopic Values tables """ spec_vals, spec_inds, spec_vals_labs, spec_vals_units, spec_vals_labs_names = \ createSpecVals(self.udvs_mat, spec_inds, bin_freqs, exec_bin_vec, curr_parm_dict, np.array(self.udvs_labs), self.udvs_units) spec_vals_slices = dict() for row_ind, row_name in enumerate(spec_vals_labs): spec_vals_slices[row_name] = (slice(row_ind, row_ind + 1), slice(None)) ds_spec_vals_mat = MicroDataset('Spectroscopic_Values', np.array(spec_vals, dtype=np.float32)) ds_spec_vals_mat.attrs['labels'] = spec_vals_slices ds_spec_vals_mat.attrs['units'] = spec_vals_units ds_spec_mat = MicroDataset('Spectroscopic_Indices', spec_inds, dtype=np.uint32) ds_spec_mat.attrs['labels'] = spec_vals_slices ds_spec_mat.attrs['units'] = spec_vals_units for entry in spec_vals_labs_names: label = entry[0] + '_parameters' names = entry[1] ds_spec_mat.attrs[label] = names ds_spec_vals_mat.attrs[label] = names """ New Method for chunking the Main_Data dataset. Chunking is now done in N-by-N squares of UDVS steps by pixels. N is determined dinamically based on the dimensions of the dataset. Currently it is set such that individual chunks are less than 10kB in size. Chris Smith -- [email protected] """ max_bins_per_pixel = np.max(pixel_bins.values()) pixel_chunking = maxReadPixels(10240, num_pix, max_bins_per_pixel, np.dtype('complex64').itemsize) chunking = np.floor(np.sqrt(pixel_chunking)) chunking = max(1, chunking) chunking = min(actual_udvs_steps, num_pix, chunking) beps_chunks = calc_chunks([num_pix, tot_pts], np.complex64(0).itemsize, unit_chunks=(1, max_bins_per_pixel)) ds_main_data = MicroDataset('Raw_Data', np.zeros(shape=(1, tot_pts), dtype=np.complex64), chunking=beps_chunks, resizable=True, compression='gzip') ds_noise = MicroDataset('Noise_Floor', np.zeros(shape=(1, actual_udvs_steps), dtype=nf32), chunking=(1, actual_udvs_steps), resizable=True, compression='gzip') # noise_labs = ['super_band','inter_bin_band','sub_band'] # noise_slices = dict() # for col_ind, col_name in enumerate(noise_labs): # noise_slices[col_name] = (slice(None),slice(col_ind,col_ind+1), slice(None)) # ds_noise.attrs['labels'] = noise_slices # ds_noise.attrs['units'] = ['','',''] # ds_noise_labs = MicroDataset('Noise_Labels',np.array(noise_labs)) # Allocate space for the first pixel for now and write along with the complete tree... # Positions CANNOT be written at this time since we don't know if the parameter changed chan_grp.addChildren([ ds_main_data, ds_noise, ds_ex_wfm, ds_spec_mat, ds_wfm_typ, ds_bin_steps, ds_bin_inds, ds_bin_freq, ds_bin_FFT, ds_UDVS, ds_spec_vals_mat, ds_UDVS_inds ]) #meas_grp.showTree() h5_refs = self.hdf.writeData(meas_grp) self.ds_noise = getH5DsetRefs(['Noise_Floor'], h5_refs)[0] self.ds_main = getH5DsetRefs(['Raw_Data'], h5_refs)[0] #self.dset_index += 1 # raise dset index after closing only self.ds_pixel_index = 0 # Use this for plot groups: self.mean_resp = np.zeros(shape=(tot_pts), dtype=np.complex64) # Used for Histograms self.max_resp = np.zeros(shape=(num_pix), dtype=np.float32) self.min_resp = np.zeros(shape=(num_pix), dtype=np.float32) return h5_refs