# Python numpy.diagflat() 使用实例

The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.

Example 1

```def train(self):
X = self.train_x
y = self.train_y
# include intercept
beta = np.zeros((self.p+1, 1))

iter_times = 0
while True:
e_X = np.exp(X @ beta)
# N x 1
self.P = e_X / (1 + e_X)
# W is a vector
self.W = (self.P * (1 - self.P)).flatten()
# X.T * W equal (X.T @ diagflat(W)).diagonal()
beta = beta + self.math.pinv((X.T * self.W) @ X) @ X.T @ (y - self.P)

iter_times += 1
if iter_times > self.max_iter:
break

self.beta_hat = beta ```

Example 2

```def latent_correlation(self):
"""Compute correlation matrix among latent features.

This computes the generalization of Pearson's correlation to discrete
data. Let I(X;Y) be the mutual information. Then define correlation as

rho(X,Y) = sqrt(1 - exp(-2 I(X;Y)))

Returns:
A [V, V]-shaped numpy array of feature-feature correlations.
"""
logger.debug('computing latent correlation')
V, E, M, R = self._VEMR
edge_probs = self._edge_probs
vert_probs = self._vert_probs
result = np.zeros([V, V], np.float32)
for root in range(V):
messages = np.empty([V, M, M])
program = make_propagation_program(self._tree.tree_grid, root)
for op, v, v2, e in program:
if op == OP_ROOT:
# Initialize correlation at this node.
messages[v, :, :] = np.diagflat(vert_probs[v, :])
elif op == OP_OUT:
# Propagate correlation outward from parent to v.
trans = edge_probs[e, :, :]
if v > v2:
trans = trans.T
messages[v, :, :] = np.dot(  #
trans / vert_probs[v2, np.newaxis, :],
messages[v2, :, :])
for v in range(V):
result[root, v] = correlation(messages[v, :, :])
return result ```

Example 3

```def train(self):
super().train()
sigma = self.Sigma_hat
D_, U = LA.eigh(sigma)
D = np.diagflat(D_)
self.A = np.power(LA.pinv(D), 0.5) @ U.T ```

Example 4

```def train(self):
super().train()
W = self.Sigma_hat
# prior probabilities (K, 1)
Pi = self.Pi
# class centroids (K, p)
Mu = self.Mu
p = self.p
# the number of class
K = self.n_class
# the dimension you want
L = self.L

# Mu is (K, p) matrix, Pi is (K, 1)
mu = np.sum(Pi * Mu, axis=0)
B = np.zeros((p, p))

for k in range(K):
# vector @ vector equal scalar, use vector[:, None] to transform to matrix
# vec[:, None] equal to vec.reshape((1, vec.shape[0]))
B = B + Pi[k]*((Mu[k] - mu)[:, None] @ ((Mu[k] - mu)[None, :]))

# Be careful, the `eigh` method get the eigenvalues in ascending , which is opposite to R.
Dw, Uw = LA.eigh(W)
# reverse the Dw_ and Uw
Dw = Dw[::-1]
Uw = np.fliplr(Uw)

W_half = self.math.pinv(np.diagflat(Dw**0.5) @ Uw.T)
B_star = W_half.T @ B @ W_half
D_, V = LA.eigh(B_star)

# reverse V
V = np.fliplr(V)

# overwrite `self.A` so that we can reuse `predict` method define in parent class
self.A = np.zeros((L, p))
for l in range(L):
self.A[l, :] = W_half @ V[:, l] ```

Example 5

```def _update_(U, D, d, lambda_):
"""Go from u(n) to u(n+1)."""
I = np.identity(3)

m = U.T.dot(d)
p = (I - U.dot(U.T)).dot(d)
p_norm = np.linalg.norm(p)

# Make p and m column vectors
p = p[np.newaxis].T
m = m[np.newaxis].T

U_left = np.hstack((U, p/p_norm))
Q = np.hstack((lambda_ * D, m))
Q = np.vstack((Q, [0, 0, p_norm]))

# SVD
U_right, D_new, V_left = np.linalg.svd(Q)

# Get rid of the smallest eigenvalue
D_new = D_new[0:2]
D_new = np.diagflat(D_new)

U_right = U_right[:, 0:2]

return U_left.dot(U_right), D_new ```

Example 6

```def rosenberger(dataX, dataY, dataZ, lambda_):
"""
Separate P and non-P wavefield from 3-component data.

Return a two set of 3-component traces.
"""
# Construct the data matrix
A = np.vstack((dataZ, dataX, dataY))

# SVD of the first 3 samples:
U, D, V = np.linalg.svd(A[:, 0:3])

# Get rid of the smallest eigenvalue
D = D[0:2]
D = np.diagflat(D)
U = U[:, 0:2]

save_U = np.zeros(len(dataX))
save_U[0] = abs(U[0, 0])

Dp = np.zeros((3, len(dataX)))
Ds = np.zeros((3, len(dataX)))
Dp[:, 0] = abs(U[0, 0]) * A[:, 2]
Ds[:, 0] = (1 - abs(U[0, 0])) * A[:, 2]

# Loop over all the values
for i in range(1, A.shape[1]):
d = A[:, i]
U, D = _update_(U, D, d, lambda_)

Dp[:, i] = abs(U[0, 0]) * d
Ds[:, i] = (1-abs(U[0, 0])) * d

save_U[i] = abs(U[0, 0])

return Dp, Ds, save_U ```

