小编And*_*dyK的帖子

根据矩阵指数,如果XY = YX,那么exp(X)exp(Y) = exp(X+Y).但是当我在Python中运行以下内容时:

import numpy as np
from scipy.linalg import expm

A = np.arange(1,17).reshape(4,4)

print(expm(2*A))
[[ 306.63168024  344.81465009  380.01335176  432.47730444]
 [ 172.59336774  195.36562731  214.19453937  243.76985501]
 [ -35.40485583  -39.87705598  -42.94545895  -50.01324379]
 [-168.44316833 -190.32607875 -209.76427134 -237.72069322]]

print(expm(A) @ expm(A))
[[1.87271814e+30 2.12068332e+30 2.36864850e+30 2.61661368e+30]
 [4.32685652e+30 4.89977229e+30 5.47268806e+30 6.04560383e+30]
 [6.78099490e+30 7.67886126e+30 8.57672762e+30 9.47459398e+30]
 [9.23513328e+30 1.04579502e+31 1.16807672e+31 1.29035841e+31]]

我得到两个非常不同的结果.请注意,这@只是点积.

我也在Matlab中尝试过,两个结果与预期相同.我在这里错过了什么？

编辑:我有NumPy 1.15.3,SciPy 1.1.0,Python 3.6.4,Windows 7 64位

正如Warren Weckesser的评论中所建议的,使用A = A.astype(np.float64)解决了这个问题.

我正在优化一段代码并发现列表复制（浅层）是瓶颈。

现在我很好奇：为什么列表复制比复制array8 字节慢这么多？在我看来，应该没有区别。在这两种情况下，应该只是memcpy(dst, src, sizeof(int64_t)*len(src))因为指针的长度为 8 个字节。但显然 Python 做的工作比我预期的要多。它与GC有某种关系吗？或者列表是否可能实现为链接列表？

import array
import numpy as np
import timeit


n = 100*1000
lst = [i for i in range(n)]
arr = array.array('q', lst)
nmp = np.array(arr, dtype=np.int64)

assert(arr.itemsize == 8)

n_iter = 100000
print('=== copy() ===')
print('List of int:', timeit.timeit(stmt='lst.copy()', setup='from __main__ import lst', number=n_iter))
print('Array of 8-bytes:', timeit.timeit(stmt='arr.__copy__()', setup='from __main__ import arr', number=n_iter))
print('Numpy array of int64:', timeit.timeit(stmt='nmp.copy()', setup='from __main__ import nmp', number=n_iter))

结果：

import array
import …

当我们从 构造 scipy 稀疏矩阵（例如coo_matrix、csc_matrix或csr_matrix）时(data, (row_ind, col_ind))，默认情况下重复的条目(row_ind, col_ind)会被累加在一起。例如：

from scipy.sparse import coo_matrix

row_ind  = [0, 0, 0, 2, 0, 0]
col_ind  = [0, 0, 0, 2, 1, 1]
data = [1, 1, 1, 1, 1, 1]

coo_matrix((data, (row_ind, col_ind))).todense()

matrix([[3, 2, 0],
        [0, 0, 0],
        [0, 0, 1]])

有没有办法指定另一个操作，例如min, max，mean而不是sum？此外，拥有类似sum_duplicates()这些操作的方法也会很有用。

如何计算数据帧所有行之间的欧几里得距离？我正在尝试此代码，但它不起作用：

zero_data = data
distance = lambda column1, column2: pd.np.linalg.norm(column1 - column2)
result = zero_data.apply(lambda col1: zero_data.apply(lambda col2: distance(col1, col2)))
result.head()

这是我的（44062 x 278）数据框的样子：

我无法从他们的官方网站下载原始 ImageNet 数据集。但是，我发现 pytorch 将 ImageNet 作为其火炬视觉数据集之一。

一季度。那是原始的 ImageNet 数据集吗？

Q2。我如何像在 Cifar-10 中那样获取数据集的类

classes = [‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’]

我正在尝试计算 PyTorch 中变量的梯度。但是，有一个 RuntimeError 告诉我 output 和 grad 的形状必须相同。但是，就我而言， output 和 grad 的形状不能相同。这是我要重现的代码：

import numpy as np
import torch
from torch.autograd import Variable as V

ne = 3
m, n = 79, 164
G = np.random.rand(m, n).astype(np.float64)
w = np.random.rand(n, n).astype(np.float64)
z = -np.random.rand(n).astype(np.float64)

