小编pat*_*_ai的帖子

我有一个 LongTensors 列表和另一个标签列表。我是 PyTorch 和 RNN 的新手，所以我对如何为我拥有的数据实施小批量训练感到非常困惑。这个数据还有很多，但我想保持简单，所以我只能理解如何实现小批量训练部分。我正在根据在可变长度输入上训练的 LSTM/GRU 的最终隐藏状态进行多类分类。我设法让它与批量大小 1（基本上是 SGD）一起工作，但我正在努力实现小批量。

我是否必须将序列填充到最大尺寸并创建一个更大尺寸的新张量矩阵来容纳所有元素？我的意思是这样的：

inputs = pad(sequences)
train = DataLoader(inputs, batch_size=batch_size, shuffle=True)
for i, data in train:
   #do stuff using LSTM and/or GRU models

这是对自定义数据进行小批量训练的公认方式吗？我找不到有关使用 DataLoader 加载自定义数据的任何教程（但我认为这是使用 pyTorch 创建批次的方法？）

我的另一个疑问是关于填充。我使用 LSTM/GRU 的原因是因为输入的长度可变。填充不会破坏目的吗？小批量训练是否需要填充？

我有 conda 环境文件conda.yml：

name: env

channels:
  - pytorch

dependencies:
  - python=3.7.*
  - python-dev
  - python3-distutils

但线路- python-dev并python3-distutils不起作用。我应该放什么才能获得Python开发工具？

我试图tf.gradient在张量流y中做出一个hack,它会给出一个等级(M,N)的张量和一个x等级(Q,P)的等级(M,N,Q,P)的梯度张量作为一个自然会期待.

正如在这个网站*上的多个问题所指出的那样,得到的是一个等级(Q,P),它是元素总和的等级y.现在我无法弄清楚,查看张量流代码是在哪里对元素进行求和y？是开始还是结束？有人可以帮我查明代码行吗？

*

• Tensorflow梯度:没有自动隐式求和
• TensorFlow:计算Hessian矩阵(和更高阶导数)
• 张量流中每个示例的未聚集梯度/渐变
• 在tf.gradients中分开渐变

是否可以让 PyTorch 发行版直接在 GPU 上创建样本。

如果我做

from torch.distributions import Uniform, Normal
normal = Normal(3, 1)
sample = normal.sample()

然后样本将在CPU上。当然，sample = sample.to(torch.device("cuda"))在 GPU 上制作也是可以的。但是有没有办法让样本直接进入 GPU，而不需要先在 CPU 上创建它呢？

PyTorch 发行版继承自Object，nn.Module因此它没有to将发行版实例放在 GPU 上的方法。

有任何想法吗？

给定一种典型的编程语言.

我有两个数字浮点数a和b彼此接近(即它们的差值比绝对值的绝对值小得多).

| AB | << | a + b |/2

在数学上,我们有

exp(ab)= exp(a)/ exp(b).

但是当你编程时,你可以选择首先计算(ab)然后取幂,或取幂a,然后取b,然后除以它们.

如果a和b彼此非常接近,那么(ab)的精度可能会很差.

例

(1 + pi*10 ^ -20) - (1 + 1.1*pi*10 ^ -20)= - pi*10 ^ -21

但如果您使用的浮点只有19个小数点的精度.你会得到零作为答案,这是一个糟糕的精度.您可以通过重新排序操作获得更好的精度,如下所示

(1-1)+(pi*10 ^ -20 -1.1*pi*10 ^ -20)= -pi*10 ^ -21

这将给你-pi*10 ^ -21具有19个小数点的精度.

因此,我的问题是,给定一个有限的浮点精度,计算exp(ab)的方法给出了更好的精度？

差异的指数:

EXP(AB)

或指数的商

EXP(A)/ EXP(b)中

？

文档说

h_n形状的(num_layers*num_directions,分批,hidden_​​size):张量含有用于隐藏状态T = seq_len

现在,批处理和hidden_​​size维度几乎是不言自明的.不过,第一个维度仍然是一个谜.

