Python numpy 模块，tri() 实例源码
我们从Python开源项目中，提取了以下22个代码示例，用于说明如何使用numpy.tri()。
def tril(m, k=0):
"""
Lower triangle of an array.
Return a copy of an array with elements above the `k`-th diagonal zeroed.
Parameters
----------
m : array_like, shape (M, N)
Input array.
k : int, optional
Diagonal above which to zero elements. `k = 0` (the default) is the
main diagonal, `k < 0` is below it and `k > 0` is above.
Returns
-------
array, shape (M, N)
Lower triangle of `m`, of same shape and data-type as `m`.
See Also
--------
triu : Same thing, only for the upper triangle.
"""
return m * tri(m.shape[0], m.shape[1], k=k, dtype=m.dtype)
def __call__(self, h, train=True):
"""
in_type:
h: float32
in_shape:
h: (batch_size, hidden_num)
out_type: float32
out_shape: (batch_size, rating_num, predicted_item_num)
"""
xp = cuda.get_array_module(h.data)
h = self.p(h)
if hasattr(self, 'q'):
h = self.q(h)
h = F.reshape(h, (-1, self.rating_num, self.item_num, 1))
w = chainer.Variable(xp.asarray(np.tri(self.rating_num, dtype=np.float32).reshape(self.rating_num, self.rating_num, 1, 1)), volatile=h.volatile)
h = F.convolution_2d(h, w)
return F.reshape(h, (-1, self.rating_num, self.item_num))
def ordinal_loss(y, mask):
xp = cuda.get_array_module(y.data)
volatile = y.volatile
b, c, n = y.data.shape
max_y = F.broadcast_to(F.max(y, axis=1, keepdims=True), y.data.shape)
y = y - max_y
sum_y = F.broadcast_to(F.expand_dims(F.sum(y, axis=1), 1), y.data.shape)
down_tri = np.tri(c, dtype=np.float32)
up_tri = down_tri.T
w1 = Variable(xp.asarray(down_tri.reshape(c, c, 1, 1)), volatile=volatile)
w2 = Variable(xp.asarray(up_tri.reshape(c, c, 1, 1)), volatile=volatile)
h = F.exp(F.expand_dims(y, -1))
h1 = F.convolution_2d(h, w1)
h1 = F.convolution_2d(F.log(h1), w1)
h2 = F.convolution_2d(h, w2)
h2 = F.convolution_2d(F.log(h2), w2)
h = F.reshape(h1 + h2, (b, c, n))
return F.sum((h - sum_y - y) * mask) / b
def ones_matrix_band_part(rows, cols, num_lower, num_upper, out_shape=None):
"""Matrix band part of ones."""
if all([isinstance(el, int) for el in [rows, cols, num_lower, num_upper]]):
# Needed info is constant, so we construct in numpy
if num_lower < 0:
num_lower = rows - 1
if num_upper < 0:
num_upper = cols - 1
lower_mask = np.tri(rows, cols, num_lower).T
upper_mask = np.tri(rows, cols, num_upper)
band = np.ones((rows, cols)) * lower_mask * upper_mask
if out_shape:
band = band.reshape(out_shape)
band = tf.constant(band, tf.float32)
else:
band = tf.matrix_band_part(tf.ones([rows, cols]),
tf.cast(num_lower, tf.int64),
tf.cast(num_upper, tf.int64))
if out_shape:
band = tf.reshape(band, out_shape)
return band
def test_euclidean_pdist(self):
a = np.arange(12, dtype=np.float).reshape(4, 3)
out = np.empty((a.shape[0] * (a.shape[0] - 1) // 2,), dtype=a.dtype)
umt.euclidean_pdist(a, out)
b = np.sqrt(np.sum((a[:, None] - a)**2, axis=-1))
b = b[~np.tri(a.shape[0], dtype=bool)]
assert_almost_equal(out, b)
# An output array is required to determine p with signature (n,d)->(p)
assert_raises(ValueError, umt.euclidean_pdist, a)
def test_euclidean_pdist(self):
a = np.arange(12, dtype=np.float).reshape(4, 3)
out = np.empty((a.shape[0] * (a.shape[0] - 1) // 2,), dtype=a.dtype)
umt.euclidean_pdist(a, out)
b = np.sqrt(np.sum((a[:, None] - a)**2, axis=-1))
b = b[~np.tri(a.shape[0], dtype=bool)]
assert_almost_equal(out, b)
# An output array is required to determine p with signature (n,d)->(p)
assert_raises(ValueError, umt.euclidean_pdist, a)
def test_euclidean_pdist(self):
a = np.arange(12, dtype=np.float).reshape(4, 3)
out = np.empty((a.shape[0] * (a.shape[0] - 1) // 2,), dtype=a.dtype)
umt.euclidean_pdist(a, out)
b = np.sqrt(np.sum((a[:, None] - a)**2, axis=-1))
b = b[~np.tri(a.shape[0], dtype=bool)]
assert_almost_equal(out, b)
# An output array is required to determine p with signature (n,d)->(p)
assert_raises(ValueError, umt.euclidean_pdist, a)
def test_euclidean_pdist(self):
a = np.arange(12, dtype=np.float).reshape(4, 3)
out = np.empty((a.shape[0] * (a.shape[0] - 1) // 2,), dtype=a.dtype)
umt.euclidean_pdist(a, out)
b = np.sqrt(np.sum((a[:, None] - a)**2, axis=-1))
b = b[~np.tri(a.shape[0], dtype=bool)]
assert_almost_equal(out, b)
# An output array is required to determine p with signature (n,d)->(p)
assert_raises(ValueError, umt.euclidean_pdist, a)
def X_to_vec(X):
n = X.shape[0]
return X.T[np.tri(n, dtype=np.bool).T]
def vec_to_X(v_X):
n = int(math.sqrt(2 * len(v_X)))
if len(v_X) != n * (n + 1) / 2:
raise ValueError(
"v_X is not the right shape for a vectorized lower triangular matrix. Tried to turn vector of size {} into matrix with width {} ".format(len(v_X), n))
Y = np.zeros((n, n))
Y[np.tri(n, dtype=np.bool).T] = v_X
return Y + np.triu(Y, 1).T
def J(v_X):
X = vec_to_X(v_X)
n = X.shape[0]
# perform scaling
_i = tuple(range(n))
X[_i, _i] *= _sqrt2
Lam, U = np.linalg.eigh(X)
idx = np.argsort(Lam)
Lam = Lam[idx]
U = U[:, idx]
L = np.diag(Lam)
L_max = np.maximum(L, 0.0)
dU_dX, dL_dX = dU_dL_dX(Lam, U)
dL_max_dX = dL_dX.copy()
for i, l in enumerate(Lam):
if l < 0:
dL_max_dX[i, :, :] = 0
t1 = dot(U.dot(L_max), np.rollaxis(dU_dX, 1, 0))
t2 = np.rollaxis(t1, 1, 0)
t3 = np.rollaxis(dot(multiply_diag(U, dL_max_dX), U.T, (1, 0)), 3, 1)
idx = np.nonzero(np.tri(n, dtype=np.bool).T)
W = t1 + t2 + t3
# rescale jacobian
W[:, :, _i, _i] *= _sqrt2
W[_i, _i, :, :] /= _sqrt2
return W[idx[0], idx[1]][:, idx[0], idx[1]]
def test_euclidean_pdist(self):
a = np.arange(12, dtype=np.float).reshape(4, 3)
out = np.empty((a.shape[0] * (a.shape[0] - 1) // 2,), dtype=a.dtype)
umt.euclidean_pdist(a, out)
b = np.sqrt(np.sum((a[:, None] - a)**2, axis=-1))
b = b[~np.tri(a.shape[0], dtype=bool)]
assert_almost_equal(out, b)
# An output array is required to determine p with signature (n,d)->(p)
assert_raises(ValueError, umt.euclidean_pdist, a)
def test_euclidean_pdist(self):
a = np.arange(12, dtype=np.float).reshape(4, 3)
out = np.empty((a.shape[0] * (a.shape[0] - 1) // 2,), dtype=a.dtype)
umt.euclidean_pdist(a, out)
b = np.sqrt(np.sum((a[:, None] - a)**2, axis=-1))
b = b[~np.tri(a.shape[0], dtype=bool)]
assert_almost_equal(out, b)
# An output array is required to determine p with signature (n,d)->(p)
assert_raises(ValueError, umt.euclidean_pdist, a)
def test_tri(self):
def check(dtype, N, M_=None, k=0):
# Theano does not accept None as a tensor.
# So we must use a real value.
M = M_
# Currently DebugMode does not support None as inputs even if this is
# allowed.
if M is None and theano.config.mode in ['DebugMode', 'DEBUG_MODE']:
M = N
N_symb = tensor.iscalar()
M_symb = tensor.iscalar()
k_symb = tensor.iscalar()
f = function([N_symb, M_symb, k_symb],
tri(N_symb, M_symb, k_symb, dtype=dtype))
result = f(N, M, k)
self.assertTrue(
numpy.allclose(result, numpy.tri(N, M_, k, dtype=dtype)))
self.assertTrue(result.dtype == numpy.dtype(dtype))
for dtype in ALL_DTYPES:
yield check, dtype, 3
# M != N, k = 0
yield check, dtype, 3, 5
yield check, dtype, 5, 3
# N == M, k != 0
yield check, dtype, 3, 3, 1
yield check, dtype, 3, 3, -1
# N < M, k != 0
yield check, dtype, 3, 5, 1
yield check, dtype, 3, 5, -1
# N > M, k != 0
yield check, dtype, 5, 3, 1
yield check, dtype, 5, 3, -1
def perform(self, node, inp, out_):
N, M, k = inp
out, = out_
out[0] = numpy.tri(N, M, k, dtype=self.dtype)
def tri(N, M=None, k=0, dtype=None):
"""
An array with ones at and below the given diagonal and zeros elsewhere.
Parameters
----------
N : int
Number of rows in the array.
M : int, optional
Number of columns in the array.
By default, `M` is taken equal to `N`.
k : int, optional
The sub-diagonal at and below which the array is filled.
`k` = 0 is the main diagonal, while `k` < 0 is below it,
and `k` > 0 is above. The default is 0.
dtype : dtype, optional
Data type of the returned array. The default is float.
Returns
-------
Array of shape (N, M)
Array with its lower triangle filled with ones and zero elsewhere;
in other words ``T[i,j] == 1`` for ``i <= j + k``, 0 otherwise.
"""
if dtype is None:
dtype = config.floatX
if M is None:
M = N
op = Tri(dtype)
return op(N, M, k)
def triu(m, k=0):
"""
Upper triangle of an array.
Return a copy of a matrix with the elements below the `k`-th diagonal
zeroed.
Please refer to the documentation for `tril` for further details.
See Also
--------
tril : Lower triangle of an array.
"""
return m * (1 - tri(m.shape[0], m.shape[1], k=k - 1, dtype=m.dtype))
def make_rating_matrix(x, r, item_num, rating_num):
y = np.zeros((x.shape[0], item_num, rating_num), dtype=np.float32)
for i in six.moves.range(x.shape[0]):
index = x[i] >= 0
y[i, x[i, index], r[i, index]] = 1
r_to_v = np.tri(rating_num, dtype=np.float32)
y = y.dot(r_to_v)
return y.reshape((x.shape[0], -1))
def sample_wishart(sigma, nu):
n = sigma.shape[0]
chol = np.linalg.cholesky(sigma)
# use matlab's heuristic for choosing between the two different sampling schemes
if (nu <= 81+n) and (nu == round(nu)):
# direct
X = np.dot(chol,np.random.normal(size=(n,nu)))
else:
A = np.diag(np.sqrt(np.random.chisquare(nu - np.arange(n))))
A[np.tri(n,k=-1,dtype=bool)] = np.random.normal(size=(n*(n-1)/2.))
X = np.dot(chol,A)
return np.dot(X,X.T)
def sample_wishart(sigma, nu):
n = sigma.shape[0]
chol = np.linalg.cholesky(sigma)
# use matlab's heuristic for choosing between the two different sampling schemes
if (nu <= 81+n) and (nu == round(nu)):
# direct
X = np.dot(chol,np.random.normal(size=(n,nu)))
else:
A = np.diag(np.sqrt(np.random.chisquare(nu - np.arange(n))))
A[np.tri(n,k=-1,dtype=bool)] = np.random.normal(size=(n*(n-1)/2.))
X = np.dot(chol,A)
return np.dot(X,X.T)
def testCorrectlyMakesNoBatchLowerTril(self):
with self.test_session():
x = ops.convert_to_tensor(self._rng.randn(10))
expected = self._fill_lower_triangular(tensor_util.constant_value(x))
actual = distribution_util.fill_lower_triangular(x, validate_args=True)
self.assertAllEqual(expected.shape, actual.get_shape())
self.assertAllEqual(expected, actual.eval())
g = gradients_impl.gradients(
distribution_util.fill_lower_triangular(x), x)
self.assertAllEqual(np.tri(4).reshape(-1), g[0].values.eval())
def test_euclidean_pdist(self):
a = np.arange(12, dtype=np.float).reshape(4, 3)
out = np.empty((a.shape[0] * (a.shape[0] - 1) // 2,), dtype=a.dtype)
umt.euclidean_pdist(a, out)
b = np.sqrt(np.sum((a[:, None] - a)**2, axis=-1))
b = b[~np.tri(a.shape[0], dtype=bool)]
assert_almost_equal(out, b)
# An output array is required to determine p with signature (n,d)->(p)
assert_raises(ValueError, umt.euclidean_pdist, a)