小编uke*_*emi的帖子

在 networkx 中有一个函数可以使用径向布局（graphviz 的“twopi”）绘制树：

import pydot
from networkx.drawing.nx_pydot import graphviz_layout

pos = graphviz_layout(G, prog='twopi', root=root, args='')

可以使用参数指定根节点root（它被添加到引擎盖下的 args 中args += f" -Groot={root}"）。

但是，当图形由多个断开连接的组件组成时，如何指定多个根？即一片树林。

我在不提供根参数的情况下得到以下图：

正如你在视觉上看到的，虽然它正确地为 10 棵树选择了真正的根节点，但它为 12 选择了真正根节点的一个孩子作为中心（因此一些分支看起来比实际更浅，相对于其他分支）。

如何手动指定多棵树的根？

在 PyTorch 中，以下两种方法向 GPU 发送张量（或模型）有什么区别：

设置：

X = np.array([[1, 3, 2, 3], [2, 3, 5, 6], [1, 2, 3, 4]]) # X = model()
X = torch.DoubleTensor(X)

（我真的不需要对后端发生的事情进行详细解释，只想知道它们是否本质上都在做同样的事情）

PyTorch/Numpy 中存在一个错误，即当与 a DataLoader（即设置num_workers > 1）并行加载批次时，每个工作线程使用相同的 NumPy 随机种子，导致并行批次之间应用的任何随机函数都是相同的。

最小的例子：

import numpy as np
from torch.utils.data import Dataset, DataLoader

class RandomDataset(Dataset):
    def __getitem__(self, index):
        return np.random.randint(0, 1000, 2)

    def __len__(self):
        return 9
    
dataset = RandomDataset()
dataloader = DataLoader(dataset, batch_size=1, num_workers=3)

for batch in dataloader:
    print(batch)

如您所见，对于每个并行批次集 (3)，结果是相同的：

# First 3 batches
tensor([[891, 674]])
tensor([[891, 674]])
tensor([[891, 674]])
# Second 3 batches
tensor([[545, 977]])
tensor([[545, 977]])
tensor([[545, 977]])
# Third 3 batches
tensor([[880, 688]])
tensor([[880, 688]])
tensor([[880, …

例如，如果我提供 [0.5, 0.5] 的概率数组，两个函数将以相同的概率对索引 [0,1] 进行采样？

我知道Google字典已于2011年停产，但字典信息和定义仍可通过google搜索结果获得：

这是它的屏幕截图

是否有人知道可以通过Custom Search API或Translate API访问此信息？-我找到了这个相关问题（可惜没有令人满意的答案）。

我有一个字符串格式的数字列表。我使用 将该列表转换为 numpy 数组np.asarray()。

如何将字符串元素转换为整数？

我正在寻找通过 Pytorch 获取函数的雅可比行列式的最有效方法，并且到目前为止提出了以下解决方案：

# Setup
def func(X):
    return torch.stack((X.pow(2).sum(1),
                        X.pow(3).sum(1),
                        X.pow(4).sum(1)),1)  

X = Variable(torch.ones(1,int(1e5))*2.00094, requires_grad=True).cuda()

# Solution 1:
t = time()
Y = func(X)
J = torch.zeros(3, int(1e5))

for i in range(3):
    J[i] = grad(Y[0][i], X, create_graph=True, retain_graph=True, allow_unused=True)[0]

print(time()-t)
>>> Output: 0.002 s

# Solution 2:
def Jacobian(f,X):
    X_batch = Variable(X.repeat(3,1), requires_grad=True)
    f(X_batch).backward(torch.eye(3).cuda(), retain_graph=True)
    return X_batch.grad

t = time()
J2 = Jacobian(func,X)
print(time()-t)
>>> Output: 0.001 s

由于在第一个解决方案中使用循环与在第二个解决方案中使用循环似乎没有太大区别，我想问一下是否还有更快的方法来计算 pytorch 中的雅可比行列式。

我的另一个问题也是关于什么可能是计算 Hessian 的最有效方法。

最后，有谁知道在 TensorFlow 中是否可以更轻松或更高效地完成此类操作？

我有一个形状为 ( m*n , m*n ) 的张量，我想提取一个大小为 ( n , m*n )的张量，其中包含对角线上大小为n*n的 m 个块。例如：

>>> a
tensor([[1, 2, 0, 0],
        [3, 4, 0, 0],
        [0, 0, 5, 6],
        [0, 0, 7, 8]])

我想要一个extract(a, m, n)将输出的函数：

>>> extract(a, 2, 2)
tensor([[1, 2, 5, 6],
        [3, 4, 7, 8]])

我想过使用某种切片，因为块可以表示为：

>>> for i in range(m):
...     print(a[i*m: i*m + n, i*m: i*m + n])
tensor([[1, 2],
        [3, 4]])
tensor([[5, 6],
        [7, 8]])

我想用tensorflow重写pytorch的torch.nn.functional.unfold函数：

#input x:[16, 1, 50, 36]
x = torch.nn.functional.unfold(x, kernel_size=(5, 36), stride=3)
#output x:[16, 180, 16]

我尝试使用该功能tf.extract_image_patches()：

x = tf.extract_image_patches(x,ksizes=[1, 1,5, 98],strides=[1, 1, 3, 1], rates=[1, 1, 1, 1],padding='VALID')

输入x.shape：[16,1,64,98]

我得到输出x.shape：[16,1,20,490]

然后我将 重塑X为[16,490,20]，这正是我所期望的。

但是当我输入数据时出现错误：

UnimplementedError (see above for traceback): Only support ksizes across space.
[[Node:hcn/ExtractImagePatches = ExtractImagePatches[T=DT_FLOAT, ksizes=[1, 1, 5, 98], padding="VALID", rates=[1, 1, 1, 1], strides=[1, 1, 3, 1], _device="/job:localhost/replica:0/task:0/device:GPU:0"](hcn/Reshape)]]

我如何使用tensorflow重写pytorchtorch.nn.functional.unfold函数来更改X？

让我们考虑一下，有两个数组I，并J由此确定邻居对：

I = np.array([0, 0, 1, 2, 2, 3])
J = np.array([1, 2, 0, 0, 3, 2])

这意味着元素0有两个邻居1和2。元素1只有0作为邻居等等。

什么是创建所有邻居三元组阵列的最有效的方式I'，J'，K'这样j是邻居i和k是邻居j给出的条件i，j以及k不同的元素（i != j != k）？

Ip = np.array([0, 0, 2, 3])
Jp = np.array([2, 2, 0, 2])
Kp = np.array([0, 3, 1, 0])

当然，一种方法是遍历每个元素。有没有更高效的算法？（使用 10-5 亿个元素）