标签: pytorch

如何在 pytorch 中使用 tfrecord？

我已经下载了具有视频级特征的“Youtube8M”数据集，但它存储在tfrecord中。我尝试从这些文件中读取一些示例，将其转换为 numpy，然后加载到 pytorch 中。但它失败了。

    reader = YT8MAggregatedFeatureReader()
    files = tf.gfile.Glob("/Data/youtube8m/train*.tfrecord")
    filename_queue = tf.train.string_input_producer(
        files, num_epochs=5, shuffle=True)
    training_data = [
        reader.prepare_reader(filename_queue) for _ in range(1)
    ]

    unused_video_id, model_input_raw, labels_batch, num_frames = tf.train.shuffle_batch_join(
        training_data,
        batch_size=1024,
        capacity=1024 * 5,
        min_after_dequeue=1024,
        allow_smaller_final_batch=True  ,
        enqueue_many=True)

    with tf.Session() as sess:
        label_numpy = labels_batch.eval()
        print(type(label_numpy))

但这一步却没有任何结果，只是卡了半天没有任何反应。

我有一个二维张量：

samples = torch.Tensor([
    [0.1, 0.1],    #-> group / class 1
    [0.2, 0.2],    #-> group / class 2
    [0.4, 0.4],    #-> group / class 2
    [0.0, 0.0]     #-> group / class 0
])

以及对应于一个类的每个样本的标签：

labels = torch.LongTensor([1, 2, 2, 0])

所以len(samples) == len(labels)。现在我想计算每个类别/标签的平均值。因为有 3 个类（0、1 和 2），所以最终向量应该具有维度[n_classes, samples.shape[1]]所以预期的解决方案应该是：

result == torch.Tensor([
    [0.1, 0.1],
    [0.3, 0.3], # -> mean of [0.2, 0.2] and [0.4, 0.4]
    [0.0, 0.0]
])

问题：如何在纯 pytorch 中完成此操作（即没有 numpy，以便我可以自动分级）并且理想情况下没有 for 循环？

从Convolution 的PyTorch文档中，我看到该函数torch.nn.Conv1d需要用户传递参数in_channels和out_channels。

我知道这些指的是“输入通道”和“输出通道”，但我不确定它们在卷积的上下文中意味着什么。我的猜测是，这in_channels相当于输入特征，也out_channels相当于输出特征，但我不确定。

有人可以解释一下这些论点指的是什么吗？

这个方法我已经见过很多次了。这样做的目的和好处是什么？

我尝试在 Pytorch 中定义一个简单的模型。该模型计算高斯分布的负对数概率：

import torch
import torch.nn as nn

class GaussianModel(nn.Module):

    def __init__(self):
        super(GaussianModel, self).__init__()

        self.register_parameter('mean', nn.Parameter(torch.zeros(1),
                                                     requires_grad=True))
        
        self.pdf = torch.distributions.Normal(self.state_dict()['mean'],
                                              torch.tensor([1.0]))
    def forward(self, x):
        return -self.pdf.log_prob(x)

model = GaussianModel()

然后我尝试优化mean参数：

optimizer = torch.optim.SGD(model.parameters(), lr=0.002)
for _ in range(5):
  optimizer.zero_grad()
  nll = model(torch.tensor([3.0], requires_grad=True))
  nll.backward()
  optimizer.step()
  print('mean : ', model.state_dict()['mean'],
                 ' - Negative Loglikelihood : ', nll.item())

但看起来梯度为零并且mean没有改变：

mean :  tensor([0.])  - Negative Loglikelihood :  5.418938636779785
mean :  tensor([0.])  - Negative Loglikelihood :  5.418938636779785
mean : …

RuntimeError: Detected that PyTorch and torchvision were compiled with different CUDA versions. PyTorch has CUDA Version=10.2 and torchvision has CUDA Version=10.1. Please reinstall the torchvision that matches your PyTorch install.

我尝试在我的 Google Colab 上运行 YOLACT 并发现此错误。有人可以帮助解决这个问题吗？

PyTorch 似乎没有tensor.stride(). 有人可以确认我的理解吗？

我的问题有三个。

1. Stride 用于访问存储中的元素。因此步幅大小将与张量的维度相同。正确的？

2. 对于每个维度，stride 的相应元素表示沿着一维存储移动需要多少距离。正确的？

例如：

In [15]: x = torch.arange(1,25)

In [16]: x
Out[16]:
tensor([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18
, 19, 20, 21, 22, 23, 24])

In [17]: a = x.view(4,3,2)

In [18]: a
Out[18]:
tensor([[[ 1,  2],
         [ 3,  4],
         [ 5,  6]],

        [[ 7,  8],
         [ 9, 10],
         [11, 12]],

        [[13, 14],
         [15, 16],
         [17, 18]],

        [[19, 20], …

我是 pytorch 的新手，我想知道如何显示损失和准确性的图表，以及我应该如何准确存储这些值，知道我正在使用 CIFAR10 应用 cnn 模型进行图像分类。

这是我当前的实现：

    def train(num_epochs,optimizer,criterion,model):
        for epoch in range(num_epochs):
            for i, (images, labels) in enumerate(trainloader):
                # origin shape: [4, 3, 32, 32] = 4, 3, 1024
                # input_layer: 3 input channels, 6 output channels, 5 kernel size
                images = images.to(device)
                labels = labels.to(device)
    
                # Forward pass
                outputs = model(images)
                loss = criterion(outputs, labels)
    
                # Backward and optimize
                optimizer.zero_grad()
                loss.backward()
                optimizer.step()
    
                if (i+1) % 2000 == 0:
                    print (f'Epoch [{epoch+1}/{num_epochs}], Step [{i+1}/{n_total_steps}], Loss: {loss.item():.4f}')
                
        
        PATH = …

我看到一个数独求解器 CNN 使用稀疏分类交叉熵作为使用 TensorFlow 框架的损失函数，我想知道 Pytorch 是否有类似的函数？如果不是，我如何可能使用 Pytorch 计算 2d 数组的损失？

我正在使用一个Resnet18模型。

ResNet(
  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (1): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): …