我假设,所有层的所有"最后一个单元格"的隐藏状态都包含在此输出中.但是,例如,"最上层"中"最后一个单元格"的隐藏状态是什么？h_n[-1]？h_n[0]？

输出是否受batch_first选项影响？

比方说，我有一个矩阵X与n, m == X.shape在PyTorch。计算伪逆的时间复杂度是torch.pinverse多少？

换句话说，什么是时间复杂度

X_p = torch.pinverse(X)

?

这是文档

我使用Mac在后台运行一个jupyter笔记本

>jupyter notebook &

因为它在后台运行我不能用它ctrl-c来杀死它.此外jupyter,活动监视器中似乎没有进程名称.

这个github问题表明这无法从浏览器中执行此操作:https://github.com/jupyter/notebook/issues/1530 但是它说应该可以从命令行使用,jupyter notebook stop <portno>但似乎没有为我工作.

如何关闭jupyter服务器(理想情况下无需搜索pid然后调用kill)？

是什么在的功能差别tf.layers.conv1d,并tf.layers.conv2d在tensorflow以及如何决定选择哪一个？

有没有办法将密集张量转换为稀疏张量？显然,Tensorflow的Estimator.fit不接受SparseTensors作为标签.我想将SparseTensors传递给Tensorflow的Estimator.fit的一个原因是能够使用tensorflow ctc_loss.这是代码:

import dataset_utils
import tensorflow as tf
import numpy as np

from tensorflow.contrib import grid_rnn, learn, layers, framework

def grid_rnn_fn(features, labels, mode):
    input_layer = tf.reshape(features["x"], [-1, 48, 1596])
    indices = tf.where(tf.not_equal(labels, tf.constant(0, dtype=tf.int32)))
    values = tf.gather_nd(labels, indices)
    sparse_labels = tf.SparseTensor(indices, values, dense_shape=tf.shape(labels, out_type=tf.int64))

    cell_fw = grid_rnn.Grid2LSTMCell(num_units=128)
    cell_bw = grid_rnn.Grid2LSTMCell(num_units=128)
    bidirectional_grid_rnn = tf.nn.bidirectional_dynamic_rnn(cell_fw, cell_bw, input_layer, dtype=tf.float32)
    outputs = tf.reshape(bidirectional_grid_rnn[0], [-1, 256])

    W = tf.Variable(tf.truncated_normal([256,
                                     80],
                                    stddev=0.1, dtype=tf.float32), name='W')
    b = tf.Variable(tf.constant(0., dtype=tf.float32, shape=[80], name='b'))

    logits = tf.matmul(outputs, W) + b …

我正在努力训练一个看起来像这样的U-Net

`class UNet(nn.Module):
def __init__(self, imsize):
    super(UNet, self).__init__()
    self.imsize = imsize

    self.activation = F.relu
    self.pool1 = nn.MaxPool2d(2)
    self.pool2 = nn.MaxPool2d(2)
    self.pool3 = nn.MaxPool2d(2)
    self.pool4 = nn.MaxPool2d(2)
    self.conv_block1_64 = UNetConvBlock(4, 64)
    self.conv_block64_128 = UNetConvBlock(64, 128)
    self.conv_block128_256 = UNetConvBlock(128, 256)
    self.conv_block256_512 = UNetConvBlock(256, 512)
    self.conv_block512_1024 = UNetConvBlock(512, 1024)

    self.up_block1024_512 = UNetUpBlock(1024, 512)
    self.up_block512_256 = UNetUpBlock(512, 256)
    self.up_block256_128 = UNetUpBlock(256, 128)
    self.up_block128_64 = UNetUpBlock(128, 64)

    self.last = nn.Conv2d(64, 1, 1)`

我正在使用的损失函数是

`class BCELoss2d(nn.Module):

def __init__(self, weight=None, size_average=True):
    super(BCELoss2d, self).__init__()
    self.bce_loss = nn.BCELoss(weight, size_average) …