G = V(torch.from_numpy(G))
w = V(torch.from_numpy(w))
z = V(torch.from_numpy(z), requires_grad=True)
e, v = torch.symeig(torch.diag(2 * z - torch.sum(w, dim=1)) + w, eigenvectors=True, upper=False)
ssev = torch.sum(torch.pow(e[-ne:] * v[:, -ne:], 2), dim=1)
out = torch.sum(torch.matmul(G, ssev.reshape((n, 1)))) …

例如，我想获取 tensor 中值为 0 和 2 的元素的索引a。这些值（0 和 2）存储在 tensor 中b。我已经设计了一种 pythonic 方法来这样做（如下所示），但我认为列表推导式没有被优化为在 GPU 上运行，或者也许有一种我不知道的更多 PyTorchy 方法来做到这一点。

import torch
a = torch.tensor([0, 1, 0, 1, 1, 0, 2])
b = torch.tensor([0, 2])
torch.tensor([x in b for x in a]).nonzero()

>>>> tensor([[0],
             [2],
             [5],
             [6]])

任何其他建议或者这是一种可以接受的方式？

假设我们有一阶 ODE 系统有以下求解器：

   % func.m
   function dydt = func(t,y)
   dydt = [y(2); (1-y(1)^2)*y(2)-y(1)];

和主要代码：

% solver.m
tspan=0:1:10;
[t,y] = ode45(@func,tspan,[2; 0]);

如何实时显示 ode45 执行的每个时间步 t (t=0,1,2,...,10) 的结果 y1(t) 和 y2(t)，而无需等待整个过程代码要完成吗？

我想在同一图中绘制两个numpy数组Z1和Z2，Z2在Z1的顶部。数组Z2仅包含0和1，并且我希望0是完全透明的（alpha = 0）和1的透明，其中alpha> 0。

这是代码和生成的图像：

import numpy as np
import matplotlib.pyplot as plt

N = 10
x = np.arange(0, N)
y = np.arange(0, N)
Z1 = np.random.rand(N,N)
Z2 = np.ones((N, N))
Z2[0:N//2, 0:N] = 0

X, Y = np.meshgrid(x, y)
fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8, 6))
plt.pcolormesh(X, Y, Z1, cmap=plt.cm.Blues)
plt.colorbar()
plt.pcolormesh(X, Y, Z2, cmap=plt.cm.Reds_r, alpha=0.3)
ax.set_xlabel(r'$x$', fontsize=22)
ax.set_ylabel(r'$y$', fontsize=22)
plt.show()

有两个问题：

1. 多余的网格线的外观

2. Z2的0不能完全透明

为了摆脱网格线，我们可以使用imshow而不是pcolor，但是我真的想使用x和y的值。

我有一个 NumPy 数组，每行代表一些 (x, y, z) 坐标，如下所示：

a = array([[0, 0, 1],
           [1, 1, 2],
           [4, 5, 1],
           [4, 5, 2]])

我还有另一个 NumPy 数组，其中包含该数组的 z 坐标的唯一值，如下所示：

b = array([1, 2])

如何将函数（我们称之为“f”）应用于 a 中与 b 中的值相对应的每个行组？例如，b 的第一个值是 1，因此我将获取 a 中 z 坐标为 1 的所有行。然后，我将一个函数应用于所有这些值。

最后，输出将是一个与 b 形状相同的数组。

我正在尝试对其进行矢量化以使其尽可能快。谢谢！

预期输出示例（假设 f 是 count()）：

c = array([2, 2])

因为数组 a 中有 2 行，数组 b 中的 z 值为 1，数组 a 中有 2 行，数组 b 中的 z 值为 2。

一个简单的解决方案是像这样迭代数组 b：

for val in b: …

我有一个图像名称列表和一个（阈值）相似度矩阵。相似关系是自反的和对称的，但不一定是传递的，即如果image_i与image_j和相似image_k，那么它不一定意味着image_j和image_k是相似的。

例如：

images = ['image_0', 'image_1', 'image_2', 'image_3', 'image_4']

sm = np.array([[1, 1, 1, 0, 1],
               [1, 1, 0, 0, 1],
               [1, 0, 1, 0, 0],
               [0, 0, 0, 1, 0],
               [1, 1, 0, 0, 1]])

相似度矩阵sm解释如下：如果sm[i, j] == 1然后image_i和image_j相似，否则它们不相似。在这里我们看到image_0与image_1and相似image_2，但image_1和image_2不相似（这只是非传递性的一个例子）。

我想保留最大数量的唯一图像（根据给定的sm矩阵，它们都是成对非相似的）。对于这个例子，它是[image_2, image_3, image_4]或[image_1, image_2, image_3]（通常有多个这样的子集，但我不介意保留哪个，只要它们是最大长度）。我正在寻找一种有效的方法来做到这一点，因为我有成千上万的图像。

编辑 …