def vRaman(x,omega=1.0,delta=0.0,epsilon=0.048,phi=4.0/3.0):
x=np.array(x)
s=1
v=np.outer(omega*np.exp(1.0j*2.0*phi*x),Fx(s)*np.sqrt(2.0)/2.0).reshape(x.size,2*s+1,2*s+1)
v=sLA.block_diag(*[np.triu(v[i])+np.conjugate(np.triu(v[i],1)).transpose() for i in range(x.size)])
v+=sLA.block_diag(*[np.diag([epsilon-delta,0.0,epsilon+delta])]*x.size)
return v
def prob(self, state):
"""
Calculates the probability of a given state using the exponential
family parameterization learned from a prior dataset. Note that
we are assuming A(theta) = 0 (i.e., the graph is triangulated).
Also note the similarity to calc_mu.
"""
n1 = state[0,0:self.num_sites]
n2 = state[0,self.num_sites:]
mu_s = state
s = np.zeros((self.num_nodes, self.num_nodes))
mu_st11 = np.matrix(s)
mu_st10 = np.matrix(s)
mu_st01 = np.matrix(s)
mu_st00 = np.matrix(s)
"""
Calculate the edges from n->n'.
This is the upper-right quadrant.
"""
upright = self.calc_mu_quadrant(n1, n2, False)
mu_st11[0:self.num_sites,self.num_sites:] += upright[3] # nn11
mu_st10[0:self.num_sites,self.num_sites:] += upright[2] # nn10
mu_st01[0:self.num_sites,self.num_sites:] += upright[1] # nn01
mu_st00[0:self.num_sites,self.num_sites:] += upright[0] # nn00
"""
Calculate the edges from n'->n'.
This is the lower-right quadrant.
"""
lowright = self.calc_mu_quadrant(n2, n2, True)
mu_st11[self.num_sites:,self.num_sites:] += lowright[3] # nn11
mu_st10[self.num_sites:,self.num_sites:] += lowright[2] # nn10
mu_st01[self.num_sites:,self.num_sites:] += lowright[1] # nn01
mu_st00[self.num_sites:,self.num_sites:] += lowright[0] # nn00
"""
We only want the upper triangle, since otherwise we will double
count the n'->n' edges.
"""
mu_st11 = np.triu(mu_st11)
mu_st10 = np.triu(mu_st10)
mu_st01 = np.triu(mu_st01)
mu_st00 = np.triu(mu_st00)
"""
Sum(x_s)
"""
sum_s = mu_s * self.nodes[0].T
sum_s += (mu_s - 1) * -1 * self.nodes[1].T
sum_s = sum_s[0,0]
"""
Sum(x_s,x_t)
"""
sum_st00 = np.sum(np.multiply(mu_st00, self.edges[0]))
sum_st01 = np.sum(np.multiply(mu_st01, self.edges[1]))
sum_st10 = np.sum(np.multiply(mu_st10, self.edges[2]))
sum_st11 = np.sum(np.multiply(mu_st11, self.edges[3]))
result = sum_s + sum_st00 + sum_st01 + sum_st10 + sum_st11
#print "S: {0} ST[00]: {1} ST[01]: {2} ST[10]: {3} ST[11]: {4}".format(sum_s, sum_st00, sum_st01, sum_st10, sum_st11)
#print "Prob: {0}".format(result)
#pseudo-likelihood
return result
def make_connections(n,density=0.25): """ This function will return a random adjacency matrix of size n x n. You read the matrix like this: if matrix[2,7] = 1, then cities '2' and '7' are connected. if matrix[2,7] = 0, then the cities are _not_ connected. :param n: number of cities :param density: controls the ratio of 1s to 0s in the matrix :returns: an n x n adjacency matrix """ import networkx # Generate a random adjacency matrix and use it to build a networkx graph a=numpy.int32(numpy.triu((numpy.random.random_sample(size=(n,n))<density))) G=networkx.from_numpy_matrix(a) # If the network is 'not connected' (i.e., there are isolated nodes) # generate a new one. Keep doing this until we get a connected one. # Yes, there are more elegant ways to do this, but I'm demonstrating # while loops! while not networkx.is_connected(G): a=numpy.int32(numpy.triu((numpy.random.random_sample(size=(n,n))<density))) G=networkx.from_numpy_matrix(a) # Cities should be connected to themselves. numpy.fill_diagonal(a,1) return a + numpy.triu(a,1).T
def __init__(self, rng, matches_vec, batch_size,
sample_diff_every_epoch=True, n_same_pairs=None):
"""
If `n_same_pairs` is given, this number of same pairs is sampled,
otherwise all same pairs are used.
"""
self.rng = rng
self.matches_vec = matches_vec
self.batch_size = batch_size
if n_same_pairs is None:
# Use all pairs
I, J = np.where(np.triu(distance.squareform(matches_vec))) # indices of same pairs
else:
# Sample same pairs
n_pairs = min(n_same_pairs, len(np.where(matches_vec == True)[0]))
same_sample = self.rng.choice(
np.where(matches_vec == True)[0], size=n_pairs, replace=False
)
same_vec = np.zeros(self.matches_vec.shape[0], dtype=np.bool)
same_vec[same_sample] = True
I, J = np.where(np.triu(distance.squareform(same_vec)))
self.x1_same_indices = []
self.x2_same_indices = []
for i, j in zip(I, J):
self.x1_same_indices.append(i)
self.x2_same_indices.append(j)
if not sample_diff_every_epoch:
self.x1_diff_indices, self.x2_diff_indices = self._sample_diff_pairs()
self.sample_diff_every_epoch = sample_diff_every_epoch
def test_compute_modes(self):
ws = N.identity(self.num_states)
tol = 1e-6
weights_full = N.mat(N.random.random((self.num_states, self.num_states)))
weights_full = N.triu(weights_full) + N.triu(weights_full, 1).H
weights_full = weights_full*weights_full
weights_diag = N.random.random(self.num_states)
weights_list = [None, weights_diag, weights_full]
vec_array = N.random.random((self.num_states, self.num_vecs))
for weights in weights_list:
IP = VectorSpaceMatrices(weights=weights).compute_inner_product_mat
correlation_mat_true = IP(vec_array, vec_array)
eigen_vals_true, eigen_vecs_true = util.eigh(correlation_mat_true)
build_coeff_mat_true = eigen_vecs_true * N.mat(N.diag(
eigen_vals_true**-0.5))
modes_true = vec_array.dot(build_coeff_mat_true)
modes, eigen_vals, eigen_vecs, correlation_mat = \
compute_POD_matrices_snaps_method(vec_array, self.mode_indices,
inner_product_weights=weights, return_all=True)
N.testing.assert_allclose(eigen_vals, eigen_vals_true, rtol=tol)
N.testing.assert_allclose(eigen_vecs, eigen_vecs_true)
N.testing.assert_allclose(correlation_mat, correlation_mat_true)
N.testing.assert_allclose(modes, modes_true[:,self.mode_indices])
modes, eigen_vals, eigen_vecs = \
compute_POD_matrices_direct_method(vec_array, self.mode_indices,
inner_product_weights=weights, return_all=True)
N.testing.assert_allclose(eigen_vals, eigen_vals_true)
N.testing.assert_allclose(N.abs(eigen_vecs), N.abs(eigen_vecs_true))
N.testing.assert_allclose(N.abs(modes), N.abs(modes_true[:,self.mode_indices]))
def test_dingdong():
"""Simple test of dingdong(n) for n = 9. Only tests to
see if matrix is symmetric. Again, very lame testing,
but it is a start"""
a = rogues.dingdong(9)
# Matrix must be Hermetian
assert((np.triu(a) == np.triu(np.conj(a.T))).all())
def _test(n):
"""Do an nxn test case worth 5 points."""
A = self._luTestCase(n)
L1, U1 = lu(A)
if not np.allclose(L1.dot(U1), A):
return _test(n)
stu = s.lu(A.copy())
try:
L2, U2 = stu
except(TypeError, ValueError):
raise ValueError("lu() failed to return two arrays")
pts = 5
if not all(np.allclose(*x) for x in [(np.tril(L2), L2),
(np.triu(U2), U2), (L1, L2), (U1, U2), (A, L2.dot(U2))]):
pts = 2
self.feedback += "\n\n{}\nA =\n{}".format('- '*20, A)
if not np.allclose(np.tril(L2), L2):
self.feedback += "\nL not lower triangular:\n{}".format(L2)
pts -= 1
if not np.allclose(np.triu(U2), U2):
self.feedback += "\nU not upper triangular:\n{}".format(U2)
pts -= 1
pts += self._eqTest(L1, L2, "lu() failed (L incorrect)")
pts += self._eqTest(U1, U2, "lu() failed (U incorrect)")
pts += self._eqTest(A, L2.dot(U2), "lu() failed (A != LU)")
return pts
def test_trsv(self):
seed(1234)
for ind, dtype in enumerate(DTYPES):
n = 15
A = (rand(n, n)+eye(n)).astype(dtype)
x = rand(n).astype(dtype)
func, = get_blas_funcs(('trsv',), dtype=dtype)
y1 = func(a=A, x=x)
y2 = solve(triu(A), x)
assert_array_almost_equal(y1, y2)
y1 = func(a=A, x=x, lower=1)
y2 = solve(tril(A), x)
assert_array_almost_equal(y1, y2)
y1 = func(a=A, x=x, diag=1)
A[arange(n), arange(n)] = dtype(1)
y2 = solve(triu(A), x)
assert_array_almost_equal(y1, y2)
y1 = func(a=A, x=x, diag=1, trans=1)
y2 = solve(triu(A).T, x)
assert_array_almost_equal(y1, y2)
y1 = func(a=A, x=x, diag=1, trans=2)
y2 = solve(triu(A).conj().T, x)
assert_array_almost_equal(y1, y2)
def generate_random_network(beta, N, k_bar, kappa0, gamma):
mu = beta * math.sin(math.pi / beta) / (2 * math.pi * k_bar)
graphe_random = nx.Graph()
kappa = powerlaw.Power_Law(xmin=kappa0, parameters=[gamma]).generate_random(N)
theta = np.random.uniform(0, 2 * math.pi, N)
# print 1+(len(kappa)/sum(np.log(kappa)))
th = np.outer(np.ones(N), theta)
# print "th"
th2 = np.outer(theta, np.ones(N))
# print "th2"
kp = np.outer(np.ones(N), kappa)
# print "kp"
kp2 = np.outer(kappa, np.ones(N))
# print "kp2"
dth = math.pi - np.abs(math.pi - np.abs(th - th2))
# print "dth"
khi = N * dth / (2 * math.pi * mu * kp * kp2)
# print "khi"
r = np.random.uniform(0, 1, [N, N])
# print "r"
r2 = np.triu(np.log(1 / r - 1) / beta, k=1)
p2 = np.triu(np.log(khi), k=1)
# print np.where(r2>p2) ie ln(1/r-1) / beta > ln(khi) <=> r < 1/(1+khi^beta)
graphe_random.add_edges_from(np.transpose(np.where(r2 > p2)))
return graphe_random
def pressure(self):
ps = 1.
sig = 1.
eps = 1.
d = 2.
N = np.size(self.c.x)
dx = self.c.dx()
dy = self.c.dy()
dz = self.c.dz()
dr2 = self.c.dr2()
r_mag = (dx ** 2 + dy ** 2 + dz ** 2)
r_mag = np.nan_to_num(r_mag)
px = dx * (24 * eps / r_mag) * ((2 * (sig**12 / r_mag**6)) - (sig**6 / r_mag**3))
px = np.nan_to_num(px)
px = np.triu(px)
py = dy * (24 * eps / r_mag) * ((2 * (sig**12 / r_mag**6)) - (sig**6 / r_mag**3))
py = np.nan_to_num(py)
py = np.triu(py)
pz = dz * (24 * eps / r_mag) * ((2 * (sig**12 / r_mag**6)) - (sig**6 / r_mag**3))
pz = np.nan_to_num(pz)
pz = np.triu(pz)
pt = px + py + pz
return 1 / (d * N * self.ke()) * np.sum(pt)
def _pipe_as_source(self):
rnd_norm_matr = np.random.randn(self.n_node, self.n_node)
rnd_cov_matr = np.abs(np.triu(rnd_norm_matr) +
np.triu(rnd_norm_matr).T)
signal = np.random.multivariate_normal(np.zeros(self.n_node),
rnd_cov_matr,
self.n_sample)
start_ix = 0
while True:
clip = signal[start_ix:start_ix+self.win_width, :]
# Properly format the yield
signal_packet = {}
signal_packet['data'] = clip
signal_packet['meta'] = \
{'ax_0':
{'label': 'Samples',
'index': np.arange(start_ix, start_ix+self.win_width)},
'ax_1':
{'label': 'Nodes',
'index': np.array(map(str, xrange(self.n_node)))}}
yield signal_packet
# Advance the pointer
start_ix += self.win_shift
if start_ix+self.win_width > self.n_sample:
my_display('\nEnd of signal.\n')
break
def test_tpsv(self):
seed(1234)
for ind, dtype in enumerate(DTYPES):
n = 10
x = rand(n).astype(dtype)
# Upper triangular array
A = triu(rand(n, n)) if ind < 2 else triu(rand(n, n)+rand(n, n)*1j)
A += eye(n)
# Form the packed storage
c, r = tril_indices(n)
Ap = A[r, c]
func, = get_blas_funcs(('tpsv',), dtype=dtype)
y1 = func(n=n, ap=Ap, x=x)
y2 = solve(A, x)
assert_array_almost_equal(y1, y2)
y1 = func(n=n, ap=Ap, x=x, diag=1)
A[arange(n), arange(n)] = dtype(1)
y2 = solve(A, x)
assert_array_almost_equal(y1, y2)
y1 = func(n=n, ap=Ap, x=x, diag=1, trans=1)
y2 = solve(A.T, x)
assert_array_almost_equal(y1, y2)
y1 = func(n=n, ap=Ap, x=x, diag=1, trans=2)
y2 = solve(A.conj().T, x)
assert_array_almost_equal(y1, y2)
def get_signal_correlation(self, corr='spearman'):
logging.debug("Calculating signal correlation")
response = self.response[:, 1:, :self.numbercells, 0] # orientation x freq x cell, no blank
response = response.reshape(self.number_ori * (self.number_tf-1), self.numbercells).T
N, Nstim = response.shape
signal_corr = np.zeros((N, N))
signal_p = np.empty((N, N))
if corr == 'pearson':
for i in range(N):
for j in range(i, N): # matrix is symmetric
signal_corr[i, j], signal_p[i, j] = st.pearsonr(response[i], response[j])
elif corr == 'spearman':
for i in range(N):
for j in range(i, N): # matrix is symmetric
signal_corr[i, j], signal_p[i, j] = st.spearmanr(response[i], response[j])
else:
raise Exception('correlation should be pearson or spearman')
signal_corr = np.triu(signal_corr) + np.triu(signal_corr, 1).T # fill in lower triangle
signal_p = np.triu(signal_p) + np.triu(signal_p, 1).T # fill in lower triangle
return signal_corr, signal_p
def get_representational_similarity(self, corr='spearman'):
logging.debug("Calculating representational similarity")
response = self.response[:, 1:, :self.numbercells, 0] # orientation x freq x phase x cell, no blank
response = response.reshape(self.number_ori * (self.number_tf-1), self.numbercells)
Nstim, N = response.shape
rep_sim = np.zeros((Nstim, Nstim))
rep_sim_p = np.empty((Nstim, Nstim))
if corr == 'pearson':
for i in range(Nstim):
for j in range(i, Nstim): # matrix is symmetric
rep_sim[i, j], rep_sim_p[i, j] = st.pearsonr(response[i], response[j])
elif corr == 'spearman':
for i in range(Nstim):
for j in range(i, Nstim): # matrix is symmetric
rep_sim[i, j], rep_sim_p[i, j] = st.spearmanr(response[i], response[j])
else:
raise Exception('correlation should be pearson or spearman')
rep_sim = np.triu(rep_sim) + np.triu(rep_sim, 1).T # fill in lower triangle
rep_sim_p = np.triu(rep_sim_p) + np.triu(rep_sim_p, 1).T # fill in lower triangle
return rep_sim, rep_sim_p
def test_iris(self):
# Generate full set of constraints for comparison with reference implementation
mask = (self.iris_labels[None] == self.iris_labels[:, None])
a, b = np.nonzero(np.triu(mask, k=1))
c, d = np.nonzero(np.triu(~mask, k=1))
# Full metric
mmc = MMC(convergence_threshold=0.01)
mmc.fit(self.iris_points, [a, b, c, d])
expected = [[+0.00046504, +0.00083371, -0.00111959, -0.00165265],
[+0.00083371, +0.00149466, -0.00200719, -0.00296284],
[-0.00111959, -0.00200719, +0.00269546, +0.00397881],
[-0.00165265, -0.00296284, +0.00397881, +0.00587320]]
assert_array_almost_equal(expected, mmc.metric(), decimal=6)
# Diagonal metric
mmc = MMC(diagonal=True)
mmc.fit(self.iris_points, [a, b, c, d])
expected = [0, 0, 1.21045968, 1.22552608]
assert_array_almost_equal(np.diag(expected), mmc.metric(), decimal=6)
# Supervised Full
mmc = MMC_Supervised()
mmc.fit(self.iris_points, self.iris_labels)
csep = class_separation(mmc.transform(), self.iris_labels)
self.assertLess(csep, 0.15)
# Supervised Diagonal
mmc = MMC_Supervised(diagonal=True)
mmc.fit(self.iris_points, self.iris_labels)
csep = class_separation(mmc.transform(), self.iris_labels)
self.assertLess(csep, 0.2)
def compute_distances_and_pairs(self, pdb_file, nr_contacts=None, nr_noncontacts=None):
#distance and contacts
self.features['pair']['Cbdist'] = pdb.distance_map(pdb_file, self.L)
#mask positions that have too many gaps
gap_freq = 1 - (self.Ni / self.neff)
highly_gapped_pos = np.where(gap_freq > self.max_gap_percentage)[0]
self.features['pair']['Cbdist'][:,highly_gapped_pos] = np.nan
self.features['pair']['Cbdist'][highly_gapped_pos, :] = np.nan
#if there are unresolved residues, there will be nan in the distance_map
with np.errstate(invalid='ignore'):
self.features['pair']['contact'] = (self.features['pair']['Cbdist'] <= self.contact_threshold) * 1
self.features['pair']['nocontact'] = (self.features['pair']['Cbdist'] > self.non_contact_threshold) * 1
indices_contact = np.where(np.triu(self.features['pair']['contact'], k=self.seq_separation))
indices_contact = tuple(shuffle(indices_contact[0],indices_contact[1], random_state=0))
if nr_contacts:
indices_contact = indices_contact[0][:nr_contacts], indices_contact[1][:nr_contacts]
indices_nocontact = np.where(np.triu(self.features['pair']['nocontact'], k=self.seq_separation))
indices_nocontact = tuple(shuffle(indices_nocontact[0],indices_nocontact[1], random_state=0))
if nr_noncontacts:
indices_nocontact = indices_nocontact[0][:nr_noncontacts], indices_nocontact[1][:nr_noncontacts]
#update indices of i<j for only relevant pairs
self.ij_ind_upper = np.array(list(indices_contact[0]) + list(indices_nocontact[0])), np.array(list(indices_contact[1]) + list(indices_nocontact[1]))
def test_tzrzf():
"""
This test performs an RZ decomposition in which an m x n upper trapezoidal
array M (m <= n) is factorized as M = [R 0] * Z where R is upper triangular
and Z is unitary.
"""
seed(1234)
m, n = 10, 15
for ind, dtype in enumerate(DTYPES):
tzrzf, tzrzf_lw = get_lapack_funcs(('tzrzf', 'tzrzf_lwork'),
dtype=dtype)
lwork = _compute_lwork(tzrzf_lw, m, n)
if ind < 2:
A = triu(rand(m, n).astype(dtype))
else:
A = triu((rand(m, n) + rand(m, n)*1j).astype(dtype))
# assert wrong shape arg, f2py returns generic error
assert_raises(Exception, tzrzf, A.T)
rz, tau, info = tzrzf(A, lwork=lwork)
# Check success
assert_(info == 0)
# Get Z manually for comparison
R = np.hstack((rz[:, :m], np.zeros((m, n-m), dtype=dtype)))
V = np.hstack((np.eye(m, dtype=dtype), rz[:, m:]))
Id = np.eye(n, dtype=dtype)
ref = [Id-tau[x]*V[[x], :].T.dot(V[[x], :].conj()) for x in range(m)]
Z = reduce(np.dot, ref)
assert_allclose(R.dot(Z) - A, zeros_like(A, dtype=dtype),
atol=10*np.spacing(dtype(1.0).real), rtol=0.)
def __init__(self, endmembers, alphas, energy_interaction, volume_interaction=None, entropy_interaction=None):
self.n_endmembers = len(endmembers)
# Create array of van Laar parameters
self.alphas = np.array(alphas)
# Create 2D arrays of interaction parameters
self.We = np.triu(2. / (self.alphas[:, np.newaxis] + self.alphas), 1)
self.We[np.triu_indices(self.n_endmembers, 1)] *= np.array([i for row in energy_interaction
for i in row])
if entropy_interaction is not None:
self.Ws = np.triu(2. / (self.alphas[:, np.newaxis] + self.alphas), 1)
self.Ws[np.triu_indices(self.n_endmembers, 1)] *= np.array([i for row in entropy_interaction
for i in row])
else:
self.Ws = np.zeros((self.n_endmembers, self.n_endmembers))
if volume_interaction is not None:
self.Wv = np.triu(2. / (self.alphas[:, np.newaxis] + self.alphas), 1)
self.Wv[np.triu_indices(self.n_endmembers, 1)] *= np.array([i for row in volume_interaction
for i in row])
else:
self.Wv = np.zeros((self.n_endmembers, self.n_endmembers))
# initialize ideal solution model
IdealSolution.__init__(self, endmembers)
def updatePsi(self):
self.PsicXc = np.zeros((self.nc,self.nc), dtype=np.float)
self.PsicXe = np.zeros((self.ne,self.ne), dtype=np.float)
self.PsicXcXe = np.zeros((self.nc,self.ne), dtype=np.float)
#
# print self.thetac
# print self.pc
# print self.distanceXc
newPsicXc = np.exp(-np.sum(self.thetac*np.power(self.distanceXc,self.pc), axis=2))
print newPsicXc[0]
self.PsicXc = np.triu(newPsicXc,1)
self.PsicXc = self.PsicXc + self.PsicXc.T + np.mat(eye(self.nc))+np.multiply(np.mat(eye(self.nc)),np.spacing(1))
self.UPsicXc = np.linalg.cholesky(self.PsicXc)
self.UPsicXc = self.UPsicXc.T
print self.PsicXc[0]
print self.UPsicXc
exit()
newPsicXe = np.exp(-np.sum(self.thetac*np.power(self.distanceXe,self.pc), axis=2))
self.PsicXe = np.triu(newPsicXe,1)
self.PsiXe = self.PsicXe + self.PsicXe.T + np.mat(eye(self.ne))+np.multiply(np.mat(eye(self.ne)),np.spacing(1))
self.UPsicXe = np.linalg.cholesky(self.PsicXe)
self.UPsicXe = self.UPsicXe.T
newPsiXeXc = np.exp(-np.sum(self.thetad*np.power(self.distanceXcXe,self.pd), axis=2))
self.PsicXcXe = np.triu(newPsiXeXc,1)
def __call__(self, container, sim_wide_params):
distance_matrices = container.get_distance_matrices()
# LJ
accelerations, pe = moldyn.lennardJonesForce(
distance_matrices,
radius=self.radius,
epsilon=self.epsilon,
cutoff_dist=self.cutoff_dist,
anchor_ixs = sim_wide_params.anchor_ixs)
self.pe = pe # should LJ func calc this differently since we are doing a cutoff?
# Damping
dx, dy, dr = distance_matrices # KLUDGE
ixs_not_touching = dr > self.cutoff_dist
self.ixs_not_touching = ixs_not_touching
dvx, dvy, dvr = moldyn.get_distance_matrices(container.velocities)
## if np.any(container.velocities > 1):
## pass
## if container.time > 1:
## pass
dr[dr == 0] = 0.1 # prevent / 0 errors. Will this cause problems?
accel = self.damping_magnitude * (dvx*dx + dvy*dy)/dr
accel[ixs_not_touching] = 0
accelerations[:, 0] += np.sum(np.triu(accel * dx/dr), axis=0)
accelerations[:, 1] += np.sum(np.triu(accel * dy/dr), axis=0)
return accelerations
def build_binomial_price_tree(s0, u, d, n):
'''
Builds the underlying's price tree by working forward from
t=0 to expiration (t=n) --> total of n+1 time slots.
The price tree is an upper triangular 2D array, where each column
marks the different possible security prices S(t).
arguments:
- s0: initial stock price
- u: upward movement interest rate
- d: downward movement interest rate
- n: number of periods
'''
a = np.arange(0,n+1)
A = np.tile(a,(n+1,1))
C = np.triu(np.ones( (n+1,n+1) ))
# U_e is the matrix of all exponents pertaining to up movements.
# e.g: the first row is 0, 1, 2, counting (and multiplying)
# by the amount of times we moved 'up'.
U_e = np.triu(A-A.T)
# base matrix
U_b = u*C
# Similarily - down direction.
D_e = np.triu(A.T)
D_b = d*C
# Up/Down binomial distribution matrices
U = np.power(U_b, U_e)
D = np.power(D_b, D_e)
return np.triu( s0 * ( U*D ) )
def _flat2D(fld, center='Atlantic'):
"""convert mds 2D data into global 2D field"""
nx = fld.shape[1]
ny = fld.shape[0]
n = ny//nx//4
# eastern and western hemispheres
eastern=np.concatenate((fld[:n*nx,:],fld[n*nx:2*(n*nx)]),axis=1)
tmp = fld[2*(n*nx)+nx:, ::-1]
western=np.concatenate((tmp[2::n,:].transpose(),
tmp[1::n,:].transpose(),
tmp[0::n,:].transpose()))
# Arctic face is special
arctic = fld[2*(n*nx):2*(n*nx)+nx,:]
arctice = np.concatenate((np.triu(arctic[::-1,:nx//2].transpose()),
np.zeros((nx//2,nx))),axis=1)
# arcticw = np.concatenate((arctic[:,nx:nx//2-1:-1].transpose(),
# np.zeros((nx//2,nx//2)),
# arctic[nx:nx//2-1:-1,nx//2-1::-1]),axis=1)
mskr = np.tri(nx//2)[::-1,:]
arcticw = np.concatenate((arctic[0:nx//2,nx:nx//2-1:-1].transpose(),
arctic[nx//2:nx,nx:nx//2-1:-1].transpose()*mskr,
np.triu(arctic[nx:nx//2-1:-1,nx:nx//2-1:-1]),
arctic[nx:nx//2-1:-1,nx//2-1::-1]*mskr),axis=1)
#
if center == 'Pacific':
gfld = np.concatenate( ( np.concatenate((eastern,arctice)),
np.concatenate((western,arcticw)) ), axis=1)
else:
gfld = np.concatenate( ( np.concatenate((western,arcticw)),
np.concatenate((eastern,arctice)) ), axis=1)
return gfld
def __call__(self,x,v=0,t=0,calc_auxilary=True):
distance_matrix = self.distance_matrix
sigma,eps,m,r_tol = self.sigma,self.eps,self._masses,self.r_tol
dx = distance_matrix(x) # compute distance matrix THIS IS THE MAIN TIME COMPUTATION
r = distance_matrix.radii(dx)
bad_diagonal = isnan(r)
if (abs(r) < r_tol).any(): # This is some exception handling for forces that get out of control
idx = find(abs(r) < r_tol)
err_string = "Two points within 1e-8 of eachother r = \n"
err_string += str(r) + "\n"
err_string += "\n r{} = \n".format(array(unravel_index(idx,r.shape)))
for x in r.ravel()[idx]:
err_string += "{:.12f} \n".format(float(x))
# raise ValueError(err_string)
K2 = (sigma/r)**6 # Save these constants for calculating potential energy
K1 = K2**2
fmatrix = 24*eps/r*(2*K1 - K2)*dx.transpose(2,0,1)
K1[bad_diagonal] = 0 # Set diagonal back to zero.
K2[bad_diagonal] = 0 # Set diagonal back to zero.
fmatrix[:,bad_diagonal] = 0 # Set diagonal back to zero.
if calc_auxilary:
self.potential_energy = sum(triu(4*eps*(K1 - K2))) # Calculate potential energy
self.kinetic_energy = 3/2*sum(self._masses*sum(v**2,axis=1),axis=0)/2.
N = dx.shape[0]
d = dx.shape[2]
L = self.L[abs(self.L)>0]
self.pressure = 0
if N > 1:
press_matrix = sum(fmatrix*dx.transpose(2,0,1),axis=0) # this is the "dot product"
self.pressure = (sum(triu(press_matrix)) + N/(N-1)*self.kinetic_energy*2.)/d/prod(L)
ans = sum(fmatrix,axis=1)/m # Divide by masses to get acceleration
return ans.T
def verifyloglikelihood(theta_vector, graphe, constantes, silent=False):
"""On calcule somme (aij * logpij + (1-aij)* log(1-pij))"""
# aij
a = (nx.to_numpy_matrix(graphe)).A
# pij
kappa0, gamma, beta, Nobs, k_bar = constantes
mu = beta * math.sin(math.pi / beta) / (2 * math.pi * k_bar)
kappa = {node: max(kappa0, degree - gamma / beta) for node, degree in graphe.degree().items()}
kp = np.outer(np.ones(Nobs), kappa.values())
kp2 = np.outer(kappa.values(), np.ones(Nobs))
mukpkp2 = 2 * math.pi * mu * kp * kp2
th = np.outer(np.ones(Nobs), theta_vector)
th2 = np.outer(theta_vector, np.ones(Nobs))
dth = math.pi - np.abs(math.pi - np.abs(th - th2))
khi = Nobs * dth / mukpkp2
p = 1 / (1 + khi ** beta)
# log(pij)
lp = np.triu(np.log(p), k=1)
l_p = np.triu(np.log(1 - p), k=1)
# aij*log(pij)
lp[a == 0] = 0
l_p[a == 1] = 0
if not silent: print np.sum(lp + l_p), np.sum(lp), np.sum(l_p)
return np.sum(lp + l_p)
def pstep(self, level=0):
"""Propagates the momenta for half a time step."""
dt = self.pdt[level]
dt2 = dt**2
dt3 = dt**3 / 3.0
m = dstrip(self.beads.m3)[0].reshape(self.beads.natoms, 3)
hh0 = np.dot(self.cell.h, self.h0.ih)
pi_ext = np.dot(hh0, np.dot(self.stressext, hh0.T)) * self.h0.V / self.cell.V
L = np.diag([3, 2, 1])
stress = dstrip(self.stress_mts(level))
self.p += dt * (self.cell.V * np.triu(stress))
# integerates the kinetic part of the stress with the force at the inner-most level.
if(level == self.nmtslevels - 1):
self.p += dt * (self.cell.V * np.triu(-self.beads.nbeads * pi_ext) + Constants.kb * self.temp * L)
pc = dstrip(self.beads.pc).reshape(self.beads.natoms, 3)
fc = np.sum(dstrip(self.forces.forces_mts(level)), axis=0).reshape(self.beads.natoms, 3) / self.beads.nbeads
fcTonm = (fc / dstrip(self.beads.m3)[0].reshape(self.beads.natoms, 3)).T
self.p += np.triu(dt2 * np.dot(fcTonm, pc) + dt3 * np.dot(fcTonm, fc)) * self.beads.nbeads
def calculate2_pseudoV(pred, truth, rnd=0.01, full_matrix=True, sym=False):
if full_matrix:
pred_cp = pred
truth_cp = truth
else: # make matrix upper triangular
pred_cp = np.triu(pred)
truth_cp = np.triu(truth)
# Avoid dividing by zero by rounding everything less than rnd up to rnd
# Note: it is ok to do this after making the matrix upper triangular
# since the bottom triangle of the matrix will not affect the score
size = np.array(pred_cp.shape)[1]
res = 0 # result to be returned
# do one row at a time to reduce memory usage
for x in xrange(size):
# (1 - rnd) will cast the pred_cp/truth_cp matrices automatically if they are int8
pred_row = (1 - rnd) * pred_cp[x, ] + rnd
truth_row = (1 - rnd) * truth_cp[x, ] + rnd
pred_row /= np.sum(pred_row)
truth_row /= np.sum(truth_row)
if sym:
res += np.sum(truth_row * np.log(truth_row/pred_row)) + np.sum(pred_row * np.log(pred_row/truth_row))
else:
res += np.sum(truth_row * np.log(truth_row/pred_row))
return res
def test_dynamic_programming_logic(self):
# Test for the dynamic programming part
# This test is directly taken from Cormen page 376.
arrays = [np.random.random((30, 35)),
np.random.random((35, 15)),
np.random.random((15, 5)),
np.random.random((5, 10)),
np.random.random((10, 20)),
np.random.random((20, 25))]
m_expected = np.array([[0., 15750., 7875., 9375., 11875., 15125.],
[0., 0., 2625., 4375., 7125., 10500.],
[0., 0., 0., 750., 2500., 5375.],
[0., 0., 0., 0., 1000., 3500.],
[0., 0., 0., 0., 0., 5000.],
[0., 0., 0., 0., 0., 0.]])
s_expected = np.array([[0, 1, 1, 3, 3, 3],
[0, 0, 2, 3, 3, 3],
[0, 0, 0, 3, 3, 3],
[0, 0, 0, 0, 4, 5],
[0, 0, 0, 0, 0, 5],
[0, 0, 0, 0, 0, 0]], dtype=np.int)
s_expected -= 1 # Cormen uses 1-based index, python does not.
s, m = _multi_dot_matrix_chain_order(arrays, return_costs=True)
# Only the upper triangular part (without the diagonal) is interesting.
assert_almost_equal(np.triu(s[:-1, 1:]),
np.triu(s_expected[:-1, 1:]))
assert_almost_equal(np.triu(m), np.triu(m_expected))
def vRaman(x,omega=1.0,delta=0.0,epsilon=0.048,phi=4.0/3.0):
x=np.array(x)
s=1
v=v=np.einsum('i,jk->ijk',omega*np.exp(1.0j*2.0*phi*x),Fx(s)*np.sqrt(2.0)/2.0)
v=np.array([np.triu(v[i])+np.conjugate(np.triu(v[i],1)).transpose() for i in range(x.size)])
v+=np.array([np.diag([epsilon+delta,0.0,epsilon-delta])]*x.size)
return v
def __init__(self, num_visibles, num_hiddens): """ Initializes the parameters of the SemiRBM. @type num_visibles: integer @param num_visibles: number of visible units @type num_hiddens: integer @param num_hiddens: number of hidden units """ AbstractBM.__init__(self, num_visibles, num_hiddens) # additional hyperparameters self.learning_rate_lateral = 0.01 self.momentum_lateral = 0.5 self.weight_decay_lateral = 0. self.damping = 0.2 self.num_lateral_updates = 20 self.sampling_method = AbstractBM.MF # additional parameters self.L = np.matrix(np.random.randn(num_visibles, num_visibles)) / num_visibles / 200 self.L = np.triu(self.L) + np.triu(self.L).T - 2. * np.diag(np.diag(self.L)) self.dL = np.zeros_like(self.L)
def _getImageDirection(self, threshold=None):
"""
_getImageDirection(threshold=None)
Returns the direction of the sequence of avalanches as:
"Top_to_bottom","Left_to_right", "Bottom_to_top","Right_to_left"
Parameters:
----------------
threshold : int
Minimum value of the gray level change to conisider
a pixel as part of an avalanche (i.e. it is switched)
"""
# Top, left, bottom, rigth
imageDirections=["Top_to_bottom","Left_to_right", "Bottom_to_top","Right_to_left"]
# Check if color Image is available
if not self._isColorImage:
self._isColorImageDone(ask=False)
switchTimesMasked = self._switchTimes2D
pixelsUnderMasks = []
# first identify first 10 avalanches of whole image
firstAvsList = np.unique(self._switchTimes2D)[:11]
# Prepare the mask
m = np.ones((self.dimX, self.dimY))
# Top mask
mask = np.rot90(np.triu(m)) * np.triu(m)
top = switchTimesMasked * mask
pixelsUnderMasks.append(sum([np.sum(top==elem) for elem in firstAvsList]))
# Now we need to rotate the mask
for i in range(3):
mask = np.rot90(mask)
top = switchTimesMasked * mask
pixelsUnderMasks.append(sum([np.sum(top==elem) for elem in firstAvsList]))
max_in_mask = scipy.array(pixelsUnderMasks).argmax()
return imageDirections[max_in_mask]
xmean = np.clip(t_xmean, -0.8, 0.8)
t_zmean = np.zeros(nVar, )
for k in range(mu):
t_zmean += arz[:, arindex[k]] * w[k]
t_zmean = t_zmean / mu
zmean = t_zmean
ps = (1 - cs) * ps + (np.sqrt(cs *
(2 - cs)) * mueff) * np.matmul(B, zmean)
hsig = (np.linalg.norm(ps) / np.sqrt(1 -
(1 - cs)**(2 * counteval / la)) /
chiN) < (1.4 + (2 / (nVar + 1)))
pc = (1 - cc) * pc + hsig * np.sqrt(
cc * (2 - cc) * mueff) * (np.matmul(B, np.matmul(D, zmean)))
C = (1 - c1 - cmu)*C + c1*(np.matmul(pc, np.transpose(pc)) + (1 + hsig)*cc*(2-cc)*C) + \
cmu*np.matmul((np.matmul(B, np.matmul(D, arz[:,arindex[0:mu]]))) , \
np.matmul(np.diag(w),np.transpose((np.matmul(B, np.matmul(D, arz[:,arindex[0:mu]]))))))
sigma = sigma * np.exp((cs / damps) * (np.linalg.norm(ps) / chiN - 1))
if counteval - eigeneval > la / (c1 + cmu) / nVar / 10:
eigeneval = counteval
C = np.triu(C) + np.transpose(np.triu(C, 1))
D, B = np.linalg.eig(C)
D = np.diag(np.sqrt(D))
def get_attn_subsequent_mask(seq):
attn_shape = [seq.size(0), seq.size(1), seq.size(1)]
subsequent_mask = np.triu(np.ones(attn_shape), k=1)
subsequent_mask = torch.from_numpy(subsequent_mask).byte()
return subsequent_mask
def generate_visualizations(model,
config,
voc,
src_str='((()))(())()',
run_name='SAN',
iteration=0,
score=1.0,
device='cuda:1'):
dlang = DyckLanguage(1, 0.5, 0.25)
#Convert source string to ids tensor
src = sents_to_idx(voc, [src_str]).transpose(0, 1).to(device)[:-1]
#Create directory to save visualizations
dir_path = os.path.join("Figures", run_name)
if os.path.exists(dir_path) == False:
os.mkdir(dir_path)
# Ploting attention weights
def visualize_attn(src, src_str):
output, attn = model.model(src, get_attns=True)
src_len = len(src_str)
attn_maps = []
attn_map = attn[0][0, :src_len, :src_len].detach().cpu().numpy()
for i in range(config.depth):
for j in range(config.heads):
attn_map = attn[i][
0, j, :src_len, :src_len].detach().cpu().numpy()
plt.figure(figsize=(15, 10))
sns.set(font_scale=1.5)
g = sns.heatmap(np.log(attn_map),
mask=(attn_map == 0).astype(float),
annot=attn_map,
cmap=sns.cubehelix_palette(100,
start=0.7,
rot=-0.5,
gamma=1.5),
vmin=-2.6,
vmax=0,
cbar=False,
xticklabels=list(src_str),
yticklabels=list(src_str),
linewidths=.5) #cmap="YlGnBu")
yticks = g.set_yticklabels(labels=list(src_str),
rotation=360,
size=30)
xticks = g.set_xticklabels(labels=list(src_str), size=30)
plt.title(
'Attention Weights Layer: {} Head: {} (It: {}, Score: {})'.
format(i + 1, j + 1, iteration, np.round(score, 3)),
size=20)
fig = g.get_figure()
fig.savefig(os.path.join(
dir_path,
'attn_weights_depth-{}_heads-{}_it-{}.png'.format(
i + 1, j + 1, iteration)),
bbox_inches='tight')
attn_maps.append(attn_map)
return attn_maps
attn_maps = visualize_attn(src, src_str)
# Computing and Ploting Intermediate representations
# Obtaining Embeddings
embeddings = model.model.encoder(src) * np.sqrt(3)
embeddings_np = embeddings.detach().cpu().numpy().squeeze()
#Plotting Embeddings
plt.figure(figsize=(10, 3))
embed_unq = embeddings_np[[0, 3]]
g = sns.heatmap(embed_unq,
annot=embed_unq,
cmap=sns.color_palette("coolwarm", 7),
linewidth=1.5,
linecolor='black',
yticklabels=['(', ')'])
g.set_title('Embeddings (It: {}, Score: {})'.format(
iteration, np.round(score)))
fig = g.get_figure()
fig.savefig(os.path.join(dir_path,
'embeddings_it-{}.png'.format(iteration)),
bbox_inches='tight')
# Computing queries, keys and values
kqv = list(model.model.transformer_encoder.parameters())[0].detach()
b = list(model.model.transformer_encoder.parameters())[1].detach()
query_matrix, query_bias = kqv[:config.d_model], b[:config.d_model]
key_matrix, key_bias = kqv[config.d_model:config.d_model *
2], b[config.d_model:config.d_model * 2]
value_matrix, value_bias = kqv[config.d_model * 2:], b[config.d_model * 2:]
kqv_vectors = torch.mm(embeddings.squeeze(), kqv.transpose(0, 1)) + b
queries, keys, values = kqv_vectors[:, :config.
d_model], kqv_vectors[:,
config.d_model:
config.d_model *
2], kqv_vectors[:,
config
.
d_model
*
2:]
# Plotting Query Matrix
sns.set(font_scale=1.2)
query_matrix_np = query_matrix.detach().cpu().numpy().squeeze()
query_bias_np = query_bias.detach().cpu().numpy().squeeze()[:, None]
f, (ax1, ax2,
ax3) = plt.subplots(1,
3,
sharey=False,
gridspec_kw={'width_ratios': [6, 2, 0.8]},
figsize=(10, 5))
#f.tight_layout()
g1 = sns.heatmap(query_matrix_np,
annot=query_matrix_np.round(3),
cmap=sns.color_palette("coolwarm", 7),
linewidth=1.5,
linecolor='black',
ax=ax1,
cbar=False)
g1.set_title('Query Matrix')
g2 = sns.heatmap(query_bias_np,
annot=query_bias_np.round(3),
cmap=sns.color_palette("coolwarm", 7),
linewidth=1.5,
linecolor='black',
ax=ax2,
cbar_ax=ax3)
g2.set_title('Query Bias')
f.suptitle("Iteration: {}, Score: {}".format(iteration, np.round(score,
3)))
f.subplots_adjust(top=0.8)
f.savefig(os.path.join(dir_path, 'query_wb_it-{}.png'.format(iteration)),
bbox_inches='tight')
# Plotting Key Matrix
sns.set(font_scale=1.2)
key_matrix_np = key_matrix.detach().cpu().numpy().squeeze()
key_bias_np = key_bias.detach().cpu().numpy().squeeze()[:, None]
#plt.figure(figsize = (10, 10))
f, (ax1, ax2,
ax3) = plt.subplots(1,
3,
sharey=False,
gridspec_kw={'width_ratios': [6, 2, 0.8]},
figsize=(10, 5))
#f.tight_layout()
g1 = sns.heatmap(key_matrix_np,
annot=key_matrix_np.round(3),
cmap=sns.color_palette("coolwarm", 7),
linewidth=1.5,
linecolor='black',
ax=ax1,
cbar=False)
g1.set_title('Key Matrix')
g2 = sns.heatmap(key_bias_np,
annot=key_bias_np.round(3),
cmap=sns.color_palette("coolwarm", 7),
linewidth=1.5,
linecolor='black',
ax=ax2,
cbar_ax=ax3)
g2.set_title('Key Bias')
f.suptitle("Iteration: {}, Score: {}".format(iteration, np.round(score,
3)))
f.subplots_adjust(top=0.8)
f.savefig(os.path.join(dir_path, 'key_wb_it-{}.png'.format(iteration)),
bbox_inches='tight')
# Ploting Value Matrix
sns.set(font_scale=1.2)
value_matrix_np = value_matrix.detach().cpu().numpy().squeeze()
value_bias_np = value_bias.detach().cpu().numpy().squeeze()[:, None]
#plt.figure(figsize = (10, 10))
f, (ax1, ax2,
ax3) = plt.subplots(1,
3,
sharey=False,
gridspec_kw={'width_ratios': [6, 2, 0.8]},
figsize=(10, 5))
#f.tight_layout()
g1 = sns.heatmap(value_matrix_np,
annot=value_matrix_np.round(3),
cmap=sns.color_palette("coolwarm", 7),
linewidth=1.5,
linecolor='black',
ax=ax1,
cbar=False)
g1.set_title('Value Matrix')
g2 = sns.heatmap(value_bias_np,
annot=value_bias_np.round(3),
cmap=sns.color_palette("coolwarm", 7),
linewidth=1.5,
linecolor='black',
ax=ax2,
cbar_ax=ax3)
g2.set_title('Value Bias')
f.suptitle("Iteration: {}, Score: {}".format(iteration, np.round(score,
3)))
f.subplots_adjust(top=0.8)
f.savefig(os.path.join(dir_path, 'value_wb_it-{}.png'.format(iteration)),
bbox_inches='tight')
#Plotting value vectors
plt.figure(figsize=(10, 3))
values_np = values.detach().cpu().numpy().squeeze()
values_unq = values_np[[0, 3]]
#pdb.set_trace()
g = sns.heatmap(values_unq,
annot=values_unq,
cmap=sns.color_palette("coolwarm", 7),
linewidth=1.5,
linecolor='black',
yticklabels=['(', ')'])
g.set_title('Values')
fig = g.get_figure()
fig.suptitle("Iteration: {}, Score: {}".format(iteration,
np.round(score, 3)))
fig.subplots_adjust(top=0.8)
fig.savefig(os.path.join(dir_path, 'values_it-{}.png'.format(iteration)),
bbox_inches='tight')
# Computing Attention Map
n = len(queries)
mask = torch.tensor(np.triu(np.ones((n, n))).T).float().to(device)
scores = torch.mm(queries, keys.T) / (np.sqrt(3))
scores = scores * mask + (-1e9) * (1 - mask)
attn_map = nn.functional.softmax(scores, dim=-1)
assert np.allclose(attn_map.detach().cpu().numpy(), attn_maps[0])
# Computing attention outputs
attn_outs = torch.mm(attn_map.float(), values.float())
# Ploting attention outputs
seq = src_str
depths = dlang.depth_counter(seq).squeeze()
lens = np.array([i + 1 for i in range(len(seq))])
dlratio = depths / lens
sns.set(font_scale=3, style='ticks', rc={"lines.linewidth": 4})
src_chars = src_str
src_charsv0 = list(src_chars)
src_chars = ['{}_{}'.format(ch, i) for i, ch in enumerate(src_chars)]
attn_values = attn_outs.detach().cpu().numpy()
data = pd.DataFrame([src_chars, attn_values]).transpose()
data.columns = ['dyck', '0-Element']
fig = plt.figure(figsize=(25, 10))
plt.plot(src_chars,
attn_values[:, 0],
marker='o',
label='Coordinate-0',
markersize=12,
color='r')
plt.plot(src_chars,
attn_values[:, 1],
marker='D',
label='Coordinate-1',
markersize=12,
color='m')
plt.plot(src_chars,
attn_values[:, 2],
marker='v',
label='Coordinate-2',
markersize=12,
color='g')
plt.plot(src_chars,
dlratio,
'--',
marker='s',
markersize=12,
color='c',
label='Depth : Length')
plt.legend(loc="upper right")
plt.title("Output of Self-Attention Block (It: {}, Score: {})".format(
iteration, np.round(score, 3)))
plt.grid()
plt.rc('grid', linestyle="-", color='black')
plt.savefig(os.path.join(dir_path, 'attn_outs-{}.png'.format(iteration)),
bbox_inches='tight')
# Computing outputs on applying a linear layer on attention outputs
attn_ffn_w = list(model.model.transformer_encoder.parameters())[2].detach()
attn_ffn_b = list(model.model.transformer_encoder.parameters())[3].detach()
attn_ffn = torch.mm(attn_outs, attn_ffn_w.transpose(0, 1)) + attn_ffn_b
sns.set(font_scale=1.2)
attn_ffn_w_np = attn_ffn_w.detach().cpu().numpy().squeeze()
attn_ffn_b_np = attn_ffn_b.detach().cpu().numpy().squeeze()[:, None]
#plt.figure(figsize = (10, 10))
f, (ax1, ax2,
ax3) = plt.subplots(1,
3,
sharey=False,
gridspec_kw={'width_ratios': [6, 2, 0.8]},
figsize=(10, 5))
f.tight_layout()
g1 = sns.heatmap(attn_ffn_w_np,
annot=attn_ffn_w_np.round(3),
cmap=sns.color_palette("coolwarm", 7),
linewidth=1.5,
linecolor='black',
ax=ax1,
cbar=False)
g1.set_title('Attn-FFN Matrix')
g2 = sns.heatmap(attn_ffn_b_np,
annot=attn_ffn_b_np.round(3),
cmap=sns.color_palette("coolwarm", 7),
linewidth=1.5,
linecolor='black',
ax=ax2,
cbar_ax=ax3)
g2.set_title('Attn-FFN Bias')
f.suptitle("Iteration: {}, Score: {}".format(iteration, np.round(score,
3)))
f.subplots_adjust(top=0.8)
f.savefig(os.path.join(dir_path, 'attnffn_wb_it-{}.png'.format(iteration)),
bbox_inches='tight')
# Last few important layers
ln1 = model.model.transformer_encoder.layers[0].norm1
ln2 = model.model.transformer_encoder.layers[0].norm2
linear1 = model.model.transformer_encoder.layers[0].linear1
linear2 = model.model.transformer_encoder.layers[0].linear2
try:
activation = model.model.transformer_encoder.layers[0].activation
except:
activation = F.relu
# Feeding attn_ffn obtained in the last cell to residual and layer norm layers
res_out = embeddings.squeeze() + attn_ffn
res_ln_out = ln1(res_out)
# Applying a feed forward network (d_model -> d_ffn -> d_model) to the resulting output from last set
pos_ffn = linear2(activation(linear1(res_ln_out)))
# Applying residual + layer norm to the vectors obtained from last step
res_out2 = (res_ln_out + pos_ffn)
res_ln_out2 = ln2(res_out2)
pos_ffn1_w = list(linear1.parameters())[0]
pos_ffn1_b = list(linear1.parameters())[1]
#Plotting Pos_FFN-1 Weights
sns.set(font_scale=1.2)
pos_ffn1_w_np = pos_ffn1_w.detach().cpu().numpy().squeeze()
pos_ffn1_b_np = pos_ffn1_b.detach().cpu().numpy().squeeze()[:, None]
#plt.figure(figsize = (10, 10))
f, (ax1, ax2,
ax3) = plt.subplots(1,
3,
sharey=False,
gridspec_kw={'width_ratios': [6, 2, 0.4]},
figsize=(10, 5))
#f.tight_layout()
g1 = sns.heatmap(pos_ffn1_w_np,
annot=pos_ffn1_w_np.round(3),
cmap=sns.color_palette("coolwarm", 7),
linewidth=1.5,
linecolor='black',
ax=ax1,
cbar=False)
g1.set_title('Pos-FFN Layer-1 Matrix')
g2 = sns.heatmap(pos_ffn1_b_np,
annot=pos_ffn1_b_np.round(3),
cmap=sns.color_palette("coolwarm", 7),
linewidth=1.5,
linecolor='black',
ax=ax2,
cbar_ax=ax3)
g2.set_title('Pos-FFN Layer-1 Bias')
f.suptitle("Iteration: {}, Score: {}".format(iteration, np.round(score,
3)))
f.subplots_adjust(top=0.8)
f.savefig(os.path.join(dir_path, 'posffn1_wb_it-{}.png'.format(iteration)),
bbox_inches='tight')
pos_ffn2_w = list(linear2.parameters())[0]
pos_ffn2_b = list(linear2.parameters())[1]
#Plotting Pos_FFN Weights
sns.set(font_scale=1.2)
pos_ffn2_w_np = pos_ffn2_w.detach().cpu().numpy().squeeze()
pos_ffn2_b_np = pos_ffn2_b.detach().cpu().numpy().squeeze()[:, None]
#plt.figure(figsize = (10, 10))
f, (ax1, ax2,
ax3) = plt.subplots(1,
3,
sharey=False,
gridspec_kw={'width_ratios': [6, 2, 0.4]},
figsize=(10, 5))
#f.tight_layout()
g1 = sns.heatmap(pos_ffn2_w_np,
annot=pos_ffn2_w_np.round(3),
cmap=sns.color_palette("coolwarm", 7),
linewidth=1.5,
linecolor='black',
ax=ax1,
cbar=False)
g1.set_title('Pos-FFN Layer-1 Matrix')
g2 = sns.heatmap(pos_ffn2_b_np,
annot=pos_ffn2_b_np.round(3),
cmap=sns.color_palette("coolwarm", 7),
linewidth=1.5,
linecolor='black',
ax=ax2,
cbar_ax=ax3)
g2.set_title('Pos-FFN Layer-2 Bias')
f.suptitle("Iteration: {}, Score: {}".format(iteration, np.round(score,
3)))
f.subplots_adjust(top=0.8)
f.savefig(os.path.join(dir_path, 'posffn2_wb_it-{}.png'.format(iteration)),
bbox_inches='tight')
# Feeding the encoder representations (obtained above) to the output linear layer (called decoder)
decoder_weights = list(model.model.decoder.parameters())[0].detach()
decoder_reps = torch.mm(res_ln_out2, decoder_weights.T)
sns.set(font_scale=1.2)
decoder_w_np = decoder_weights.detach().cpu().numpy().squeeze()
plt.figure(figsize=(10, 5))
#f,(ax1,ax2, ax3) = plt.subplots(1,3,sharey=False, gridspec_kw={'width_ratios':[6,2, 0.8]}, figsize = (10,5))
#f.tight_layout()
g1 = sns.heatmap(decoder_w_np,
annot=decoder_w_np.round(3),
cmap=sns.color_palette("coolwarm", 7),
linewidth=1.5,
linecolor='black',
cbar=True)
g1.set_title('Decoder Weights (It: {}, Score: {})'.format(
iteration, np.round(score, 3)))
plt.savefig(os.path.join(dir_path,
'decoder_wb_it-{}.png'.format(iteration)),
bbox_inches='tight')
model.to(device)
def future_mask(seq_length):
future_mask = np.triu(np.ones((seq_length, seq_length)),
k=1).astype('bool')
return torch.from_numpy(future_mask)
def _complex_symrand(dim, dtype):
a1, a2 = symrand(dim), symrand(dim)
# add antisymmetric matrix as imag part
a = a1 +1j*(triu(a2)-tril(a2))
return a.astype(dtype)
def subsequent_mask(size):
"Mask out subsequent positions."
attn_shape = (1, size, size)
subsequent_mask = np.triu(np.ones(attn_shape), k=1).astype('uint8')
return torch.from_numpy(subsequent_mask) == 0
import numpy as np
import pytest
from tictactoe import is_winning_game
@pytest.mark.parametrize(
'grid,expected',
(
(np.zeros((3, 3)), False),
(np.triu(np.ones((3, 3)), 1) + np.tril(np.ones((3, 3)) * -1, -1), False),
(np.ones((3, 3)), True),
(np.ones((3, 3)) * -1, True),
(np.eye(3), True),
(np.eye(3) * -1, True),
(np.flipud(np.eye(3)), True),
(np.flipud(np.eye(3)) * -1, True)
)
)
def test_is_winning_game(grid, expected):
assert expected == is_winning_game(grid)
def compute_score_full(self, L, tau):
s = -abs(np.arange(0, L - 1)[:, None] / 2 -
np.arange(L)[None, :]) / tau
s = np.tril(s, 0) + np.triu(s - float("inf"), 1)
s = np.exp(s - s.max(1, keepdims=True))
return s / s.sum(1, keepdims=True)
Será que se eu estudar mais português vou ter um desempenho melhor nas outras matérias? (lembre-se que o ENEM é uma prova que demanda interpretação de texto, então essa prerrogativa pode fazer sentido).
Será que se eu considerar provas de anos anteriores e comparar as correlações com linguagem_códigos elas serão maiores?
A verdade é que uma simples análise de correlação nos gera diversas hipóteses. **Se tiver curiosidade e quiser fazer essas análises fica como um desafio extra!**
Tentamos plotar diversos gráficos para visualizar a correlação de uma melhor forma. Seguem os códigos:
"""
from string import ascii_letters
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
# Generate a mask for the upper triangle
mask = np.triu(np.ones_like(corr, dtype=np.bool))
# Set up the matplotlib figure
f, ax = plt.subplots(figsize=(11, 9))
# Generate a custom diverging colormap
cmap = sns.diverging_palette(220, 10, as_cmap=True)
# Draw the heatmap with the mask and correct aspect ratio
sns.heatmap(corr,
mask=mask,
cmap=cmap,
vmax=.3,
center=0,
square=True,
linewidths=.5,
# just so we can carry it forward later
res = np.load(f)
if 'subjs' in res.keys():
subjs = np.load(f)['subjs']
delme = np.load(f)['delme']
else:
subjs, delme = None, None
ncomps = all_ICs[-1].shape[0]
# this makes all_ICs 2D, with all ncomps for nrep=1, then all ncomps for nrep=2, and etc
all_ICs = np.array(all_ICs).reshape(nreals * ncomps, -1)
# the cross-realization correlation matrix is nreals*ncomps by nreals*ncomps
print 'Computing correlations across all components'
crcm = np.corrcoef(all_ICs)
crcm_abs = np.abs(np.triu(crcm, k=1))
# determine threshold based on valley of CRCM histogram
u_idx = np.triu_indices(crcm.shape[0], k=1)
[bins, centers, patches] = pl.hist(np.abs(crcm)[u_idx], bins=nbins)
cc_threshold = .8 # centers[np.argmin(bins)]
print 'Correlation threshold: %.2f' % cc_threshold
# because we only pay attention at the magnitude of the connections, when we remove a given cell from consideration we mark it as -1. The lower part of the matrix has 0s, and it also has meaning behind it (low connection)
print 'Aligning components'
aligned_ics = [] # list of lists
for ic in range(ncomps):
max_corr_idx = np.argmax(crcm_abs)
idx = np.unravel_index(max_corr_idx, crcm_abs.shape)
# like in the original RAICAR paper, we discover the realization and ICs
re = [d / ncomps for d in idx]
def reJ(self):
return np.triu(self.J) + np.triu(self.J, k=1).T
def generate_twin_graphs(size=100, weight_range=1, connected_rate=0.2, noise_rate=0.2,
edge_feature_dim=3):
'''
G is a template matrix for pattern.
Generate two twin graphs G1, G2 from G for graph matching.
(The numbers of nodes in G1 and G2 may be different from G)
Randomly permute nodes and add some noise to edges and nodes.
Both of edge weights and node attributes can be negative.
size: number of nodes in G.
weight_range: default:1, for scale
'''
# Create G
# M = np.triu((np.random.rand(size,size)*2-1)*weight_range, 1) # upper tri matrix. Diag elements are 0.
# Mi = np.triu(np.random.randint(edge_feature_dim, size=(size, size)),1) # M features type index
connected_nodes = np.triu(np.random.rand(size,size) < connected_rate, 1).astype(int)
# M_tmp = np.zeros([size, size, edge_feature_dim])
M_tmp = {}
for i in range(size):
for j in range(size):
if connected_nodes[i, j]:
# M_tmp[i, j, Mi[i, j]] = M[i, j]
edge_feature = np.random.rand(edge_feature_dim) * weight_range # single edge feature vector
M_tmp[(i, j)] = edge_feature
M_tmp[(j, i)] = edge_feature # make M_tmp symetric matrix
M = M_tmp
# M = M + np.transpose(M, axes=[1, 0, 2])
M1 = dict()
M2 = dict()
M1_size = round((1+random.random()*noise_rate)*size)
M2_size = round((1+random.random()*noise_rate)*size)
idx1 = np.random.permutation(M1_size)
idx2 = np.random.permutation(M2_size)
for (i, j) in M.keys():
M1[(idx1[i], idx1[j])] = M[(i, j)]
M2[(idx2[i], idx2[j])] = M[(i, j)]
# Generate the permutation of G1 and G2
# M1 = np.triu((np.random.rand(M1_size,M1_size)*2-1)*weight_range, 1) # upper tri matrix. Diag elements are 0.
# M1i = np.triu(np.random.randint(edge_feature_dim, size=(M1_size, M1_size)),1) # M1 features type index
connected_nodes_m1 = np.triu(np.random.rand(M1_size,M1_size) < connected_rate, 1).astype(int)
connected_nodes_m1[:size, :size] = connected_nodes
# M1_tmp = np.zeros([size, size, edge_feature_dim])
for i in range(M1_size):
for j in range(M1_size):
if connected_nodes_m1[i, j] and (i, j) not in M1.keys():
# M1_tmp[i, j, M1i[i, j]] = M1[i, j]
edge_feature = np.random.rand(edge_feature_dim) * weight_range # single edge feature vector
M1[(i, j)] = edge_feature
M1[(j, i)] = edge_feature # make M_tmp symetric matrix
# M1 = M1 + np.transpose(M1, axes=[1, 0, 2])
# M2 = np.triu((np.random.rand(M2_size,M2_size)*2-1)*weight_range, 1) # upper tri matrix. Diag elements are 0.
# M2i = np.triu(np.random.randint(edge_feature_dim, size=(M2_size, M2_size)),1) # M2 features type index
connected_nodes_m2 = np.triu(np.random.rand(M2_size,M2_size) < connected_rate, 1).astype(int)
connected_nodes_m2[:size, :size] = connected_nodes
# M2_tmp = np.zeros([size, size, edge_feature_dim])
for i in range(M2_size):
for j in range(M2_size):
if connected_nodes_m2[i, j] and (i, j) not in M2.keys():
# M2_tmp[i, j, M2i[i, j]] = M2[i, j]
edge_feature = np.random.rand(edge_feature_dim) * weight_range # single edge feature vector
M2[(i, j)] = edge_feature
M2[(j, i)] = edge_feature # make M_tmp symetric matrix
# M2 = M2 + np.transpose(M2, axes=[1, 0, 2])
# node attributes
V = (np.random.rand(size)*2-1)*weight_range
V1 = (np.random.rand(M1_size)*2-1)*weight_range
V2 = (np.random.rand(M2_size)*2-1)*weight_range
V1[:size] = V
V2[:size] = V
# Generate random permutation matrix
V1 = V1[idx1]
V2 = V2[idx2]
#The original method for generating noises.
# Adding noise
# Adding noise to nodes
V1_noise = np.random.normal(0,1,M1_size)
V1_noise = V1_noise*weight_range*noise_rate
V1 = V1 + V1_noise
V2_noise = np.random.normal(0,1,M2_size)
V2_noise = V2_noise*weight_range*noise_rate
V2 = V2 + V2_noise
# Adding noise to edges
# The disturbed graph will be also undirected.(Different from the matlab version)
# M1_noise = np.triu(np.random.normal(0,1,[M1_size,M1_size]), 1)
# M1_noise = M1_noise*weight_range*noise_rate
# M1_noise = M1_noise + M1_noise.transpose()
# none_zero = M1.nonzero()
# M1[none_zero] += M1_noise[none_zero]
for i in range(M1_size):
for j in range(M1_size):
if connected_nodes_m1[i, j]:
# M1[i, j, Mi[i, j]] += M1_noise[i, j]
noise = np.random.normal(0, 1, 1)
M1[(i, j)] += noise
M1[(j, i)] += noise
# M2_noise = np.triu(np.random.normal(0,1,[M2_size,M2_size]), 1)
# M2_noise = M2_noise*weight_range*noise_rate
# M2_noise = M2_noise + M2_noise.transpose()
# none_zero = M1.nonzero()
# M1[none_zero] += M1_noise[none_zero]
for i in range(M2_size):
for j in range(M2_size):
if connected_nodes_m2[i, j]:
# M2[i, j, Mi[i, j]] += M2_noise[i, j]
noise = np.random.normal(0, 1, 1)
M2[(i, j)] += noise
M2[(j, i)] += noise
'''
# The second method for generating noises.
M1_noise = np.triu(np.random.rand(M1_size, M1_size), 1)
M1_noise = M1_noise + M1_noise.transpose()
M1_noise = (M1_noise >= noise_rate).astype(int)
M1 = M1*M1_noise
M2_noise = np.triu(np.random.rand(M2_size, M2_size), 1)
M2_noise = M2_noise + M2_noise.transpose()
M2_noise = (M2_noise >= noise_rate).astype(int)
M2 = M2*M2_noise
'''
# try return M1, M2, V1, V2,
# also return idx1, idx2 (The permutation)
return M1, M2, V1, V2, idx1, idx2
def sqr(sqrA):
return np.triu(np.outer(sqrA, sqrA)) + np.triu(np.outer(sqrA, sqrA), k=1)
def rands(rands_ele):
"""
Create random QUBO
"""
return np.triu(np.random.rand(rands_ele, rands_ele))
def split_edges_walk_pooling(
adj: sp.coo_matrix,
validation_frac: float = 0.05,
test_frac: float = 0.1,
seed: int = 0,
validation_edges_in_adj: bool = False,
practical_neg_sample: bool = True,
):
"""Split edges consistent with the method used in Walk Pooling."""
rng = np.random.default_rng(seed)
def random_perm(size, dtype=np.int64):
perm = np.arange(size, dtype=dtype)
rng.shuffle(perm)
return perm
row = adj.row
col = adj.col
mask = row < col
row, col = row[mask], col[mask]
num_edges = row.size
num_nodes = adj.shape[0]
n_v = int(validation_frac *
num_edges) # number of validation positive edges
n_t = int(test_frac * num_edges) # number of test positive edges
# split positive edges
perm = random_perm(num_edges)
row, col = row[perm], col[perm]
r, c = row[:n_v], col[:n_v]
val_pos = np.stack([r, c], axis=1)
r, c = row[n_v:n_v + n_t], col[n_v:n_v + n_t]
test_pos = np.stack([r, c], axis=1)
r, c = row[n_v + n_t:], col[n_v + n_t:]
train_pos = np.stack([r, c], axis=1)
# sample negative edges
if practical_neg_sample:
neg_adj_mask = np.ones((num_nodes, num_nodes), dtype=bool)
neg_adj_mask = np.triu(neg_adj_mask, 1)
neg_adj_mask[row, col] = 0
# Sample the test negative edges first
neg_row, neg_col = np.where(neg_adj_mask)
perm = random_perm(neg_row.size)[:n_t]
neg_row, neg_col = neg_row[perm], neg_col[perm]
test_neg = np.stack([neg_row, neg_col], axis=1)
# Sample the train and val negative edges with only knowing
# the train positive edges
row, col = train_pos.T
neg_adj_mask = np.ones((num_nodes, num_nodes), dtype=bool)
neg_adj_mask = np.triu(neg_adj_mask, 1)
neg_adj_mask[row, col] = 0
# Sample the train and validation negative edges
neg_row, neg_col = np.where(neg_adj_mask)
n_tot = n_v + train_pos.size
perm = random_perm(neg_row.size)[:n_tot]
neg_row, neg_col = neg_row[perm], neg_col[perm]
row, col = neg_row[:n_v], neg_col[:n_v]
val_neg = np.stack([row, col], axis=1)
row, col = neg_row[n_v:], neg_col[n_v:]
train_neg = np.stack([row, col], axis=1)
else:
# If practical_neg_sample == False, the sampled negative edges
# in the training and validation set aware the test set
neg_adj_mask = np.ones((num_nodes, num_nodes), dtype=bool)
neg_adj_mask = np.triu(neg_adj_mask, 1)
neg_adj_mask[row, col] = 0
# Sample all the negative edges and split into val, test, train negs
neg_row, neg_col = np.where(neg_adj_mask)
perm = random_perm(neg_row.size)[:row.size]
neg_row, neg_col = neg_row[perm], neg_col[perm]
row, col = neg_row[:n_v], neg_col[:n_v]
val_neg = np.stack([row, col], axis=1)
row, col = neg_row[n_v:n_v + n_t], neg_col[n_v:n_v + n_t]
test_neg = np.stack([row, col], axis=1)
row, col = neg_row[n_v + n_t:], neg_col[n_v + n_t:]
train_neg = np.stack([row, col], axis=1)
pos = (np.concatenate(
(train_pos,
val_pos), axis=0) if validation_edges_in_adj else train_pos)
adj_train = sp.coo_matrix((np.ones(
(pos.shape[0], ), dtype=np.float32), pos.T),
shape=adj.shape)
adj_train = adj_train + adj_train.T
return (
adj_train,
train_pos,
train_neg,
val_pos,
val_neg,
test_pos,
test_neg,
)
def mul(mulA, mulB):
return np.triu(np.outer(mulA, mulB)) + np.triu(np.outer(mulA, mulB), k=1)
def load_fb_data(n_clusters, get_couples=False):
feat_file = "data/fb/musae_facebook_features.json"
all_features = load_musae_features(feat_file)
n_nodes = all_features.shape[0]
res_edges = load_edges(f"data/fb/fb_res_edges.csv")
adj_complete = sp.csr_matrix(
(np.ones(res_edges.shape[0]), (res_edges[:, 0], res_edges[:, 1])),
shape=(n_nodes, n_nodes))
test_edges = load_edges(f"data/fb/fb_test_edges.csv")
test_matrix = sp.csr_matrix(
(np.ones(test_edges.shape[0]), (test_edges[:, 0], test_edges[:, 1])),
shape=(n_nodes, n_nodes))
valid_edges = load_edges(f"data/fb/fb_train_edges.csv")
valid_matrix = sp.csr_matrix((np.ones(valid_edges.shape[0]),
(valid_edges[:, 0], valid_edges[:, 1])),
shape=(n_nodes, n_nodes))
adj_complete = adj_complete.toarray()
# some values have a self loop, I remove it
for i in range(n_nodes):
adj_complete[i, i] = 0
com_idx_to_clust_idx = {}
node_to_clust = {}
clust_to_node = {}
with open(f"data/fb/{n_clusters}/labels_fb.csv", "r") as fin:
for i, line in enumerate(fin):
clust = int(line.strip())
if (clust_to_node.get(clust) == None):
clust_to_node[clust] = []
com_idx_to_clust_idx[i] = len(clust_to_node[clust])
clust_to_node[clust].append(i)
node_to_clust[i] = clust
if get_couples:
return get_data_couples(all_features, adj_complete, test_matrix,
valid_matrix, node_to_clust, clust_to_node,
com_idx_to_clust_idx)
clust_to_adj = {}
for key in clust_to_node.keys():
tmp_adj = adj_complete[clust_to_node[key], :]
tmp_adj = tmp_adj[:, clust_to_node[key]]
tmp_adj = tmp_adj + tmp_adj.T
tmp_adj = np.triu(tmp_adj)
clust_to_adj[key] = sp.csr_matrix(tmp_adj)
adj_complete = None
test_matrix = test_matrix.toarray()
clust_to_test = {}
for key in clust_to_node.keys():
tmp_adj = test_matrix[clust_to_node[key], :]
tmp_adj = tmp_adj[:, clust_to_node[key]]
tmp_adj = tmp_adj + tmp_adj.T
tmp_adj = np.triu(tmp_adj)
clust_to_test[key] = sp.csr_matrix(tmp_adj)
test_matrix = None
valid_matrix = valid_matrix.toarray()
clust_to_valid = {}
for key in clust_to_node.keys():
tmp_adj = valid_matrix[clust_to_node[key], :]
tmp_adj = tmp_adj[:, clust_to_node[key]]
tmp_adj = tmp_adj + tmp_adj.T
tmp_adj = np.triu(tmp_adj)
clust_to_valid[key] = sp.csr_matrix(tmp_adj)
valid_matrix = None
clust_to_features = {}
for key in clust_to_node.keys():
tmp_feat = all_features[clust_to_node[key], :]
clust_to_features[key] = sp.csr_matrix(tmp_feat)
return clust_to_adj, clust_to_features, clust_to_test, clust_to_valid, clust_to_node, node_to_clust, com_idx_to_clust_idx
def subid_det(y, i, n, u, w="SV"):
input_observations, input_dimensions = u.shape # nu, m
output_observations, output_dimensions = y.shape # ny, l
assert output_observations == input_observations, "Number of data points different in input and output"
assert i > 0, "Number of block rows should be positive"
assert (output_observations - 2 * i + 1) >= (2 * output_dimensions *
i), "Not enough data points"
j = input_observations - (
2 * i - 1) # Determine the number of columns in the Hankel matrices
Y = hankel_matrix(y / np.sqrt(j), 2 * i, j)
U = hankel_matrix(u / np.sqrt(j), 2 * i, j)
m = input_dimensions
l = output_dimensions
# Compute the R factor
R = np.triu(np.linalg.qr(np.vstack((U, Y)).conj().T,
mode='complete')[1]).conj().T # R factor
R = R[:2 * i * (m + l), :2 * i * (m + l)]
# Calculate oblique projection
Rf = R[(2 * m + l) * i:, :] # Future outputs
Rp = np.vstack(
(R[:m * i, :],
R[2 * m * i:(2 * m + l) * i, :])) # Past(inputs and) outputs
Ru = R[m * i:2 * m * i, :] # Future inputs
Rfp = project_on_perpendicular(Rf, Ru) # Perpendicular Future outputs
Rpp = project_on_perpendicular(Rp, Ru) # Perpendicular Past
# The oblique projection "obl/Ufp = Yf/Ufp * pinv(Wp/Ufp) * Wp" Computed as 6.1 on page 166
Ob = matdiv(Rfp, Rpp) @ Rp
# # Funny rankv check (SVD takes too long). This check is needed to avoid rank deficiency warnings
# if np.linalg.norm(Rpp[:, (2 * m+l) * i - 2 * l: (2 * m + l) * i], 'fro') < 1e-10:
# Ob = (Rfp @ np.linalg.pinv(Rpp.conj().T).conj().T) @ Rp # Oblique projection
# else:
# Ob = matdiv(Rfp, Rpp) @ Rp
# Compute the SVD
U, S, V = np.linalg.svd(Ob)
ss = np.diag(S)
# Determine the order from the singular values
U1 = U[:, :n]
# Determine gam and gamm
gam = U1 @ np.diag(np.sqrt(np.diag(ss[:n])))
gamm = gam[:l * (i - 1), :]
# Compute Obm (the second oblique projection)
Rf = R[(2 * m + l) * i + l:, :]
Rp = np.vstack((R[:m * (i + 1), :], R[2 * m * i:(2 * m + l) * i + l, :]))
Ru = R[m * i + m:2 * m * i, :]
Rfp = project_on_perpendicular(Rf, Ru)
Rpp = project_on_perpendicular(Rp, Ru)
Obm = matdiv(Rfp, Rpp) @ Rp
# # Funny rankv check (SVD takes too long). This check is needed to avoid rank deficiency warnings
# if np.linalg.norm(Rpp[:, (2 * m+l) * i - 2 * l: (2 * m + l) * i], 'fro') < 1e-10:
# Ob = (Rfp @ np.linalg.pinv(Rpp.conj().T).conj().T) @ Rp # Oblique projection
# else:
# Ob = matdiv(Rfp, Rpp) @ Rp
# Determine the states Xi and Xip
Xi = np.linalg.pinv(gam) @ Ob
Xip = np.linalg.pinv(gamm) @ Obm
# Solve linear system of equations
Rhs = np.vstack((Xi, R[m * i:m * (i + 1), :]))
Lhs = np.vstack((Xip, R[(2 * m + l) * i:(2 * m + l) * i + l, :]))
sol = matdiv(Lhs, Rhs)
# Extract the system matrices
A = sol[:n, :n]
B = sol[:n, n:n + m]
C = sol[n:n + l, :n]
D = sol[n:n + l, n:n + m]
return A, B, C, D, ss
def load_pubmed_data(n_clusters,
random=False,
sparsest_cut=False,
get_couples=False):
folder = "pubmed" if sparsest_cut == False else "pubmed_sparsest_cut"
data = sio.loadmat(f'data/{folder}/pubmed.mat')
adj_complete = data['W'].toarray()
all_features = data['fea']
res_edges = load_edges(f"data/{folder}/res_edges.csv")
adj_complete = sp.csr_matrix(
(np.ones(res_edges.shape[0]), (res_edges[:, 0], res_edges[:, 1])),
shape=adj_complete.shape)
test_edges = load_edges(f"data/{folder}/test_edges.csv")
test_matrix = sp.csr_matrix(
(np.ones(test_edges.shape[0]), (test_edges[:, 0], test_edges[:, 1])),
shape=adj_complete.shape)
valid_edges = load_edges(f"data/{folder}/train_edges.csv")
valid_matrix = sp.csr_matrix((np.ones(valid_edges.shape[0]),
(valid_edges[:, 0], valid_edges[:, 1])),
shape=adj_complete.shape)
adj_complete = adj_complete.toarray()
# some values have a self loop, I remove it
for i in range(adj_complete.shape[0]):
adj_complete[i, i] = 0
com_idx_to_clust_idx = {}
node_to_clust = {}
clust_to_node = {}
labels_folder = folder if not random else f"{folder}_random"
with open(f"data/{labels_folder}/{n_clusters}/labels_pubmed.csv",
"r") as fin:
for i, line in enumerate(fin):
clust = int(line.strip())
if (clust_to_node.get(clust) == None):
clust_to_node[clust] = []
com_idx_to_clust_idx[i] = len(clust_to_node[clust])
clust_to_node[clust].append(i)
node_to_clust[i] = clust
if get_couples:
return get_data_couples(all_features, adj_complete, test_matrix,
valid_matrix, node_to_clust, clust_to_node,
com_idx_to_clust_idx)
clust_to_adj = {}
for key in clust_to_node.keys():
tmp_adj = adj_complete[clust_to_node[key], :]
tmp_adj = tmp_adj[:, clust_to_node[key]]
tmp_adj = tmp_adj + tmp_adj.T
tmp_adj = np.triu(tmp_adj)
print("TRIUUUU")
clust_to_adj[key] = sp.csr_matrix(tmp_adj)
adj_complete = None
test_matrix = test_matrix.toarray()
clust_to_test = {}
for key in clust_to_node.keys():
tmp_adj = test_matrix[clust_to_node[key], :]
tmp_adj = tmp_adj[:, clust_to_node[key]]
tmp_adj = tmp_adj + tmp_adj.T
tmp_adj = np.triu(tmp_adj)
clust_to_test[key] = sp.csr_matrix(tmp_adj)
test_matrix = None
valid_matrix = valid_matrix.toarray()
clust_to_valid = {}
for key in clust_to_node.keys():
tmp_adj = valid_matrix[clust_to_node[key], :]
tmp_adj = tmp_adj[:, clust_to_node[key]]
tmp_adj = tmp_adj + tmp_adj.T
tmp_adj = np.triu(tmp_adj)
clust_to_valid[key] = sp.csr_matrix(tmp_adj)
valid_matrix = None
clust_to_features = {}
for key in clust_to_node.keys():
tmp_feat = all_features[clust_to_node[key], :]
clust_to_features[key] = sp.csr_matrix(tmp_feat)
return clust_to_adj, clust_to_features, clust_to_test, clust_to_valid, clust_to_node, node_to_clust, com_idx_to_clust_idx
def load_amazon_electronics_computers_data(n_clusters,
random=False,
is_photos=False,
get_couples=False):
print(f"random: {random}")
path = "amazon_electronics_photo" if is_photos else "amazon_electronics_computers"
data = np.load(f"data/{path}/{path}.npz")
data = from_flat_dict(data)
adj_complete = data["adj_matrix"]
all_features = data['attr_matrix']
res_edges = load_edges(f"data/{path}/{path}.npz_res_edges.csv")
adj_complete = sp.csr_matrix(
(np.ones(res_edges.shape[0]), (res_edges[:, 0], res_edges[:, 1])),
shape=adj_complete.shape)
test_edges = load_edges(f"data/{path}/{path}.npz_test_edges.csv")
test_matrix = sp.csr_matrix(
(np.ones(test_edges.shape[0]), (test_edges[:, 0], test_edges[:, 1])),
shape=adj_complete.shape)
valid_edges = load_edges(f"data/{path}/{path}.npz_train_edges.csv")
valid_matrix = sp.csr_matrix((np.ones(valid_edges.shape[0]),
(valid_edges[:, 0], valid_edges[:, 1])),
shape=adj_complete.shape)
adj_complete = adj_complete.toarray()
# some values have a self loop, I remove it
for i in range(adj_complete.shape[0]):
adj_complete[i, i] = 0
com_idx_to_clust_idx = {}
node_to_clust = {}
clust_to_node = {}
labels_folder = path if not random else f"{path}_random"
with open(f"data/{labels_folder}/{n_clusters}/labels_{path}.npz.csv",
"r") as fin:
for i, line in enumerate(fin):
clust = int(line.strip())
if (clust_to_node.get(clust) == None):
clust_to_node[clust] = []
com_idx_to_clust_idx[i] = len(clust_to_node[clust])
clust_to_node[clust].append(i)
node_to_clust[i] = clust
if get_couples:
return get_data_couples(all_features, adj_complete, test_matrix,
valid_matrix, node_to_clust, clust_to_node,
com_idx_to_clust_idx)
clust_to_adj = {}
for key in clust_to_node.keys():
tmp_adj = adj_complete[clust_to_node[key], :]
tmp_adj = tmp_adj[:, clust_to_node[key]]
tmp_adj = tmp_adj + tmp_adj.T
tmp_adj = np.triu(tmp_adj)
clust_to_adj[key] = sp.csr_matrix(tmp_adj)
adj_complete = None
test_matrix = test_matrix.toarray()
clust_to_test = {}
for key in clust_to_node.keys():
tmp_adj = test_matrix[clust_to_node[key], :]
tmp_adj = tmp_adj[:, clust_to_node[key]]
tmp_adj = tmp_adj + tmp_adj.T
tmp_adj = np.triu(tmp_adj)
clust_to_test[key] = sp.csr_matrix(tmp_adj)
test_matrix = None
valid_matrix = valid_matrix.toarray()
clust_to_valid = {}
for key in clust_to_node.keys():
tmp_adj = valid_matrix[clust_to_node[key], :]
tmp_adj = tmp_adj[:, clust_to_node[key]]
tmp_adj = tmp_adj + tmp_adj.T
tmp_adj = np.triu(tmp_adj)
clust_to_valid[key] = sp.csr_matrix(tmp_adj)
valid_matrix = None
all_features = data['attr_matrix']
clust_to_features = {}
for key in clust_to_node.keys():
tmp_feat = all_features[clust_to_node[key], :]
clust_to_features[key] = sp.csr_matrix(tmp_feat)
return clust_to_adj, clust_to_features, clust_to_test, clust_to_valid, clust_to_node, node_to_clust, com_idx_to_clust_idx
def update(self, arfitness):
"""
Update values of method from new evaluated generation
:param arfitness: list of function values to individuals
:type arfitness: list
"""
self.counteval += self.lamda
self.arfitness = arfitness
# sort by fitness and compute weighted mean into xmean
self.arindex = np.argsort(self.arfitness)
self.arfitness = self.arfitness[self.arindex]
self.xmean = np.dot(self.arx[self.arindex[:self.mu]].T, self.weights)
self.zmean = np.dot(self.arz[self.arindex[:self.mu]].T, self.weights)
self.ps = np.dot((1 - self.cs), self.ps) + np.dot(
(np.sqrt(self.cs *
(2 - self.cs) * self.mueff)), np.dot(self.B, self.zmean))
self.hsig = np.linalg.norm(
self.ps) / np.sqrt(1 -
(1 - self.cs)**(2 * self.counteval / self.lamda)
) / self.chiN < 1.4 + 2 / (self.N + 1)
self.pc = np.dot((1 - self.cc), self.pc) + np.dot(
np.dot(self.hsig, np.sqrt(self.cc * (2 - self.cc) * self.mueff)),
np.dot(np.dot(self.B, self.D), self.zmean),
)
# adapt covariance matrix C
self.C = (np.dot((1 - self.c1 - self.cmu), self.C) + np.dot(
self.c1,
((self.pc * self.pc.T) + np.dot(
(1 - self.hsig) * self.cc * (2 - self.cc), self.C)),
) + np.dot(
self.cmu,
np.dot(
np.dot(
np.dot(np.dot(self.B, self.D),
self.arz[self.arindex[:self.mu]].T),
np.diag(self.weights),
),
(np.dot(np.dot(self.B, self.D),
self.arz[self.arindex[:self.mu]].T)).T,
),
))
# adapt step size sigma
self.sigma = self.sigma * np.exp(
(self.cs / self.damps) * (np.linalg.norm(self.ps) / self.chiN - 1))
# diagonalization
if (self.counteval - self.eigenval > self.lamda /
(self.c1 + self.cmu) / self.N / 10):
self.eigenval = self.counteval
self.C = np.triu(self.C) + np.transpose(np.triu(self.C, 1))
self.D, self.B = np.linalg.eig(self.C)
self.D = np.diag(np.sqrt(self.D))
# history
self.history["short_best"].append(arfitness[0])
if len(self.history["short_best"]) >= self.short_history_len:
self.history["short_best"].popleft()
if self.generation % 5 == 0: # last 20 %
self.history["long_best"].append(arfitness[0])
self.history["long_median"].append(np.median(arfitness))
if len(self.history["long_best"]) >= self.long_history_len_up:
self.history["long_best"].popleft()
self.history["long_median"].popleft()
self.checkStop()
if self.generation % 20 == 0:
self.logState()
coded by: Rakeeb
code for: implenting Gauss Seidel method
'''
import numpy as np
x_exact= np.array([7.859713071,0.422926408,-0.073592239,-0.540643016,0.010626163]) #exact solution given
a= np.array([[0.2,0.1,1,1,0],[0.1,4,-1,1,-1],[1,-1,60,0,-2],[1,1,0,8,4],[0,-1,-2,4,700]])
b= np.array([1,2,3,4,5])
# Gauss Seidel method:
x= np.zeros(b.size) # initial value
U= np.triu(a,k=1) #upper triangular part of "a" without main diagonal
D_L= np.tril(a,k=0) #lower triangular part of "a" with the main diagonal
'''
As was done in class, U is the upper triangular part and D_L is the (D+L) matrix, where D is the diagonal part
and L is the lower triangular part of the given matrix. We have to take the inverse of the (D+L) part and
multiply it to the right hand side.
'''
D_L_inv= np.linalg.inv(D_L)
i=0 # for counting iteration number
while (any(np.abs(x_exact[j]-x[j])>0.01 for j in range (b.size))):
s= b-np.matmul(U,x)
x= np.matmul(D_L_inv,s)
i=i+1
print('solution by Gauss-Seidel method: ',x ,'\nNumber of itarations needed: ',i )
embedding = node_position_model.fit_transform(X.T).T
# #############################################################################
# Visualization
plt.figure(1, facecolor='w', figsize=(10, 8))
plt.clf()
ax = plt.axes([0., 0., 1., 1.])
plt.axis('off')
# Display a graph of the partial correlations
partial_correlations = edge_model.precision_.copy()
d = 1 / np.sqrt(np.diag(partial_correlations))
partial_correlations *= d
partial_correlations *= d[:, np.newaxis]
non_zero = (np.abs(np.triu(partial_correlations, k=1)) > 0.02)
# Plot the nodes using the coordinates of our embedding
plt.scatter(embedding[0], embedding[1], s=100 * d ** 2, c=labels,
cmap=plt.cm.nipy_spectral)
# Plot the edges
start_idx, end_idx = np.where(non_zero)
# a sequence of (*line0*, *line1*, *line2*), where::
# linen = (x0, y0), (x1, y1), ... (xm, ym)
segments = [[embedding[:, start], embedding[:, stop]]
for start, stop in zip(start_idx, end_idx)]
values = np.abs(partial_correlations[non_zero])
lc = LineCollection(segments,
zorder=0, cmap=plt.cm.hot_r,
norm=plt.Normalize(0, .7 * values.max()))
def main(train_path, out_folder_path):
# Allow Altair to make plots using more than 5000 rows
alt.data_transformers.disable_max_rows()
# Read data from file path
train = pd.read_csv(train_path)
columns = [
'housing_median_age', 'total_rooms', 'total_bedrooms', 'population',
'households', 'median_income', 'ocean_proximity', 'latitude',
'longitude'
]
X_train = train[columns]
y_train = train['median_house_value']
def make_chart(x, x_title):
"""
Creates an altair scatterplot with the input on the x-axis and
the median house value on the y-axis
Parameters
----------
x: string
the column name of the x-axis column to be created
x_title: string
the title of the x-axis (and to be used in the chart title)
Returns
----------
altair chart object
scatterplot of defined x compared to median house value
"""
chart = alt.Chart(train).mark_point(opacity=0.2).encode(
alt.X(x, title=x_title),
alt.Y('median_house_value:Q',
title="Median House Value")).properties(
width=300,
height=250,
title="Median House Value per " + x_title)
return chart
# Make charts and save them
make_chart('housing_median_age',
"House Median Age").save(out_folder_path +
'median-age_scatterplot.png')
make_chart('total_rooms',
"Total Rooms").save(out_folder_path +
'total-rooms_scatterplot.png')
make_chart('total_bedrooms',
"Total Bedrooms").save(out_folder_path +
'total-bedrooms_scatterplot.png')
make_chart('population', "Population").save(out_folder_path +
'population_scatterplot.png')
make_chart('households', "Households").save(out_folder_path +
'households_scatterplot.png')
make_chart('median_income',
"Median Income").save(out_folder_path +
'median-income_scatterplot.png')
# Look at the relationship between total_rooms and total_bedrooms
alt.Chart(X_train).mark_point(opacity=0.2).encode(
alt.X('total_bedrooms', title="Total Bedrooms"),
alt.Y('total_rooms', title="Total Rooms")).properties(
width=300,
height=250,
title="Relationship between Bedroom and Room Counts").save(
out_folder_path + 'total-rooms_total-bedrooms.png')
# Visualize Correlation Matrix between variables
# Rename correlation matrix titles
corrmatrix_titles = {
"housing_median_age": "Median House Age",
"total_rooms": "Total Rooms",
"total_bedrooms": "Total Bedrooms",
"population": "Population",
"households": "Households",
"median_income": "Median Income",
"latitude": "Latitude",
"longitude": "Longitude",
"median_house_value": "Median House Value"
}
corrMatrix = train.corr()
corrMatrix = corrMatrix.rename(columns=corrmatrix_titles)
corrMatrix = corrMatrix.rename(index=corrmatrix_titles)
# Create mask for upper triangle
upper_mask = np.triu(np.ones_like(corrMatrix, dtype=np.bool))
# Create matplotlib figure
corr_plot, ax = plt.subplots(figsize=(12, 12))
# Create heatmap
cmap = sns.diverging_palette(240, 10, as_cmap=True)
# Overlay mask on heat map
sns.heatmap(corrMatrix,
mask=upper_mask,
cmap=cmap,
vmax=0.5,
center=0,
square=True,
linewidths=.8,
cbar_kws={"shrink": 0.5})
plt.title('Correlation Matrix')
# Save heatmap to file
corr_plot.savefig(out_folder_path + 'correlation_heatmap.png')
# Create Variance Inflation Factor Table
# Drop `ocean_proximity`, `latitude` and `longitude` columns
mc_data = pd.DataFrame.drop(
X_train, columns=['ocean_proximity', 'longitude', 'latitude'])
mc_data['intercept'] = 1
# Create and return dataframe with VIFs
vif = pd.DataFrame()
vif['variable'] = mc_data.columns
vif['VIF'] = [
variance_inflation_factor(mc_data.values, i)
for i in range(mc_data.shape[1])
]
vif.to_csv(out_folder_path + 'vif_table.csv', index=False)
# Sources:
# https://campus.datacamp.com/courses/generalized-linear-models-in-python/multivariable-logistic-regression?ex=4
assert os.path.isfile(out_folder_path + 'correlation_heatmap.png')
assert os.path.isfile(out_folder_path + 'households_scatterplot.png')
assert os.path.isfile(out_folder_path + 'median-age_scatterplot.png')
assert os.path.isfile(out_folder_path + 'median-income_scatterplot.png')
assert os.path.isfile(out_folder_path + 'population_scatterplot.png')
assert os.path.isfile(out_folder_path + 'total-bedrooms_scatterplot.png')
assert os.path.isfile(out_folder_path + 'total-rooms_scatterplot.png')
assert os.path.isfile(out_folder_path + 'total-rooms_total-bedrooms.png')
assert os.path.isfile(out_folder_path + 'vif_table.csv')
def test_tsqr_uncertain(m_min, n_max, chunks, vary_rows, vary_cols,
error_type):
mat = cupy.random.rand(m_min * 2, n_max)
m, n = m_min * 2, n_max
mat[0:m_min, 0] += 1
_c0 = mat[:, 0]
_r0 = mat[0, :]
c0 = da.from_array(_c0, chunks=m_min, name="c", asarray=False)
r0 = da.from_array(_r0, chunks=n_max, name="r", asarray=False)
data = da.from_array(mat, chunks=chunks, name="A", asarray=False)
if vary_rows:
data = data[c0 > 0.5, :]
mat = mat[_c0 > 0.5, :]
m = mat.shape[0]
if vary_cols:
data = data[:, r0 > 0.5]
mat = mat[:, _r0 > 0.5]
n = mat.shape[1]
# qr
m_q = m
n_q = min(m, n)
m_r = n_q
n_r = n
# svd
m_u = m
n_u = min(m, n)
n_s = n_q
m_vh = n_q
n_vh = n
d_vh = max(m_vh, n_vh) # full matrix returned
if error_type is None:
# test QR
q, r = da.linalg.tsqr(data)
q = q.compute() # because uncertainty
r = r.compute()
assert_eq((m_q, n_q), q.shape) # shape check
assert_eq((m_r, n_r), r.shape) # shape check
assert_eq(mat, np.dot(q, r)) # accuracy check
assert_eq(np.eye(n_q, n_q), np.dot(q.T, q)) # q must be orthonormal
assert_eq(r, np.triu(r)) # r must be upper triangular
# test SVD
u, s, vh = da.linalg.tsqr(data, compute_svd=True)
u = u.compute() # because uncertainty
s = s.compute()
vh = vh.compute()
s_exact = np.linalg.svd(mat)[1]
assert_eq(s, s_exact) # s must contain the singular values
assert_eq((m_u, n_u), u.shape) # shape check
assert_eq((n_s, ), s.shape) # shape check
assert_eq((d_vh, d_vh), vh.shape) # shape check
assert_eq(np.eye(n_u, n_u), np.dot(u.T, u)) # u must be orthonormal
assert_eq(np.eye(d_vh, d_vh), np.dot(vh,
vh.T)) # vh must be orthonormal
assert_eq(mat, np.dot(np.dot(u, np.diag(s)),
vh[:n_q])) # accuracy check
else:
with pytest.raises(error_type):
q, r = da.linalg.tsqr(data)
with pytest.raises(error_type):
u, s, vh = da.linalg.tsqr(data, compute_svd=True)
def get_subseq_mask(self, size):
k = 1 + size[-1] - size[-2]
subsequent_mask = np.triu(np.ones(size), k=k).astype('uint8')
subsequent_mask = torch.from_numpy(subsequent_mask).to(device)
return subsequent_mask
def test_invalid_adjacency(self, dim):
"""Test if function raises a ``ValueError`` for a matrix that is not symmetric"""
with pytest.raises(ValueError, match="Input must be a NumPy array"):
adj_asym = np.triu(np.ones((dim, dim)))
sample.sample(A=adj_asym, n_mean=1.0)
def similarity_fig_from_weighted_prediction(round_idx,
respondent_idx,
similarity_edge_list=None,
weighted_pred=None):
"""
The similarity_edge_list has the priority for construction than the weighted prediction.
:param round_idx: integer, ranging from 1 to 10
:param respondent_idx: id of respondents, ranging from the 1 to 35
:param similarity_edge_list: edges between similar points, a list of tuples(x_i, x_j),
indicating that x_i and x_j are similar
:param weighted_pred: confident of confidence weighted prediction,
either at a specific round_idx or for a specific respondent at all times
:return: a similarity connection graph of the 50 defendants, and the similarity_edge_list
"""
_, X_test, _, y_test, _ = load_dataset(onehot=True)
# (x,y) position of each nodes, here I set them into the circle for appreciation of beauty
pos = dict()
for i in range(50):
pos[X_test.index.values[i]] = (np.cos(2 * np.pi * i / 50),
np.sin(2 * np.pi * i / 50))
# add all the nodes to the network
G = nx.Graph()
G.add_nodes_from(pos.keys())
for n, p in pos.items():
G.node[n]['pos'] = p
# similarity_edge_list has the privilege to be used for the construction of the network
if similarity_edge_list is None:
if weighted_pred is None:
# use the 14 classes weighted prediction if both are None
y_test = weighted_prediction_round(
round_idx=round_idx)[respondent_idx - 1].values.reshape(-1, 1)
else:
y_test = weighted_pred[respondent_idx - 1].values.reshape(-1, 1)
# to integrate the labels into a pairwise fashion
mask = (y_test[None] == y_test[:, None])[:, :, 0]
a, b = np.nonzero(np.triu(mask, k=1))
similarity_edge_list = [(X_test.index.values[a_],
X_test.index.values[b_])
for a_, b_ in zip(a, b)]
G.add_edges_from(similarity_edge_list)
'''Make the Graph via Plot.ly'''
edge_trace = go.Scatter(x=[],
y=[],
line=dict(width=0.5, color='#888'),
hoverinfo='none',
mode='lines')
for edge in G.edges():
x0, y0 = G.node[edge[0]]['pos']
x1, y1 = G.node[edge[1]]['pos']
edge_trace['x'] += tuple([x0, x1, None])
edge_trace['y'] += tuple([y0, y1, None])
node_trace = go.Scatter(
x=[],
y=[],
text=[],
mode='markers',
hoverinfo='text',
marker=dict(
showscale=True,
# color-scale options
# 'Greys' | 'YlGnBu' | 'Greens' | 'YlOrRd' | 'Bluered' | 'RdBu' |
# 'Reds' | 'Blues' | 'Picnic' | 'Rainbow' | 'Portland' | 'Jet' |
# 'Hot' | 'Blackbody' | 'Earth' | 'Electric' | 'Viridis' |
colorscale='YlGnBu',
reversescale=True,
color=[],
size=10,
colorbar=dict(thickness=15,
title='Node Connections',
xanchor='left',
titleside='right'),
line=dict(width=2)))
for node in G.nodes():
x, y = G.node[node]['pos']
node_trace['x'] += tuple([x])
node_trace['y'] += tuple([y])
for node, adjacencies in enumerate(G.adjacency()):
node_trace['marker']['color'] += tuple([len(adjacencies[1])])
node_info = '# of connections: ' + str(len(adjacencies[1])) + '<br>Defendant_ID: '\
+ str(X_test.index.values[node])
node_trace['text'] += tuple([node_info])
fig = go.Figure(
data=[edge_trace, node_trace],
layout=go.Layout(
width=700,
height=600,
title=
'<br>Similarity Graph of COMPAS Defendants (Respondent-%2d_Week-%2d)'
% (respondent_idx, round_idx),
titlefont=dict(size=16),
showlegend=False,
hovermode='closest',
margin=dict(b=20, l=50, r=50, t=40),
xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)))
return fig, list(G.edges())
def test_tril_triu_non_square_arrays():
A = cupy.random.randint(0, 11, (30, 35))
dA = da.from_array(A, chunks=(5, 5), asarray=False)
assert_eq(da.triu(dA), np.triu(A))
assert_eq(da.tril(dA), np.tril(A))
def leastsq(func,
x0,
args=(),
Dfun=None,
full_output=0,
col_deriv=0,
ftol=1.49012e-8,
xtol=1.49012e-8,
gtol=0.0,
maxfev=0,
epsfcn=None,
factor=100,
diag=None):
"""
Minimize the sum of squares of a set of equations.
::
x = arg min(sum(func(y)**2,axis=0))
y
Parameters
----------
func : callable
should take at least one (possibly length N vector) argument and
returns M floating point numbers. It must not return NaNs or
fitting might fail.
x0 : ndarray
The starting estimate for the minimization.
args : tuple, optional
Any extra arguments to func are placed in this tuple.
Dfun : callable, optional
A function or method to compute the Jacobian of func with derivatives
across the rows. If this is None, the Jacobian will be estimated.
full_output : bool, optional
non-zero to return all optional outputs.
col_deriv : bool, optional
non-zero to specify that the Jacobian function computes derivatives
down the columns (faster, because there is no transpose operation).
ftol : float, optional
Relative error desired in the sum of squares.
xtol : float, optional
Relative error desired in the approximate solution.
gtol : float, optional
Orthogonality desired between the function vector and the columns of
the Jacobian.
maxfev : int, optional
The maximum number of calls to the function. If `Dfun` is provided
then the default `maxfev` is 100*(N+1) where N is the number of elements
in x0, otherwise the default `maxfev` is 200*(N+1).
epsfcn : float, optional
A variable used in determining a suitable step length for the forward-
difference approximation of the Jacobian (for Dfun=None).
Normally the actual step length will be sqrt(epsfcn)*x
If epsfcn is less than the machine precision, it is assumed that the
relative errors are of the order of the machine precision.
factor : float, optional
A parameter determining the initial step bound
(``factor * || diag * x||``). Should be in interval ``(0.1, 100)``.
diag : sequence, optional
N positive entries that serve as a scale factors for the variables.
Returns
-------
x : ndarray
The solution (or the result of the last iteration for an unsuccessful
call).
cov_x : ndarray
Uses the fjac and ipvt optional outputs to construct an
estimate of the jacobian around the solution. None if a
singular matrix encountered (indicates very flat curvature in
some direction). This matrix must be multiplied by the
residual variance to get the covariance of the
parameter estimates -- see curve_fit.
infodict : dict
a dictionary of optional outputs with the key s:
``nfev``
The number of function calls
``fvec``
The function evaluated at the output
``fjac``
A permutation of the R matrix of a QR
factorization of the final approximate
Jacobian matrix, stored column wise.
Together with ipvt, the covariance of the
estimate can be approximated.
``ipvt``
An integer array of length N which defines
a permutation matrix, p, such that
fjac*p = q*r, where r is upper triangular
with diagonal elements of nonincreasing
magnitude. Column j of p is column ipvt(j)
of the identity matrix.
``qtf``
The vector (transpose(q) * fvec).
mesg : str
A string message giving information about the cause of failure.
ier : int
An integer flag. If it is equal to 1, 2, 3 or 4, the solution was
found. Otherwise, the solution was not found. In either case, the
optional output variable 'mesg' gives more information.
Notes
-----
"leastsq" is a wrapper around MINPACK's lmdif and lmder algorithms.
cov_x is a Jacobian approximation to the Hessian of the least squares
objective function.
This approximation assumes that the objective function is based on the
difference between some observed target data (ydata) and a (non-linear)
function of the parameters `f(xdata, params)` ::
func(params) = ydata - f(xdata, params)
so that the objective function is ::
min sum((ydata - f(xdata, params))**2, axis=0)
params
"""
x0 = asarray(x0).flatten()
n = len(x0)
if not isinstance(args, tuple):
args = (args, )
shape, dtype = _check_func('leastsq', 'func', func, x0, args, n)
m = shape[0]
if n > m:
raise TypeError('Improper input: N=%s must not exceed M=%s' % (n, m))
if epsfcn is None:
epsfcn = finfo(dtype).eps
if Dfun is None:
if maxfev == 0:
maxfev = 200 * (n + 1)
retval = _minpack._lmdif(func, x0, args, full_output, ftol, xtol, gtol,
maxfev, epsfcn, factor, diag)
else:
if col_deriv:
_check_func('leastsq', 'Dfun', Dfun, x0, args, n, (n, m))
else:
_check_func('leastsq', 'Dfun', Dfun, x0, args, n, (m, n))
if maxfev == 0:
maxfev = 100 * (n + 1)
retval = _minpack._lmder(func, Dfun, x0, args, full_output, col_deriv,
ftol, xtol, gtol, maxfev, factor, diag)
errors = {
0: ["Improper input parameters.", TypeError],
1: [
"Both actual and predicted relative reductions "
"in the sum of squares\n are at most %f" % ftol, None
],
2: [
"The relative error between two consecutive "
"iterates is at most %f" % xtol, None
],
3: [
"Both actual and predicted relative reductions in "
"the sum of squares\n are at most %f and the "
"relative error between two consecutive "
"iterates is at \n most %f" % (ftol, xtol), None
],
4: [
"The cosine of the angle between func(x) and any "
"column of the\n Jacobian is at most %f in "
"absolute value" % gtol, None
],
5: [
"Number of calls to function has reached "
"maxfev = %d." % maxfev, ValueError
],
6: [
"ftol=%f is too small, no further reduction "
"in the sum of squares\n is possible."
"" % ftol, ValueError
],
7: [
"xtol=%f is too small, no further improvement in "
"the approximate\n solution is possible." % xtol, ValueError
],
8: [
"gtol=%f is too small, func(x) is orthogonal to the "
"columns of\n the Jacobian to machine "
"precision." % gtol, ValueError
],
'unknown': ["Unknown error.", TypeError]
}
info = retval[-1] # The FORTRAN return value
if info not in [1, 2, 3, 4] and not full_output:
if info in [5, 6, 7, 8]:
warnings.warn(errors[info][0], RuntimeWarning)
else:
try:
raise errors[info][1](errors[info][0])
except KeyError:
raise errors['unknown'][1](errors['unknown'][0])
mesg = errors[info][0]
if full_output:
cov_x = None
if info in [1, 2, 3, 4]:
from numpy.dual import inv
from numpy.linalg import LinAlgError
perm = take(eye(n), retval[1]['ipvt'] - 1, 0)
r = triu(transpose(retval[1]['fjac'])[:n, :])
R = dot(r, perm)
try:
cov_x = inv(dot(transpose(R), R))
except (LinAlgError, ValueError):
pass
return (retval[0], cov_x) + retval[1:-1] + (mesg, info)
else:
return (retval[0], info)