Example 7

`def eye(n): return diagflat(ones(n)) `

Example 8

```def diagflat(a, k=0):
if isinstance(a, garray): return a.diagflat(k)
else: return numpy.diagflat(a,k) ```

Example 9

```def diagflat(self, k=0):
if self.ndim!=1: return self.ravel().diagflat(k)
if k!=0: raise NotImplementedError('k!=0 for garray.diagflat')
selfSize = self.size
ret = zeros((selfSize, selfSize))
ret.ravel()[:-1].reshape((selfSize-1, selfSize+1))[:, 0] = self[:-1]
if selfSize!=0: ret.ravel()[-1] = self[-1]
return ret ```

Example 10

```def diagonal(self):
if self.ndim==1: return self.diagflat()
if self.ndim==2:
if self.shape[0] > self.shape[1]: return self[:self.shape[1]].diagonal()
if self.shape[1] > self.shape[0]: return self[:, :self.shape[0]].diagonal()
return self.ravel()[::self.shape[0]+1]
raise NotImplementedError('garray.diagonal for arrays with ndim other than 1 or 2.') ```

Example 11

`def eye(n): return diagflat(ones(n)) `

Example 12

```def diagflat(self, k=0):
if self.ndim!=1: return self.ravel().diagflat(k)
if k!=0: raise NotImplementedError('k!=0 for garray.diagflat')
selfSize = self.size
ret = zeros((selfSize, selfSize))
ret.ravel()[:-1].reshape((selfSize-1, selfSize+1))[:, 0] = self[:-1]
if selfSize!=0: ret.ravel()[-1] = self[-1]
return ret ```

Example 13

```def diagonal(self):
if self.ndim==1: return self.diagflat()
if self.ndim==2:
if self.shape[0] > self.shape[1]: return self[:self.shape[1]].diagonal()
if self.shape[1] > self.shape[0]: return self[:, :self.shape[0]].diagonal()
return self.ravel()[::self.shape[0]+1]
raise NotImplementedError('garray.diagonal for arrays with ndim other than 1 or 2.') ```

Example 14

```def fit(self, dHdl):
"""
Compute free energy differences between each state by integrating
dHdl across lambda values.

Parameters
----------
dHdl : DataFrame
dHdl[n,k] is the potential energy gradient with respect to lambda
for each configuration n and lambda k.

"""

# sort by state so that rows from same state are in contiguous blocks,
# and adjacent states are next to each other
dHdl = dHdl.sort_index(level=dHdl.index.names[1:])

# obtain the mean and variance of the mean for each state
# variance calculation assumes no correlation between points
# used to calculate mean
means = dHdl.mean(level=dHdl.index.names[1:])
variances = np.square(dHdl.sem(level=dHdl.index.names[1:]))

# obtain vector of delta lambdas between each state
dl = means.reset_index()[means.index.names[:]].diff().iloc[1:].values

# apply trapezoid rule to obtain DF between each adjacent state
deltas = (dl * (means.iloc[:-1].values + means.iloc[1:].values)/2).sum(axis=1)
d_deltas = (dl**2 * (variances.iloc[:-1].values + variances.iloc[1:].values)/4).sum(axis=1)

# build matrix of deltas between each state
adelta = np.zeros((len(deltas)+1, len(deltas)+1))
ad_delta = np.zeros_like(adelta)

for j in range(len(deltas)):
out = []
dout = []
for i in range(len(deltas) - j):
out.append(deltas[i] + deltas[i+1:i+j+1].sum())
dout.append(d_deltas[i] + d_deltas[i+1:i+j+1].sum())

adelta += np.diagflat(np.array(out), k=j+1)
ad_delta += np.diagflat(np.array(dout), k=j+1)

# yield standard delta_f_ free energies between each state
self.delta_f_ = pd.DataFrame(adelta - adelta.T,
columns=means.index.values,
index=means.index.values)

# yield standard deviation d_delta_f_ between each state
self.d_delta_f_ = pd.DataFrame(np.sqrt(ad_delta + ad_delta.T),
columns=variances.index.values,
index=variances.index.values)

self.states_ = means.index.values.tolist()

return self ```

Example 15

```def simplex_project(y, infinitesimal):
# 1-D vector version
# D = len(y)
# u = np.sort(y)[::-1]
# x_tmp = (1. - np.cumsum(u)) / np.arange(1, D+1)
# lmd = x_tmp[np.sum(u + x_tmp > 0) - 1]
# return np.maximum(y + lmd, 0)

n, d = y.shape
x = np.fliplr(np.sort(y, axis=1))
x_tmp = np.dot((np.cumsum(x, axis=1) + (d * infinitesimal - 1.)), np.diagflat(1. / np.arange(1, d + 1)))
lmd = x_tmp[np.arange(n), np.sum(x > x_tmp, axis=1) - 1]
return np.maximum(y - lmd[:, np.newaxis], 0) + infinitesimal ```

Example 16

```def JCB(A,b,N=25,x=None):

if x is None:
x = zeros(len(A[0]))

D = diag(A)
R = A - diagflat(D)

for i in range(N):
x = (b - dot(R,x))/D

pprint(x)
return x ```

Example 17

```def diagflat(a, k=0):
if isinstance(a, garray): return a.diagflat(k)
else: return numpy.diagflat(a,k) ```