def p_b_wins(): # Equal to P(b<a). T=6; distrb3 = scipy.array([[p_x_tries(x, T, payoff(T)) for x in xs]]) T=7; distrb6 = scipy.array([[p_x_tries(x, T, payoff(T)) for x in xs]]) T=3; distrb7 = scipy.array([[p_x_tries(x, T, payoff(T)) for x in xs]]) table36 = scipy.fliplr(scipy.dot(distrb3.T, distrb6)) distr36 = scipy.zeros((1, 2*MAX_X)) # First element should be 0. for offseti, offset in enumerate(xrange(-(MAX_X-1), MAX_X)): distr36[0,-offseti-1] = scipy.trace(table36, offset) del table36 distr36 = distr36[:,:MAX_X] assert distr36[0,0] == 0 table367 = scipy.fliplr(scipy.dot(distr36.T, distrb7)) del distr36 distr367 = scipy.zeros((1, 2*MAX_X)) # First two elements should be 0. for offseti, offset in enumerate(xrange(-(MAX_X-1), MAX_X)): distr367[0,-offseti-1] = scipy.trace(table367, offset) del table367 distr367 = distr367[:,:MAX_X] assert distr367[0,0] == 0 and distr367[0,1] == 0 #pylab.bar(xs, distr367[0,:]); pylab.show() m = scipy.dot(distra.T, distr367) p = 0. for offseti, offset in enumerate(xrange(-(MAX_X-1), 0)): p += scipy.trace(m, offset) return p
def _qfunc_pure(psi, alpha_vec):
"""
Calculate the Q-function for a pure state.
"""
n = np.prod(psi.shape)
# Gengyan: maximun number to use factorial()
nmax = 170
if isinstance(psi, Qobj):
psi = psi.full().flatten()
else:
psi = psi.T
if n < nmax:
qvec = abs(
polyval(
fliplr([psi / sqrt(factorial(arange(n)))])[0],
conjugate(alpha_vec)))**2 * exp(-abs(alpha_vec)**2)
else:
# Gengyan: for m < nmax, use factorial()
qvec = polyval(
fliplr([psi[0:nmax] / sqrt(factorial(arange(nmax)))])[0],
conjugate(alpha_vec)) * exp(-abs(alpha_vec)**2 / 2)
# Gengyan: for m >= nmax, use Stirling's approximation
for m in range(nmax, n):
qvec += (conjugate(alpha_vec)/sqrt(m))**m*psi[m] * \
exp((m-abs(alpha_vec)**2)/2)*(2*pi*m)**(-0.25)
qvec = abs(qvec)**2
return np.real(qvec) / pi
def Suffle(n=1,a=25214903917,c=11,mod=2**48,seed=1):
NumberofCards=52
final=PRNG(n*NumberofCards,a,c,mod,seed)
index=sp.zeros((n,NumberofCards))
for x in range(n):
index[x,:]=final[(x)*NumberofCards:(x+1)*NumberofCards].argsort()
return sp.fliplr(index).astype(int)
def p_b_wins(strategy, scorea = 0): # Equal to P(b<a). Ts = strategy.Ts targets = strategy.targets distr = None for T, target, i in zip(Ts, targets, itertools.count()): distrT = scipy.array([[p_x_tries(x, T, target) for x in xs]]) if distr is not None: table = scipy.fliplr(scipy.dot(distr.T, distrT)) distr = scipy.zeros((1, 2*MAX_X)) for offseti, offset in enumerate(xrange(-(MAX_X-1), MAX_X)): distr[0, -offseti-1] = scipy.trace(table, offset) distr = distr[:,:MAX_X] else: distr = distrT assert distr[0,:i].sum() == 0 E = (xs * distr[0,:]).sum() #pylab.bar(xs, distr[0,:]); pylab.show() distra = scipy.array([[p_x_tries(x, 1, 100 - scorea) for x in xs]]) m = scipy.dot(distra.T, distr) p = 0. for offseti, offset in enumerate(xrange(-(MAX_X-1), 0)): p += scipy.trace(m, offset) return p
def generator(self,samples=None):
"""Generator to only hold batch_size of data in memory
TODO:
* Trim images -> Or do this with a cropping layer in keras
Args:
samples (Dataframe): Dataframe containing sample info.
batch_size (int): Batch size for the training
"""
print("="*50)
print(" Generate batch data")
print("-"*50)
im_output_flip = True
path = self._path
batch_size = self._batchsize
num_samples = len(samples)
num_samples_flipped = 0
print(" Batch size = {}, Sample Size = {}".format(batch_size,num_samples))
while 1: # Loop forever so the generator never terminates
sklearn.utils.shuffle(samples) # Wow, this work for pandas DataFrames !!!
for offset in range(0, num_samples, batch_size):
batch_samples = samples[offset:offset+batch_size]
images = []
angles = []
for index, batch_sample in batch_samples.iterrows():
# name = './IMG/'+batch_sample[0].split('/')[-1] # Add if becessart
im_col = batch_sample["im_sel"]
image = cv2.imread(os.path.join(path, batch_sample[im_col].lstrip()))
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
if batch_sample['im_flip']:
if im_output_flip:
logger.info('Saving first flipped image')
print('Saving first flipped image')
plt.imsave('examples/im_flip_original.png',image)
image = sp.fliplr(image)
if im_output_flip:
plt.imsave('examples/im_flip_flipped.png',image)
im_output_flip = False
angle = float(batch_sample['steering'])
images.append(image)
angles.append(angle)
# trim image to only see section with road
X_train = sp.array(images)
y_train = sp.array(angles)
yield sklearn.utils.shuffle(X_train, y_train)
def _qfunc_pure(psi, alpha_mat):
"""
Calculate the Q-function for a pure state.
"""
n = prod(psi.shape)
if isinstance(psi, Qobj):
psi = array(psi.trans().full())[0,:]
else:
psi = psi.T
qmat1 = abs(polyval(fliplr([psi/sqrt(factorial(arange(0, n)))])[0], conjugate(alpha_mat))) ** 2;
qmat1 = real(qmat1) * exp(-abs(alpha_mat)**2) / pi;
return qmat1
def _qfunc_pure(psi, alpha_mat):
"""
Calculate the Q-function for a pure state.
"""
n = np.prod(psi.shape)
if isinstance(psi, Qobj):
psi = psi.full().flatten()
else:
psi = psi.T
qmat = abs(polyval(fliplr([psi / sqrt(factorial(arange(n)))])[0],
conjugate(alpha_mat))) ** 2
return real(qmat) * exp(-abs(alpha_mat) ** 2) / pi
def _eig_decomposition(self, A, largest=True):
n_features = A.shape[0]
if (largest):
eig_range = (n_features - self.n_components, n_features - 1)
else:
eig_range = (0, self.n_components - 1)
eigvals, eigvecs = spla.eigh(A, eigvals=eig_range)
if (largest):
eigvals = eigvals[::-1]
eigvecs = sp.fliplr(eigvecs)
return eigvals, eigvecs
def _qfunc_pure(psi, alpha_mat):
"""
Calculate the Q-function for a pure state.
"""
n = prod(psi.shape)
if isinstance(psi, Qobj):
psi = array(psi.trans().full())[0, :]
else:
psi = psi.T
qmat1 = abs(
polyval(
fliplr([psi / sqrt(factorial(arange(0, n)))])[0],
conjugate(alpha_mat)))**2
qmat1 = real(qmat1) * exp(-abs(alpha_mat)**2) / pi
return qmat1
color_Lab = KamiSolve.rgb2CIELAB(color[::-1])
#gw = color.dot(BGR_weights)
#color = color/gw
#color = scipy.append(color,gw/100)
#dist_list = [scipy.linalg.norm(color-mi) for mi in m]
#dist_list = [abs(scipy.exp(1j*color_hsl[0]*pi/180)-scipy.exp(1j*mi[0]*pi/180)) + abs(color_hsl[1]-mi[1]) for mi in m]
dist_list = [scipy.linalg.norm(color_Lab-mi) for mi in m]
min_index, min_value = min(enumerate(dist_list), key=operator.itemgetter(1))
#color_board[p] = [color,min_index]
#color_board[p] = [color_hsl,min_index]
color_board[p] = [color_Lab,min_index]
kami = scipy.fliplr(kami.reshape(-1,3)).reshape(kami.shape)
plt.imshow(kami)
plt.figure()
KamiSolve.show_color_board(color_board)
m = KamiSolve.k_means(color_board,k)
plt.figure()
KamiSolve.show_color_board(color_board)
plt.show()
c = [ [], [], [], [] ]
for i in color_board:
c[color_board[i][1]].append(i)
while [] in c:
c.remove([])
def define_mask(self):
csmask0 = sp.flipud(sp.fliplr(self.omask))
csmask = np.zeros((self.ny+4*self.dy, self.nx+4*self.dx)).astype(np.bool)
csmask[self.dy:self.dy+self.ny,self.dx:self.dx+self.nx] = csmask0
self.csmask = csmask
def rdmd(A,
dt=1,
k=None,
p=10,
q=2,
sdist='uniform',
return_amplitudes=False,
return_vandermonde=False,
order=True):
"""
Randomized Dynamic Mode Decomposition.
Dynamic Mode Decomposition (DMD) is a data processing algorithm which
allows to decompose a matrix `A` in space and time. The matrix `A` is
decomposed as `A = F * B * V`, where the columns of `F` contain the dynamic modes.
The modes are ordered corresponding to the amplitudes stored in the diagonal
matrix `B`. `V` is a Vandermonde matrix describing the temporal evolution.
Parameters
----------
A : array_like
Real/complex input matrix `a` with dimensions `(m, n)`.
dt : scalar or array_like
Factor specifying the time difference between the observations.
k : int
If `k < (n-1)` low-rank Dynamic Mode Decomposition is computed.
p : int, optional
Oversampling paramater.
sdist : str `{'uniform', 'normal'}`
Specify the distribution of the sensing matrix `S`.
return_amplitudes : bool `{True, False}`
True: return amplitudes in addition to dynamic modes.
return_vandermonde : bool `{True, False}`
True: return Vandermonde matrix in addition to dynamic modes and amplitudes.
order : bool `{True, False}`
True: return modes sorted.
Returns
-------
F : array_like
Matrix containing the dynamic modes of shape `(m, n-1)` or `(m, k)`.
b : array_like, if `return_amplitudes=True`
1-D array containing the amplitudes of length `min(n-1, k)`.
V : array_like, if `return_vandermonde=True`
Vandermonde matrix of shape `(n-1, n-1)` or `(k, n-1)`.
omega : array_like
Time scaled eigenvalues: `ln(l)/dt`.
Notes
-----
References
----------
Examples
--------
"""
#Shape of A
m, n = A.shape
dat_type = A.dtype
if dat_type == sci.float32:
isreal = True
real_type = sci.float32
fT = rT
elif dat_type == sci.float64:
isreal = True
real_type = sci.float64
fT = rT
elif dat_type == sci.complex64:
isreal = False
real_type = sci.float32
fT = cT
elif dat_type == sci.complex128:
isreal = False
real_type = sci.float64
fT = cT
else:
raise ValueError('A.dtype is not supported')
if k > min(m, n):
k = min(m, n)
if k is None:
raise ValueError('Target rank needs to be specified.')
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Generate a random test matrix Omega
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if sdist == 'uniform':
Omega = np.array(sci.random.uniform(-1, 1, size=(n, k + p)),
dtype=dat_type)
if isreal == False:
Omega += 1j * sci.array(sci.random.uniform(-1, 1, size=(n, k + p)),
dtype=real_type)
elif sdist == 'normal':
Omega = np.array(sci.random.standard_normal(size=(n, k + p)),
dtype=dat_type)
if isreal == False:
Omega += 1j * sci.array(
sci.random.standard_normal(size=(n, k + p)), dtype=real_type)
else:
raise ValueError('Sampling distribution is not supported.')
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Build sample matrix Y : Y = A * Omega
#Note: Y should approximate the range of A
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Y = A.dot(Omega)
del (Omega)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Orthogonalize Y using economic QR decomposition: Y=QR
#If q > 0 perfrom q subspace iterations
#Note: check_finite=False may give a performance gain
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
s = 1 #control parameter for number of orthogonalizations
if q > 0:
for i in np.arange(1, q + 1):
if ((2 * i - 2) % s == 0):
Y, _ = sci.linalg.qr(Y,
mode='economic',
check_finite=False,
overwrite_a=True)
if ((2 * i - 1) % s == 0):
Z, _ = sci.linalg.qr(fT(A).dot(Y),
mode='economic',
check_finite=False,
overwrite_a=True)
Y = A.dot(Z)
#End for
#End if
Q, _ = sci.linalg.qr(Y,
mode='economic',
check_finite=False,
overwrite_a=True)
del (Y)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Project the data matrix a into a lower dimensional subspace
#B = Q.T * A
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
B = fT(Q).dot(A)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Split data into lef and right snapshot sequence
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
X = B[:, 0:(n - 1)] #pointer
Y = B[:, 1:n] #pointer
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Singular Value Decomposition
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
U, s, Vh = sci.linalg.svd(X,
compute_uv=True,
full_matrices=False,
overwrite_a=False,
check_finite=True)
U = U[:, 0:k]
s = s[0:k]
Vh = Vh[0:k, :]
#EndIf
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Solve the LS problem to find estimate for M using the pseudo-inverse
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#real: M = U.T * Y * Vt.T * S**-1
#complex: M = U.H * Y * Vt.H * S**-1
#Let G = Y * Vt.H * S**-1, hence M = M * G
Vscaled = fT(Vh) * s**-1
G = np.dot(Y, Vscaled)
M = np.dot(fT(U), G)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Eigen Decomposition
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
l, W = sci.linalg.eig(M, right=True, overwrite_a=True)
omega = np.log(l) / dt
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Order
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if order == True:
sort_idx = sci.argsort(np.abs(omega))
W = W[:, sort_idx]
l = l[sort_idx]
omega = omega[sort_idx]
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Compute DMD Modes
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
F = Q.dot(U.dot(W))
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Compute amplitueds b using least-squares: Fb=x1
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if return_amplitudes == True:
b, _, _, _ = sci.linalg.lstsq(F, A[:, 0])
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Compute Vandermonde matrix (CPU)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if return_vandermonde == True:
V = sci.fliplr(sci.vander(l, N=n))
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Return
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if return_amplitudes == True and return_vandermonde == True:
return F, b, V, omega
elif return_amplitudes == True and return_vandermonde == False:
return F, b, omega
else:
return F, omega
if dict_fn.split('.')[-1] == 'pickle':
with open(dict_fn, 'rb') as fid:
d = pickle.load(fid)
else:
d = sio.loadmat(dict_fn)
d['n_words'] = len(d['w_sizes'])
if d['n_words'] > max_dict_words:
d['n_words'] = max_dict_words
d['w_sizes'] = d['w_sizes'][:max_dict_words]
d['l_words'] = d['l_words'][:max_dict_words]
word_sizes = sorted(np.unique([s[0] for s in d['w_sizes']]))
d["l_word_sizes"] = [[s,s] for s in word_sizes]
max_word_size = np.max(word_sizes)
d['l_words'] = d['l_words'][:,:,:max_word_size,:max_word_size]
for i,ws in enumerate(word_sizes):
d['l_words'][i,:,:ws,:ws] = flipud(fliplr(d['l_words'][i,:,:ws,:ws]))
print 'Using dictionary with %d words with sizes %s.' % (d['n_words'], d["l_word_sizes"])
else:
d = None
p = legacy.params.ventral_2(d)
padding_value = p['model']['preprocessing']['pad_value']
img_new_size = p['model']['preprocessing']['img_base_size']
if s2_is_rbf:
p['model']['s2']['function'] = 'extract_s2_rbf'
p['model']['s2']['sigma'] = s2_rbf_sigma
n_scales = p['model']['preprocessing']['n_scales']
scaling_factor = p['model']['preprocessing']['scaling_factor']
# init the cuda kernels
def define_mask(self):
csmask0 = sp.flipud(sp.fliplr(self.omask))
csmask = np.zeros((self.ny+4*self.dy, self.nx+4*self.dx)).astype(np.bool)
csmask[self.dy:self.dy+self.ny,self.dx:self.dx+self.nx] = csmask0
self.csmask = csmask
def flip_frame(frame):
return sp.fliplr(frame)
if patch_size[0] % 2 == 0 or patch_size[1] % 2 == 0:
print("patch_size should be even")
exit(1)
key = 0
for filename in os.listdir(args.input_dir):
img = cv2.imread(args.input_dir+"/"+filename)
# img = cv2.cvtColor(img, cv2.cv.CV_BGR2GRAY)
if img.shape == (100, 130, 3):
first_resized = cv2.resize(img, (65, 50))
resized = cv2.resize(first_resized, (130, 100))
cv2.imwrite(args.resized_dir+"/"+filename+".png", resized)
# 折り返し画像
large_width = scipy.concatenate((scipy.fliplr(resized), resized, scipy.fliplr(resized)), axis=1)
large = scipy.concatenate((scipy.flipud(large_width), large_width, scipy.flipud(large_width)), axis=0)
h, w, d = resized.shape
xys = [(x, y) for x in xrange(w) for y in xrange(h)]
random.shuffle(xys)
for original_x, original_y in xys:
key += 1
x, y = original_x + w, original_y + h
subimg = large[y-patch_size[1]/2:y+patch_size[1]/2+1, x-patch_size[0]/2:x+patch_size[0]/2+1]
#cv2.imshow("test", img)
#cv2.waitKey(-1)
target_filename="{}_{}_{}.png".format(filename, original_x, original_y)
cv2.imwrite(args.output_dir+"/"+target_filename, subimg)
label = map(lambda item: float(item)/256, img[original_y, original_x].tolist())
print(" ".join(map(str, [key, target_filename]+label)))
def flip_frame(frame):
return sp.fliplr(frame)
def rdmd_single(A,
dt=1,
k=None,
p=10,
l=None,
sdist='uniform',
return_amplitudes=False,
return_vandermonde=False,
order=True):
"""
Randomized Dynamic Mode Decomposition Single-View.
Dynamic Mode Decomposition (DMD) is a data processing algorithm which
allows to decompose a matrix `A` in space and time. The matrix `A` is
decomposed as `A = F * B * V`, where the columns of `F` contain the dynamic modes.
The modes are ordered corresponding to the amplitudes stored in the diagonal
matrix `B`. `V` is a Vandermonde matrix describing the temporal evolution.
This algorithms implements a single pass algorithm.
Parameters
----------
A : array_like
Real/complex input matrix `a` with dimensions `(m, n)`.
dt : scalar or array_like
Factor specifying the time difference between the observations.
k : int
If `k < (n-1)` low-rank Dynamic Mode Decomposition is computed.
p : integer, default: `p=10`.
Parameter to control oversampling of column space.
l : integer, default: `l=2*p`.
Parameter to control oversampling of row space.
sdist : str `{'uniform', 'normal', 'orthogonal'}`, default: `sdist='uniform'`.
'uniform' : Random test matrices with uniform distributed elements.
'normal' : Random test matrices with normal distributed elements.
'orthogonal' : Orthogonalized random test matrices with uniform distributed elements.
return_amplitudes : bool `{True, False}`
True: return amplitudes in addition to dynamic modes.
return_vandermonde : bool `{True, False}`
True: return Vandermonde matrix in addition to dynamic modes and amplitudes.
order : bool `{True, False}`
True: return modes sorted.
Returns
-------
F : array_like
Matrix containing the dynamic modes of shape `(m, n-1)` or `(m, k)`.
b : array_like, if `return_amplitudes=True`
1-D array containing the amplitudes of length `min(n-1, k)`.
V : array_like, if `return_vandermonde=True`
Vandermonde matrix of shape `(n-1, n-1)` or `(k, n-1)`.
omega : array_like
Time scaled eigenvalues: `ln(l)/dt`.
Notes
-----
* Add option for sparse random test matrices.
* Modify algorithm to allow for the streaming model.
References
----------
Tropp, Joel A., et al.
"Randomized single-view algorithms for low-rank matrix approximation" (2016).
(available at `arXiv <https://arxiv.org/abs/1609.00048>`_).
Examples
--------
"""
# Shape of input matrix
m, n = A.shape
dat_type = A.dtype
if dat_type == sci.float32:
isreal = True
real_type = sci.float32
fT = rT
elif dat_type == sci.float64:
isreal = True
real_type = sci.float64
fT = rT
elif dat_type == sci.complex64:
isreal = False
real_type = sci.float32
fT = cT
elif dat_type == sci.complex128:
isreal = False
real_type = sci.float64
fT = cT
else:
raise ValueError("A.dtype is not supported")
if l is None:
l = 2 * p
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Generate a random test matrix Omega
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if sdist == 'uniform':
Omega = np.array(sci.random.uniform(-1, 1, size=(n, k + p)),
dtype=dat_type)
Psi = np.array(sci.random.uniform(-1, 1, size=(k + l, m)),
dtype=dat_type)
if isreal == False:
Omega += 1j * sci.array(sci.random.uniform(-1, 1, size=(n, k + p)),
dtype=real_type)
Psi += 1j * sci.array(sci.random.uniform(-1, 1, size=(k + l, m)),
dtype=real_type)
elif sdist == 'normal':
Omega = np.array(sci.random.standard_normal(size=(n, k + p)),
dtype=dat_type)
Psi = np.array(sci.random.standard_normal(size=(k + l, m)),
dtype=dat_type)
if isreal == False:
Omega += 1j * sci.array(
sci.random.standard_normal(size=(n, k + p)), dtype=real_type)
Psi += 1j * sci.array(sci.random.standard_normal(size=(k + l, m)),
dtype=real_type)
elif sdist == 'orthogonal':
Omega = np.array(sci.random.standard_normal(size=(n, k + p)),
dtype=dat_type)
Psi = np.array(sci.random.standard_normal(size=(k + l, m)),
dtype=dat_type)
if isreal == False:
Omega += 1j * sci.array(
sci.random.standard_normal(size=(n, k + p)), dtype=real_type)
Psi += 1j * sci.array(sci.random.standard_normal(size=(k + l, m)),
dtype=real_type)
Omega, _ = sci.linalg.qr(Omega,
mode='economic',
check_finite=False,
overwrite_a=True)
Psi, _ = sci.linalg.qr(Psi.T,
mode='economic',
check_finite=False,
overwrite_a=True)
Psi = Psi.T
else:
raise ValueError('Sampling distribution is not supported.')
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Build sample matrix Y = A * Omega and W = Psi * A
#Note: Y should approximate the column space and W the row space of A
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Y = A.dot(Omega)
W = Psi.dot(A)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Orthogonalize Y using economic QR decomposition: Y=QR
#Note: check_finite=False may give a performance gain
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Q, _ = sci.linalg.qr(Y,
mode='economic',
check_finite=False,
overwrite_a=True)
U, T = sci.linalg.qr(Psi.dot(Q),
mode='economic',
check_finite=False,
overwrite_a=False)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Form a smaller matrix
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
B = sci.linalg.solve(a=T, b=fT(U).dot(W))
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Split data into lef and right snapshot sequence
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
X = B[:, 0:(n - 1)] #pointer
Y = B[:, 1:n] #pointer
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Singular Value Decomposition
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
U, s, Vh = sci.linalg.svd(X,
compute_uv=True,
full_matrices=False,
overwrite_a=False,
check_finite=True)
U = U[:, 0:k]
s = s[0:k]
Vh = Vh[0:k, :]
#EndIf
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Solve the LS problem to find estimate for M using the pseudo-inverse
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#real: M = U.T * Y * Vt.T * S**-1
#complex: M = U.H * Y * Vt.H * S**-1
#Let G = Y * Vt.H * S**-1, hence M = M * G
Vscaled = fT(Vh) * s**-1
G = np.dot(Y, Vscaled)
M = np.dot(fT(U), G)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Eigen Decomposition
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
l, W = sci.linalg.eig(M, right=True, overwrite_a=True)
omega = np.log(l) / dt
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Order
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if order == True:
sort_idx = np.argsort(np.abs(omega))
W = W[:, sort_idx]
l = l[sort_idx]
omega = omega[sort_idx]
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Compute DMD Modes
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
F = Q.dot(U.dot(W))
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Compute amplitueds b using least-squares: Fb=x1
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if return_amplitudes == True:
b, _, _, _ = sci.linalg.lstsq(F, A[:, 0])
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Compute Vandermonde matrix (CPU)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if return_vandermonde == True:
V = sci.fliplr(np.vander(l, N=n))
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Return
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if return_amplitudes == True and return_vandermonde == True:
return F, b, V, omega
elif return_amplitudes == True and return_vandermonde == False:
return F, b, omega
else:
return F, omega
