标签: neural-network

看起来 pytorch 的 Transformer 层无法提供可重现的输出。cpu和gpu都会出现这种情况。我知道有时会因为 GPU 上的并行计算而发生这种情况。

emb = nn.Embedding(10, 12).to(device)
inp1 = torch.LongTensor([1, 2, 3, 4]).to(device)
inp1 = emb(inp1).reshape(inp1.shape[0], 1, 12) #S N E

encoder_layer = nn.TransformerEncoderLayer(d_model=12, nhead=4)
transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=4)

out1 = transformer_encoder(inp1)
out2 = transformer_encoder(inp1)

out1 和 out2 不同。它可以在 cpu 上进行多处理，但结果看起来太不稳定。如何解决这个问题？

我期望 pytorch 中的线性模型产生sigmoid(WX+b). 但我看到它只是回归Wx+b。为什么会这样呢？

在 Udacity “Intro to Deep Learning with pytorch” -> Lesson 2: Introduction to Neural Networks 中，他们说输出是 sigmoid：

\xcc\x82 =(11+22+)\n

从下面的代码中，我预计 y cap 为 0.38391371665752183，但这只是 的值WX+b，我确认了输出。为什么会出现这样的差异呢？

import torch\nfrom torch import nn\nimport numpy as np\n\ntorch.manual_seed(0)\nmodel = nn.Linear(2,1)\nw1 = model.weight.detach().numpy()\nb1 = model.bias.detach().numpy()\nprint (f'model.weight = {w1}, model.bias={b1}')\nx = torch.tensor([[0.2877, 0.2914]])\nprint(f'model predicted {model(x)}')\nz = x.numpy()[0][0] * w1[0][0] + x.numpy()[0][1] * w1 [0][1] + b1[0]\nprint(f'manual multiplication yielded {z}')\nycap = 1/(1+ np.exp(-z))\nprint(f'y cap …

考虑以下网络：

%%time
import torch
from torch.autograd import grad
import torch.nn as nn
import torch.optim as optim

class net_x(nn.Module): 
        def __init__(self):
            super(net_x, self).__init__()
            self.fc1=nn.Linear(1, 20) 
            self.fc2=nn.Linear(20, 20)
            self.out=nn.Linear(20, 400) #a,b,c,d

        def forward(self, x):
            x=torch.tanh(self.fc1(x))
            x=torch.tanh(self.fc2(x))
            x=self.out(x)
            return x

nx = net_x()

#input
val = 100
t = torch.rand(val, requires_grad = True) #input vector
t = torch.reshape(t, (val,1)) #reshape for batch

#method 
dx = torch.autograd.functional.jacobian(lambda t_: nx(t_), t)

这输出

CPU times: user 11.1 s, sys: 3.52 ms, total: 11.1 s
Wall time: …

我听很多人谈论一些原因，但他们从未真正回答是否应该修复。我检查了数据集是否存在泄漏，并从 TFRecords 数据集中随机抽取 20% 作为验证集。我开始怀疑我的模型有太多正则化层。我是否应该减少正则化以使验证线位于训练线之上？或者这真的很重要吗？

我正在研究Deep Neural Networks并且想知道以下问题:

为了获得最佳准确度,每层最佳层数和神经元数量是多少？

根据这张图片:

最佳数字是否等于要素大小,以便考虑每个要素对另一组要素的影响？

此外,如果我们寻求最佳的准确性和效率,答案会有所不同吗？

谢谢,任何见解表示赞赏!

编辑:

这些答案内容丰富.我仍然觉得他们没有特别提到我问题的第一部分.澄清:是否有最大量的神经元和层在应用时对数据同样精细,因此添加更多神经元或层将是多余的？我假设3个特征数据集的无限层在某些时候变得不必要.再次感谢所有阅读和回复!

我有点困惑隐藏层之间激活的用途是什么,我知道隐藏层和输出之间的softmax函数是将概率挤压到[0,1],但隐藏层之间的sigmoid函数有什么用？

我在这里问一些关于 Pytorch 和卷积自动编码器的更一般的问题。

1. 如果我只使用卷积层 (FCN)，我什至需要关心输入形状吗？然后我如何最好地选择特征图的数量？
2. ConvTranspose2d 层会自动解除池化吗？
3. 您能在我的示例中发现任何错误或非常规代码吗？

顺便说一句，我想制作一个对称的卷积自动编码器来对不同图像大小的黑白图像进行着色。

    self.encoder = nn.Sequential (
        # conv 1
        nn.Conv2d(in_channels=3, out_channels=512, kernel_size=3, stride=1, padding=1),
        nn.ReLU,
        nn.MaxPool2d(kernel_size=2, stride=2),  # 1/2
        nn.BatchNorm2d(512),

        # conv 2
        nn.Conv2d(in_channels=512, out_channels=256, kernel_size=3, stride=1, padding=1),
        nn.ReLU,
        nn.MaxPool2d(kernel_size=2, stride=2),  # 1/4
        nn.BatchNorm2d(256),

        # conv 3
        nn.Conv2d(in_channels=256, out_channels=128, kernel_size=3, stride=1, padding=1),
        nn.ReLU,
        nn.MaxPool2d(kernel_size=2, stride=2),  # 1/8
        nn.BatchNorm2d(128),

        # conv 4
        nn.Conv2d(in_channels=128, out_channels=64, kernel_size=3, stride=1, padding=1),
        nn.ReLU,
        nn.MaxPool2d(kernel_size=2, stride=2),  #1/16
        nn.BatchNorm2d(64)
    )


    self.encoder = nn.Sequential (
        # conv 5
        nn.ConvTranspose2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, …

我遇到过许多用于分类问题的神经网络架构。AlexNet、ResNet、VGGNet、GoogLeNet 等......是否有类似的回归问题网络可用于迁移学习？

numpy.powerpytorch 中有类似的吗？

该函数基本上将第一个张量中的每个元素计算为第二个张量中每个对应元素所表示的幂。

我正在尝试学习如何从头开始编写非常简单的神经网络。但是我看不到如何进行正确的培训。每当我运行 while 循环时，它就会陷入无限循环。这是我的代码：

#inputs and targets
x1=[1,0,1]
x2=[0,1,0]
x3=[0,0,1]
inputs=[x1,x2,x3]
targets=[1,0,0,1]

#parameters
np.random.seed(1)
w1 = np.random.random_sample(size = 3)
w1=w1.tolist()
alpha=0.1
itera=0

#activation function
def purelin(z):
    return z

#network
def red(i,w1):
    n=[]
    for inp in i:
        a=inp*w1[inputs.index(i)]
        n.append(a)
    n=sum(n) #sumar inputs*weights (caso sin bias)
    a=purelin(n)
    return a

#forward propagation
def forw(inputs):
    outputs=[]
    for i in inputs:
        x=red(i,w1)
        outputs.append(x)
    return outputs

#error
def error(targets, outputs):
    e=[]
    zip_object = zip(targets, outputs)
    for i, j in zip_object:
        e.append(i-j)
    return e 


#backpropagation 
def back(e):
    w1_=[] …