pytorch 1D Dropout导致学习不稳定
PyTorch是一个开源的机器学习框架，它提供了丰富的工具和库，用于构建和训练深度神经网络模型。1D Dropout是PyTorch中的一种正则化技术，用于减少神经网络模型的过拟合现象。
1D Dropout是指在神经网络的某一层中，随机地将一部分神经元的输出置为0。这样做的目的是为了防止神经网络过度依赖某些特定的神经元，从而增加模型的泛化能力。通过随机地丢弃神经元的输出，1D Dropout可以减少神经元之间的耦合，使得网络更加鲁棒和稳定。
1D Dropout的优势在于它可以有效地减少过拟合现象，提高模型的泛化能力。通过随机地丢弃神经元的输出，1D Dropout可以迫使网络学习到更加鲁棒的特征表示，从而提高模型在未见过的数据上的性能。
1D Dropout在语音识别、自然语言处理、图像处理等领域都有广泛的应用。在语音识别任务中，1D Dropout可以减少模型对特定说话人的依赖，提高模型在不同说话人之间的泛化能力。在自然语言处理任务中，1D Dropout可以减少模型对特定词语的依赖，提高模型在不同语境下的泛化能力。在图像处理任务中，1D Dropout可以减少模型对特定图像区域的依赖，提高模型对不同图像变换的鲁棒性。
腾讯云提供了一系列与PyTorch相关的产品和服务，包括云服务器、GPU实例、深度学习平台等。您可以通过腾讯云的PyTorch产品介绍页面（https://cloud.tencent.com/product/pytorch）了解更多相关信息。
相关·内容
1回答
调整GAN超参数
、、
如上面两张图片所示，在训练DCGAN模型时，梯度不稳定和波动greatly.Because，因此模型不能绘制出完美的图像，甚至绘制出人类eyes.Does可以识别的图像。有谁能告诉我如何调整参数，如辍读率或学习率或其他参数，使模型运行得更好?我将非常感谢您！这是我之前制作的模型(用Keras构建)：
鉴别器：
学习率为0.0005
丢失率为0.6
batch_size 25岁
dis=Sequential()
dis.add(Conv2D(depth*1, 5, strides=2, input_shape=(56,56,3),padding='same',ker
浏览 2提问于2017-09-24得票数 0
1回答
我在PyTorch上的代码实现的代码片段是：
model = models.vgg16(pretrained = False)
classifier = nn.Sequential(
nn.Linear(25088, 128),
nn.ReLU(True),
nn.Dropout(),
nn.Linear(128, 128),
nn.ReLU(True),
nn.Dropout(),
nn.Linear(128, 20)
)
model.classifier = classifier
浏览 0提问于2019-03-13得票数 2
回答已采纳
1回答
我想将我的pyTorch模型转换为ONNX。但是，我说错了
RuntimeError:提供的输入名称数(9)超过了输入数(7)，但是，如果我从模型中取出两个Dropout层，我的代码运行得很完美。
为什么会这样呢？
这是我的代码：
# Define the model
model = torch.nn.Sequential(
torch.nn.Linear(D_in, H),
torch.nn.ReLU(),
torch.nn.Dropout(0.2), # problem with dropout layer
torch.nn.Linear(H, H
浏览 0提问于2019-06-28得票数 1
我正在使用PyTorch，目的是学习它，我有一个非常愚蠢的问题:如何将一个矩阵乘以一个向量？
这是我尝试过的：
>>> import torch
>>> a = torch.rand(4,4)
>>> a
0.3162 0.4434 0.9318 0.8752
0.0129 0.8609 0.6402 0.2396
0.5720 0.7262 0.7443 0.0425
0.4561 0.1725 0.4390 0.8770
[torch.FloatTensor of size 4x4]
>>
浏览 2提问于2017-12-18得票数 20
回答已采纳
1回答
我正在尝试将我的顺序Keras网络移植到PyTorch。但我在LSTM单位遇到麻烦了
LSTM(512,
stateful = False,
return_sequences = True,
dropout = 0.5),
LSTM(512,
stateful = False,
return_sequences = True,
dropout = 0.5),
我应该如何用PyTorch来表述这个问题呢？尤其是辍学在PyTorch中的工作方式与在Keras中的工作方式非常不同。
浏览 2提问于2020-06-09得票数 1
我是火炬手和蟒蛇中的一员，
我在机器学习中尝试了一些代码，这些代码是我使用Google COlab在网上发现的，我得到了以下错误：
---------------------------------------------------------------------------
RuntimeError Traceback (most recent call last)
<ipython-input-4-d4b0db6cedae> in <module>()
295
浏览 3提问于2020-04-14得票数 2
回答已采纳
2回答
偶尔，我看到一些模型正在使用SpatialDropout1D而不是Dropout。例如，在词性标记神经网络中，它们使用：
model = Sequential()
model.add(Embedding(s_vocabsize, EMBED_SIZE,
input_length=MAX_SEQLEN))
model.add(SpatialDropout1D(0.2)) ##This
model.add(GRU(HIDDEN_SIZE, dropout=0.2, recurrent_dropout=0.2))
model.add(RepeatVector(
浏览 0提问于2018-05-17得票数 45
回答已采纳
我对机器学习和深度学习还不熟悉。目前，我正试图用PyTorch中的LSTM来预测时间序列数据。我遇到的问题是，我不明白我应该使用哪一种输出来进行最后的预测。我的代码如下：
class Model(nn.Module):
def __init__(self, input_size, hidden_size, output_size, seq_len, dropout):
super(Model, self).__init__()
self.input_size = input_size
self.hidden_size = hidden_size
self.o
浏览 3提问于2020-05-30得票数 1
1回答
我在PyTorch中使用预先训练过的PyTorch模型和传输学习来分类我自己的数据集。这是很好的工作，但我认为我可以进一步提高我的分类性能。我们的图像有不同的尺寸，它们都被调整大小以适应我的模型的输入(例如，224x224像素)。
然而，原始图像大小通常表示该图像属于的类的很多。因此，我认为，添加原始图像维作为模型的第二输入可能会有所帮助。
目前，我在PyTorch中构建了这样的模型：
model = resnet50(pretrained=True) # Could be another base model as well
for module, param in zip(model.m
浏览 1提问于2022-01-24得票数 0
回答已采纳
1回答
我正在Pytorch中训练一个简单的CNN，用于在一个非常小的数据集上进行分割(只有几张图像，因为这只是为了验证概念)。由于某些原因，在返回之前的训练过程中，损失飙升到6，IoU随机下降到0(联合精度指标的交集)。我想知道为什么会发生这种事？
浏览 39提问于2020-02-23得票数 0
回答已采纳
我尝试在网格地图中预测2D坐标序列。为了做到这一点，我有一个具有形状(41185, 10, 2)的训练集Input_train，所以我有41185个序列示例，它们有10个时间步长，每个步骤包含2个坐标。
这是我的模型：
self.model = Sequential()
self.model.add(LSTM(self.num_neurons, input_shape=(10, 2), dropout=self.dropout, recurrent_dropout=self.dropout,
return_seq
浏览 0提问于2018-03-20得票数 1
我创建了一个用于转移学习的PyTorch torchvision模型，使用了预先构建的ResNet50基模型，如下所示：
# Create base model from torchvision.models
model = resnet50(pretrained=True)
num_features = model.fc.in_features
# Define the network head and attach it to the model
model_head = nn.Sequential(
浏览 2提问于2022-01-09得票数 2
回答已采纳
这段代码来自PyTorch transformer： self.linear1 = Linear(d_model, dim_feedforward, **factory_kwargs)
self.dropout = Dropout(dropout)
self.linear2 = Linear(dim_feedforward, d_model, **factory_kwargs)
self.norm1 = LayerNorm(d_model, eps=layer_norm_eps, **factory_kwargs)
self.norm2 = Layer
浏览 31提问于2021-05-11得票数 4
回答已采纳
我有一个由模块组合组成的深度神经网络，如编码器、解码器等。在训练之前，我从预先训练的模型中加载其参数的一部分，仅用于模块的子集。例如，我可以加载一个预先训练好的编码器。然后，我想冻结预训练模块的参数，这样它们就不会与其他模块一起训练。在Pytorch中：
for param in submodel.parameters()
param.requires_grad = False
现在，我应该在学习期间继续对这些冻结的模块应用dropout，还是应该停用它(参见下面的示例)？为什么？
def MyModel(nn.Module):
...
def forward(x):
浏览 7提问于2020-07-29得票数 1
我得到了以下错误。
AttributeError:无法在模块之前分配模块。init()调用
我有一节课如下。
class Classifier(nn.Module):
def __init__(self, dictionary, embeddings_index, max_seq_length, args):
self.embedding = EmbeddingLayer(len(dictionary), args.emsize, args.dropout)
self.drop = nn.Dropout(args.dropout)
我在这里
浏览 1提问于2017-06-15得票数 0
1回答
我用以下几个层次训练了一个关于PyTorch闪电的堆叠式LSTM：
def __init__(self, n_features, hidden_size, batch_size, num_layers, dropout, learning_rate):
super(LSTMClassifier, self).__init__()
...
# Architecture Baseline
self.lstm = nn.LSTM(input_size=n_features,
hidden_size=hidden_siz
浏览 5提问于2022-02-11得票数 0
我试着做一个文本分类，使用电筒和火炬文本在纸空间。
我得到了
RuntimeError: ‘lengths’ argument should be a 1D CPU int64 tensor, but got 1D cuda:0 Long tensor
我的PyTorch版本是1.10.1+cu102
浏览 17提问于2021-12-20得票数 3
1回答
我正在尝试实现在PyTorch中描述的注意，但是我无法让它工作。下面是我的代码，我现在只对“一般”的注意情况感兴趣。我想知道我是否遗漏了任何明显的错误。它运行，但似乎没有学习。
class AttnDecoderRNN(nn.Module):
def __init__(self, hidden_size, output_size, dropout_p=0.1):
super(AttnDecoderRNN, self).__init__()
self.hidden_size = hidden_size
self.output_size =
浏览 0提问于2018-05-28得票数 6
回答已采纳
我的工作是很少射击学习，我想使用高效的网络作为骨干特征提取器。大多数模型使用Resnet作为特征提取器。例如，我可以使用下面的代码，它为我提取特性-
from model.res50 import ResNet
self.encoder = ResNet()
self.fc = nn.Linear(hidden_dim, num_classes)
def forward(self, data):
out = self.encoder(data)
out = self.fc(out)
return out
我正在使用这个高效网络的PyTorch实现- 有效网络-PyTo
浏览 0提问于2021-06-02得票数 0
回答已采纳
来自PyTorch Seq2Seq教程
我们看到，注意力机制严重依赖于MAX_LENGTH参数来确定attn -> attn_softmax -> attn_weights的输出维数，即
class AttnDecoderRNN(nn.Module):
def __init__(self, hidden_size, output_size, dropout_p=0.1, max_length=MAX_LENGTH):
super(AttnDecoderRNN, self).__init__()
self.hidden_size = hidde
浏览 0提问于2018-02-09得票数 4
1回答
在pytorch LSTM上循环
、、、、
我正在训练一个用于pytorch机器翻译的seq2seq模型。我希望收集每个时间步的单元状态，同时仍然具有多层和双向的灵活性，例如，您可以在pytorch的LSTM模块中找到这些信息。 为此，我使用了以下编码器和转发方法，其中我循环遍历LSTM模块。问题是，该模型训练得不是很好。在循环结束后，您可以看到使用LSTM模块的正常方式，以及使用该模块的模型列车。 那么，循环不是这样做的有效方法吗？ class encoder(nn.Module):
def __init__(self, input_dim, emb_dim, hid_dim, n_layers, dropout):
浏览 16提问于2019-07-04得票数 1
回答已采纳
2回答
我正在Pytorch中学习Logistic回归，为了更好地理解，我定义了一个定制的CrossEntropyLoss，如下所示：
def softmax(x):
exp_x = torch.exp(x)
sum_x = torch.sum(exp_x, dim=1, keepdim=True)
return exp_x/sum_x
def log_softmax(x):
return torch.exp(x) - torch.sum(torch.exp(x), dim=1, keepdim=True)
def CrossEntropyLoss(outputs
浏览 5提问于2019-10-13得票数 1
回答已采纳
我想在分类层(我使用的是PyTorch lightning)之前添加一个额外的层(和dropout)，最好的方法是什么？
浏览 62提问于2021-05-05得票数 0
回答已采纳
1回答
如何计算conv1d层在PyTorch中的形状。在PyTorch中是否有任何命令来计算这些层的大小和形状。
nn.Conv1d(depth_1, depth_2, kernel_size=kernel_size_2, stride=stride_size),
nn.ReLU(),
nn.MaxPool1d(kernel_size=2, stride=stride_size),
nn.Dropout(0.25)```
浏览 2提问于2020-06-02得票数 1
我正在尝试将CNN LSTM for keras转换为pytorch，但我遇到了麻烦。 ConvNN_model = models.Sequential()
ConvNN_model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(64, 64, 1)))
ConvNN_model.add(layers.MaxPooling2D((2, 2)))
ConvNN_model.add(layers.Conv2D(64, (3, 3), activation='relu'))
ConvNN_
浏览 57提问于2021-04-05得票数 0
回答已采纳
如何在virtualenv中使用java调用python？这是我的.sh文件 #!/bin/bash
source activate pytorch41&&
cd /home/cery/workspace/pytorch-CycleGAN-and-pix2pix&&
python test.py --dataroot datasets/vangogh2photo/SHU --name style_vangogh_pretrained --model test --no_dropout 当我在终端中使用它时，它可以运行，但在java中失败。 String[]
浏览 19提问于2019-04-18得票数 0
1回答
当我查看https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/RNN.cpp#L744时，该函数被声明为接受4个模板参数，但在调用该函数时，只有2个参数被传递给模板。在这种情况下，cell_params和io_type从何而来？ template<template<typename,typename> class LayerT,
template<typename,typename> class BidirLayerT,
typename c
浏览 12提问于2019-06-29得票数 2
回答已采纳
1回答
我正试着和LSTM和Pytorch一起练习。我用来预测评论是正面的还是负面的。我使用80%的数据集进行培训，删除标点符号，使用GloVe ( 200 dims)作为嵌入层。
在训练前，我也排除太短(长度小于50个符号的评论)和太长(超过1000个符号的评论)评论。
对于LSTM层，我在0.5 dropout中使用hidden dimension 256、num_layers 2和one directional参数。之后，我有了完全连接的图层。在培训中，我在Adam优化器(lr=0.001)中使用了lr=0.001函数。
目前，我得到了85%的验证精度和98%的训练精度后，7期。我做了以下步骤，
浏览 0提问于2019-07-02得票数 0
在由Hugginface编写的代码中，有许多具有init_weight功能的微调模型.例如()，最后有一个init_weight函数。
class BertForSequenceClassification(BertPreTrainedModel):
def __init__(self, config):
super().__init__(config)
self.num_labels = config.num_labels
self.bert = BertModel(config)
self.dropout = nn.
浏览 2提问于2020-05-27得票数 2
回答已采纳
我正试图将一个TensorFlow模型转换成Pytorch，但却陷入了这个错误。有谁可以帮我？
#getting weights and biases from tensorflow model
weights, biases = model.layers[0].get_weights()
#[1] is the dropout layer
weights2, biases2 = model.layers[2].get_weights()
#initializing pytorch
class TwoLayerNet(torch.nn.Module):
def __init__(self,
浏览 5提问于2020-06-15得票数 0
回答已采纳
1回答
我有一个来自torchtext的Bucketiterator，我将其提供给pytorch中的一个模型。如何构造迭代器的一个示例：
train_iter, val_iter = BucketIterator.splits((train,val),
batch_size=batch_size,
sort_within_batch = True,
浏览 32提问于2019-07-09得票数 3
1回答
我正在尝试将以下GRU层从PyTorch(1.9.1)转换为TensorFlow(2.6.0)： # GRU layer
self.gru = nn.GRU(64, 32, bidirectional=True, num_layers=2, dropout=0.25, batch_first=True) 我不确定我目前的实现，特别是关于参数bidirectional和num_layers的转换。我目前的重构如下： # GRU Layer
model.add(Bidirectional(GRU(32, return_sequences=True, dropout=0.25, time_majo
浏览 106提问于2021-10-21得票数 0
我曾训练过以下班的火炬闪电模型：
class LSTMClassifier(pl.LightningModule):
def __init__(self, n_features, hidden_size, batch_size, num_layers, dropout, learning_rate):
super(LSTMClassifier, self).__init__()
self.save_hyperparameters()
# Params
self.n_features = n_features
浏览 14提问于2022-03-18得票数 1
import tensorflow as tf
INPUT_SIZE = (1,28,28)
inputs = tf.keras.Input(shape=INPUT_SIZE)
dropout = tf.keras.layers.Dropout(rate=0.2)(inputs)
conv = tf.keras.layers.Conv1D(
filters=10,
kernel_size=3,
padding='same',
activation=tf.nn.relu)(dropout)
max_pool = tf.keras.layers.
浏览 14提问于2021-03-19得票数 0
回答已采纳
Pytorch的退出层将更改未设置为零的值。使用Pytorch文档示例：()：
import torch
import torch.nn as nn
m = nn.Dropout(p=0.5)
input = torch.ones(5, 5)
print(input)
tensor([[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.]])
然后我通过一个dropo
浏览 2提问于2019-11-23得票数 4
回答已采纳
1回答
我有如下的Pytorch回归模型：
model = nn.Sequential(nn.Linear(n_in, n_h_1),
nn.ReLU(),
nn.Dropout(p=0.1),
nn.Linear(n_h_1, n_h_2),
nn.ReLU(),
nn.Linear(n_h_2, n_out))
如您所见，我使用了Dropout正则化层，其退出概率为0.1。
浏览 0提问于2019-07-09得票数 1
回答已采纳
有没有人能帮我把这个模型转换成PyTorch？我已经尝试过像这样从Keras转换到PyTorch，但是训练结果不同。谢谢。
input_3d = (1, 64, 96, 96)
pool_3d = (2, 2, 2)
model = Sequential()
model.add(Convolution3D(8, 3, 3, 3, name='conv1', input_shape=input_3d,
data_format='channels_first'))
model.add(MaxPooling3D(po
浏览 1提问于2020-12-08得票数 3
1回答
--我想知道它是否对下面的代码是可用的，但现在使用的是pytorch，其中dtype = torch.cuda.FloatTensor。这里有一个直接的python代码(使用numpy):，基本上我想得到x的值，它产生最小的适应度值。
import numpy as np
import random as rand
xmax, xmin = 5, -5
pop = 30
x = (xmax-xmin)*rand.random(pop,1)
y = x**2
[minz, indexmin] = n
浏览 4提问于2017-11-13得票数 0
回答已采纳
1回答
有没有一种简单的方法将像这样的模型从keras转换到pytorch？
我在keras中的代码如下：
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.regularizers import l2
state_dim = 10
architecture = (256, 256) # units per layer
learning
浏览 2提问于2021-07-17得票数 0
在任何人建议pytorch和其他事情之前，我专门寻找Tensorflow +预培训+ MLM任务。我知道，在PyTorch上有很多博客，在Tensorflow上有很多用于微调(分类)的博客。
关于这个问题，我得到了一个语言模型，即英语+ LaTex，其中一个文本数据可以表示来自物理、化学、MAths和生物学的任何文本，而任何典型的例子都可以是这样的：
"Find the value of function x in the equation: \n \\( f(x)=\\left\\{\\begin{array}{ll}x^{2} & \\text { if } x<0
浏览 18提问于2022-01-24得票数 0
我试图用Pytorch实现一个Transformer模型，并用来自的示例进行实验，该示例从链接而来，但在PositionalEncoding类中遇到了问题，在model.py中也发现了问题。
该类的__init__()函数的代码如下：
def __init__(self, d_model, dropout=0.1, max_len=5000):
super(PositionalEncoding, self).__init__()
self.dropout = nn.Dropout(p=dropout)
pe = torch.zeros(max_len, d_model
浏览 1提问于2020-03-20得票数 1
1回答
因此，我正在尝试开发一个OCR (为了好玩)，为此，我决定首先在一页中找到文本，将它解析为文本中的字母，然后尝试逐个提取这些字母。
对于分类，我尝试基于以下数据库构建CNN：http://www.ee.surrey.ac.uk/CVSSP/demos/chars74k/
CNN的架构如下：
# CNN architecture
input = Input(shape=(32, 32, 1))
conv1 = Conv2D(32, (3, 3))(input)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
drop1 = Dropout(0.5)(
浏览 0提问于2019-09-25得票数 1
回答已采纳
我有这样的代码：
EMBEDDING_DIM = 100
MAXLEN = 16
TRUNCATING = 'post'
PADDING = 'post'
OOV_TOKEN = "<OOV>"
MAX_EXAMPLES = 160000
TRAINING_SPLIT = 0.9
# Initialize an empty numpy array with the appropriate size
EMBEDDINGS_MATRIX = np.zeros((VOCAB_SIZE+1, EMBEDDING_DIM))
# Itera
浏览 37提问于2022-04-04得票数 0
这里有一些卷积神经网络示例代码，这些代码来自Pytorch的github：上的示例目录
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.dropout1 = nn.Dropout2d(0.25)
self.dropout2 = nn.Dropout2d(0.5)
浏览 3提问于2020-06-28得票数 3
回答已采纳
1回答
对RNN最大输出层的理解
、、、、
以下是Keras中的一个简单的LSTM模型：
input = Input(shape=(max_len,))
model = Embedding(input_dim=input_dim, output_dim=embed_dim, input_length=max_len)(input)
model = Dropout(0.1)(model)
model = Bidirectional(LSTM(units=blstm_dim, return_sequences=True, recurrent_dropout=0.1))(model)
out =Dense(label_dim, activat
浏览 2提问于2018-11-26得票数 2
回答已采纳
1回答
我刚刚开始学习机器学习，我试着写了一个简单的程序，其中nn将学习简单的函数y= f(x) = 2x。
代码如下：
#x is a 1D array of 1 to 1000
x = np.arange(1,1000, 1)
y = x*2
xtrain = x[:750]
ytrain = y[:750]
xtest = x[750:]
ytest = y[750:]
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten, Conv2D
model
浏览 65提问于2018-06-11得票数 1
1回答
同时使用批发量和辍学率？
、、、
我对术语"Dropout“和"BatchNorm”之间的关系有点困惑。据我所知，
辍学是一种正则化技术，仅在训练过程中使用。
BatchNorm是一种用于加速训练速度、提高训练精度、提高训练精度的技术。但是我也看到了一些关于BatchNorm正则化技术的相互矛盾的观点？
那么，有谁能，请回答一些问题：
BatchNorm正则化技术是什么？为什么？
我们应该只在训练过程中使用BatchNorm吗？为什么？
我们能同时使用Dropout和BatchNorm吗？如果可以的话，按什么顺序？
浏览 0提问于2021-06-03得票数 1
回答已采纳
1回答
以下代码(PyTorch中的MNIST)提供了大致相同的训练损失，而不考虑前传返回的最后一层：
F.log_softmax(x)(x)
选项1是不正确的，因为我使用criterion = nn.CrossEntropyLoss()，但是结果几乎是相同的。我有遗漏什么吗？
import torch
import numpy as np
import time
from torchvision import datasets
import torchvision.transforms as transforms
# number of subprocesses to use for data lo
浏览 3提问于2020-07-16得票数 1
1回答
零滴率辍学层
、、、
在PyTorch中，我很难理解下拉层的某些方面。
正如中所述，该方法的签名是torch.nn.Dropout(p=0.5, inplace=False)，其中p是辍学率。
当选择p=0时，这个层会做什么？它是否以任何方式改变了它的投入？
浏览 2提问于2021-04-10得票数 2
回答已采纳
1回答
游戏的策略网络2048
、、、、
根据卡帕西的，我正在尝试为游戏2048实现一个策略网络代理。我知道算法需要玩一些游戏，记住输入和采取的操作，对结束分数进行归一化和平均。然而，我在设计损失函数时遇到了困难。如何正确地鼓励那些最终分数更高的行动，而不鼓励那些导致更差分数的行动？
当在输出层使用softmax时，我设计了这样的东西：
loss = sum((action - net_output) * reward)
其中action是一种热格式。然而，这种损失似乎没有多大作用，网络没有学习。我在PyTorch中的完整代码(不包括游戏环境)是。
浏览 3提问于2018-05-05得票数 2
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
云直播活动推荐
腾讯云开发者
