def JSD(sequence_P, P_P, sequence_Q, P_Q):
""" alphabetic Jensen-Shannon Distance, calculated from discretized timeseries
data in a combined probability space.
Receives discretized sequences and their word counters using the discretize_sequence method.
P:=prior, Q:=posterior
See: https://stackoverflow.com/questions/15880133/jensen-shannon-divergence
Together with: http://doi.org/10.1063/1.4999613
"""
if len(P_P) > 0 and len(P_Q) > 0:
# create alphabet dictionary
# combine words for equal DPD lengths
P_combined = P_P + P_Q
sorted_keys = sorted(list(P_combined.keys()))
# Unknown key returns 0! :)
P_dpd = np.array([P_P[w] for w in sorted_keys])
Q_dpd = np.array([P_Q[w] for w in sorted_keys])
# norm probability distributions
norm_P = np_dot(P_dpd, P_dpd)
_P = P_dpd / norm_P
norm_Q = np_dot(Q_dpd, Q_dpd)
_Q = Q_dpd / norm_Q
# calculate Jensen-Shannon Distance
_M = 0.5 * (_P + _Q)
js_distance = np_sqrt(0.5 * (kl_div(_P, _M) + kl_div(_Q, _M)))
return js_distance
print("JSD: Alphabets must contain at least one word!")
return 1.0
def mel_scaled_spectrogram(spectrogram: ndarray,
sr: int,
n_mels: Optional[int] = 128,
fmin: Optional[float] = 0.0,
fmax: Optional[Union[float, None]] = None,
htk: Optional[bool] = False):
"""Calculates the mel scaled version of the spectrogram.
:param spectrogram: Spectrogram to be used.
:type spectrogram: numpy.ndarray
:param sr: Sampling frequency of the original signal.
:type sr: int
:param n_mels: Amount of mel filters to use, defaults to 128.
:type n_mels: int, optional
:param fmin: Minimum frequency for mel filters, defaults to 0.0.
:type fmin: float, optional
:param fmax: Maximum frequency for mel filters. If `None`, \
sr/2.0 is used. Defaults to None
:type fmax: float|None, optional
:param htk: Use HTK formula, instead of Slaney, defaults to False.
:type htk: bool, optional
:return: Mel scaled version of the input spectrogram, with shape \
(channels, nb_mels, values) for channels >= 2, else \
(nb_mels, values).
:rtype: numpy.ndarray
"""
ndim = spectrogram.ndim
if ndim not in [2, 3]:
raise AttributeError('Input spectrogram must be of shape '
'(channels, nb_frames, frames). '
f'Current input has {ndim} dimensions. '
f'Allowed are either 2 or 3.')
n_fft = 2 * (spectrogram[ndim - 2] - 1)
mel_filters = mel(
sr=sr,
n_fft=n_fft,
n_mels=n_mels,
fmin=fmin,
fmax=fmax,
htk=htk)
if ndim == 2:
mel_spectrogram = np_dot(mel_filters, spectrogram)
else:
mel_spectrogram = np_cat([expand_dims(np_dot(mel_filters, i), 0)
for i in spectrogram], axis=0)
return mel_spectrogram
def num_lap(x, A, n, dim, D, c):
ans = 0.0
x = x.reshape(n, dim)
for i in range(n):
for j in range(n):
ans = ans + (np_linalg_norm(x[i, :] - x[j, :])**2) * A[i, j] #\
# - (np.linalg.norm(x[i,:]-x[j,:])**2)*(1-A[i,j])
lst_eq = []
constraint = np_sum(
np_square(np_diagonal(np_dot(x, np_trans(x)) - np_eye(n))))
return ans + c * constraint
def array_pow(a, k):
"""
Calculate the matrix power as a^k.
Args:
a(numpy.array): a square matrix to be mutiplied.
k(int): the power index.
"""
retval = np_copy(a)
for i in xrange(1, k):
retval = np_dot(retval, a)
return retval
def diff_dists(self, other):
""" Calculate the difference between discrete probability distributions.
Assume the distributions are equally sorted.
"""
# check for size difference
if self.dpd.shape[0] == other.shape[0]:
diff = self.dpd[:, 0] - other[:, 0]
return np_sqrt(np_dot(diff, diff))
else:
# defenitely different!
# print("diff_dists: Could not calculate distribution difference as distributions are not equally long!")
return 1.0
def f(x, A, n, dim, D, c):
ans = 0.0
x = x.reshape(n, dim)
for i in range(n):
for j in range(n):
ans = ans + (np_linalg_norm(x[i, :] - x[j, :])**2) * A[i, j] #\
# - (np.linalg.norm(x[i,:]-x[j,:])**2)*(1-A[i,j])
lst_eq = []
# for i in range(dim):
# for j in range(dim):
# Mij = 0
# for k in range(n):
# Mij = Mij + D[k]*x[k,i]*x[k,j]
# if i == j: lst_eq.append(Mij - 1)
# else: lst_eq.append(Mij)
# constraint = np.array(lst_eq)
constraint = np_sum(
np_square(np_diagonal(np_dot(x, np_trans(x)) - np_eye(n))))
return ans + c * constraint
def passed_test(dtype, as_matrix, x_is_row, y_is_row, stride):
"""
Run one dot (inner) product test.
Arguments:
dtype: either 'float64' or 'float32', the NumPy dtype to test
as_matrix: True to test a NumPy matrix, False to test a NumPy ndarray
x_is_row: True to test a row vector as parameter x, False to test a column vector
y_is_row: True to test a row vector as parameter y, False to test a column vector
stride: stride of x and y to test; if None, a random stride is assigned
Returns:
True if the expected result is within the margin of error of the actual result,
False otherwise.
"""
# generate random sizes for vector dimensions and vector stride (if necessary)
length = randint(N_MIN, N_MAX)
stride = randint(N_MIN, STRIDE_MAX) if stride is None else stride
# create random vectors to test
x = random_vector(length, x_is_row, dtype, as_matrix)
y = random_vector(length, y_is_row, dtype, as_matrix)
# create views of x and y that can be used to calculate the expected result
x_2 = x if x_is_row else x.T
y_2 = y.T if y_is_row else y
# compute the expected result
if stride == 1:
expected = np_dot(x_2, y_2)[0][0]
else:
expected = 0
for i in range(0, length, stride):
expected += x_2[0, i] * y_2[i, 0]
# get the actual result
actual = dot(x, y, stride, stride)
# compare the actual result to the expected result and return result of the test
return abs(actual - expected) / expected < EPSILON
def enum( n, lattice ):
from math import pow
from numpy import dot as np_dot
from pylada import enumeration, math, crystal
supercells = enumeration.find_all_cells(lattice, n)
smiths = enumeration.create_smith_groups(lattice, supercells)
nflavors = enumeration.count_flavors(lattice)
nsites = len([0 for i in lattice.sites if len(i.type) > 1])
transforms = enumeration.create_transforms(lattice)
for smith in smiths:
card = int(smith.smith[0]*smith.smith[1]*smith.smith[2]*nsites)
label_exchange=enumeration.LabelExchange( card, nflavors )
flavorbase = enumeration.create_flavorbase(card, nflavors)
translations = enumeration.Translation(smith.smith, nsites)
database = enumeration.Database(card, nflavors)
maxterm = 0
for x in xrange(1, int(pow(nflavors, card))-1):
if not database[x]: continue
if not is_valid(flavorbase, x):
database[x] = False
continue
maxterm = x
for labelperm in label_exchange:
t = labelperm(x, flavorbase)
if t > x: database[t] = False
for translation in translations:
t = translation(x, flavorbase)
if t > x: database[t] = False
elif t == x:
database[t] = False
continue
for labelperm in label_exchange:
u = labelperm(t, flavorbase)
if u > x: database[u] = False
# checks supercell dependent transforms.
for nsupercell, supercell in enumerate(smith.supercells):
mine = []
# creates list of transformation which leave the supercell invariant.
cell = np_dot(lattice.cell, supercell.hermite)
specialized = []
for transform in transforms:
if not transform.invariant(cell): continue
transform.init(supercell.transform, smith.smith)
if not transform.is_trivial:
specialized.append( transform )
specialized_database = enumeration.Database(database)
for x in xrange(1, maxterm+1):
if not database[x]: continue
maxterm = x
for transform in specialized:
t = transform(x, flavorbase)
if t == x: continue
specialized_database[t] = False
for labelperm in label_exchange:
u = labelperm(t, flavorbase)
if u == x: continue
specialized_database[u] = False
for translation in translations:
u = translation(t, flavorbase)
if u == x: continue
specialized_database[u] = False
for labelperm in label_exchange:
v = labelperm(u, flavorbase)
if v == x: continue
specialized_database[v] = False
if specialized_database[x]: yield x, smith, supercell, flavorbase
def read_database(filename, withperms=True):
from numpy import array as np_array, dot as np_dot, zeros as np_zeros
from pylada import crystal, enumeration
lattice = crystal.Lattice()
with open(filename, "r") as file:
# reads lattice
for line in file:
data = line.split()
if len(data) == 0: continue
if data[0] == "cell:":
lattice.cell = np_array(data[1:], dtype="float64").reshape(3,3)
elif data[0] == "scale:":
lattice.scale = float(line.split()[1])
elif data[0] == "site:":
data = line.split()
data.pop(0)
site = crystal.Site()
for i in range(3): site.pos[i] = float(data.pop(0))
while len(data): site.type.append( data.pop(0) )
lattice.sites.append(site)
elif data[0] == "endlattice": break
lattice.set_as_crystal_lattice()
transforms = enumeration.create_transforms(lattice)
specialized = []
nsites = len([0 for i in lattice.sites if len(i.type) > 1])
hermite = None
flavorbase = None
transform = None
structure = crystal.Structure()
structure.scale = lattice.scale
for line in file:
data = line.split()
if len(data) == 0: continue
if data[0] == "n:": continue
if data[0] == "hermite:":
hermite = np_array(data[1:], dtype="float64").reshape(3,3)
specialized = []
elif data[0] == "transform:":
transform = np_array(data[1:], dtype="float64").reshape(3,3)
elif data[0] == "smith:":
smith = np_array( data[1:], dtype = "int64" )
translations = enumeration.Translation(smith, nsites)
cell = np_dot(lattice.cell, hermite)
structure = crystal.fill_structure(cell)
for transformation in transforms:
if not transformation.invariant(cell): continue
transformation.init(transform, smith)
if not transformation.is_trivial:
specialized.append( transformation )
elif data[0] == "flavorbase:":
card, nflavors = int(data[1]), int(data[2])
flavorbase = enumeration.create_flavorbase(card, nflavors)
label_exchange=enumeration.LabelExchange(card, nflavors)
elif len(data) > 0:
assert flavorbase is not None
assert hermite is not None
for x in data:
# adds label permutations that are not equivalent by affine transforms.
x = int(x)
others = set([x])
if withperms:
for labelperm in label_exchange:
u = labelperm(x, flavorbase)
if u in others: continue
dont = False
for transform in specialized:
t = transform(u, flavorbase)
if t in others:
dont = True
break
for translation in translations:
v = translation(t, flavorbase)
if v in others:
dont = True
break
if not dont: others.add(u)
for u in others:
enumeration.as_structure(structure, u, flavorbase)
yield structure
def gaussian(x, mu, sig):
""" Not normally distributed!
"""
diff = np.array([x - mu])
return np_exp((-np_sqrt(np_dot(diff, diff))**2.) / (2. * sig**2.))
def time_precision(mu, x, pi):
# fit time 'x' to predicted time 'mu' with precision 'pi'
# TODO: the scaling of sigma needs to be adapted to SoA empirical evidence
diff = np_sqrt(np_dot(x - mu, x - mu))
sig = 2 * (1 - pi) if pi < 1. else 0.1
return np_e**(-(diff**2) / (sig**2)) + 0.001
def get_grayscale(self, image=None):
if image is not None:
return np_dot(image[..., :3], [0.2989, 0.5870, 0.1140])
else:
return np_dot(self.image[..., :3], [0.2989, 0.5870, 0.1140])
# Mij = 0
# for k in range(n):
# Mij = Mij + D[k]*x[k,i]*x[k,j]
# if i == j: lst_eq.append(Mij - 1)
# else: lst_eq.append(Mij)
# constraint = np.array(lst_eq)
constraint = np_sum(
np_square(np_diagonal(np_dot(x, np_trans(x)) - np_eye(n))))
return ans + c * constraint
# def f_jac(x,A,n,dim,D,c):
# ans = 0.0
# jac = np_zeros((dim,1))
# jac[] = np_dot(A,x)
A = [[1, 1, 0, 0], [1, 1, 1, 1], [0, 1, 1, 0], [0, 1, 0, 1]]
A_dense = np_array(A)
D = np_sum(A_dense, axis=0)
A = scipy.sparse.csr_matrix(A_dense)
# A = A_dense
A_sq = np_dot(A, A)
dim = 1
n = 4
res = optimize.minimize(partial(f, A=A, n=n, dim=dim, D=D, c=1),
np_rand(n * dim))
print res.x
