Python 训练临床EHR pytorch模型时出现未定义错误

我在做临床EHR。我现在指的是这个和github的链接。我已经生成了数据集，并按照存储库中笔记本中的说明进行了处理。我在尝试训练模型时遇到了一个问题

构建一个类

torch.manual_seed(1)

class build_EHRNN(nn.Module):
    def __init__(self, inputDimSize=4894, hiddenDimSize=[200,200], batchSize=100, embSize=200, numClass=4894, dropout=0.5, logEps=1e-8):
        super(build_EHRNN, self).__init__()
        
        self.inputDimSize = inputDimSize
        self.hiddenDimSize = hiddenDimSize
        self.numClass = numClass
        self.embSize = embSize
        self.batchSize = batchSize
        self.dropout = nn.Dropout(p=0.5)
        self.logEps = logEps
        
        
        # Embedding inputs
        self.W_emb = nn.Parameter(torch.randn(self.inputDimSize, self.embSize).cuda())
        self.b_emb = nn.Parameter(torch.zeros(self.embSize).cuda())
        
        self.W_out = nn.Parameter(torch.randn(self.hiddenDimSize, self.numClass).cuda())
        self.b_out = nn.Parameter(torch.zeros(self.numClass).cuda())
         
        self.params = [self.W_emb, self.W_out, 
                       self.b_emb, self.b_out] 
    
    def forward(self,x, y, h, lengths, mask):
        self.emb = torch.tanh(torch.matmul(x, self.W_emb) + self.b_emb)
        input_values = self.emb
        self.outputs = [input_values]
        for i, hiddenSize in enumerate([self.hiddenDimSize, self.hiddenDimSize]):  # iterate over layers
            rnn = EHRNN(self.inputDimSize,hiddenSize,self.embSize,self.batchSize,self.numClass) # calculate hidden states
            hidden_state = []
            h = self.init_hidden().cuda()
            for i,seq in enumerate(input_values): # loop over sequences in each batch
                h = rnn(seq, h)                    
                hidden_state.append(h)    
            hidden_state = self.dropout(torch.stack(hidden_state))    # apply dropout between layers
            input_values = hidden_state
       
        y_linear = torch.matmul(hidden_state, self.W_out)  + self.b_out # fully connected layer
        yhat = F.softmax(y_linear, dim=1)  # yhat
        yhat = yhat*mask[:,:,None]   # apply mask
        
        # Loss calculation
        cross_entropy = -(y * torch.log(yhat + self.logEps) + (1. - y) * torch.log(1. - yhat + self.logEps))
        last_step = -torch.mean(y[-1] * torch.log(yhat[-1] + self.logEps) + (1. - y[-1]) * torch.log(1. - yhat[-1] + self.logEps))
        prediction_loss = torch.sum(torch.sum(cross_entropy, dim=0),dim=1)/ torch.cuda.FloatTensor(lengths)
        cost = torch.mean(prediction_loss) + 0.000001 * (self.W_out ** 2).sum() # regularize
        return (yhat, hidden_state, cost)

    def init_hidden(self):
        return torch.zeros(self.batchSize, self.hiddenDimSize)  # initial state

创建实例和培训模型

model = build_EHRNN(inputDimSize=4894, hiddenDimSize=200, batchSize=100, embSize=200, numClass=4894, dropout=0.5, logEps=1e-8)
model = model.to(device)
optimizer = torch.optim.Adadelta(model.parameters(), lr = 0.01, rho=0.90)
max_epochs = 10

loss_all = []
iteration = 0
        
for e in range(max_epochs):
    for index in random.sample(range(n_batches), n_batches):
        batchX = train[0][:n_batches*batchSize][index*batchSize:(index+1)*batchSize]
        batchY = train[1][:n_batches*batchSize][index*batchSize:(index+1)*batchSize]
        
        optimizer.zero_grad()
        
        x, y, lengths, mask = padding(batchX, batchY, 4894, 4894)
        
        if torch.cuda.is_available():
            x, y, lenghts, mask = x.cuda(), y.cuda(), lengths, mask.cuda()
        
        outputs, hidden, cost = model(x,y, h, lengths, mask)
        
        if torch.cuda.is_available():
            cost.cuda()
        cost.backward()
        nn.utils.clip_grad_norm_(model.parameters(), 5)
        optimizer.step()
        

错误：

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-14-cff1f002dced> in <module>()
     17             x, y, lenghts, mask = x.cuda(), y.cuda(), lengths, mask.cuda()
     18 
---> 19         outputs, hidden, cost = model(x,y, h, lengths, mask)
     20 
     21         if torch.cuda.is_available():

NameError: name 'h' is not defined

---------------------------------------------------------------------------
NameError回溯（最近一次呼叫上次）
在（）
17 x，y，长度，mask=x.cuda（），y.cuda（），长度，mask.cuda（）
18
--->19输出，隐藏，成本=型号（x、y、h、长度、遮罩）
20
21如果torch.cuda.U可用（）：
NameError:未定义名称“h”

更新： 删除“h”参数会产生以下错误

---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-14-6495250d91c9> in <module>()
     18 
     19         # outputs, hidden, cost = model(x,y, h, lengths, mask)
---> 20         outputs, hidden, cost = model(x, y, lengths, mask)
     21 
     22         if torch.cuda.is_available():

1 frames
/usr/local/lib/python3.6/dist-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs)
    720             result = self._slow_forward(*input, **kwargs)
    721         else:
--> 722             result = self.forward(*input, **kwargs)
    723         for hook in itertools.chain(
    724                 _global_forward_hooks.values(),

<ipython-input-7-3c831fe3ca8d> in forward(self, x, y, lengths, mask)
     36                 h = rnn(seq, h)
     37                 hidden_state.append(h)
---> 38             hidden_state = self.dropout(torch.stack(hidden_state))    # apply dropout between layers
     39             input_values = hidden_state
     40 

RuntimeError: stack expects a non-empty TensorList

---------------------------------------------------------------------------
运行时错误回溯（上次最近调用）
在（）
18
19#输出，隐藏，成本=型号（x、y、h、长度、遮罩）
--->20个输出，隐藏，成本=型号（x、y、长度、遮罩）
21
22如果torch.cuda.U可用（）：
1帧
/usr/local/lib/python3.6/dist-packages/torch/nn/modules/module.py in_call_impl（self，*input，**kwargs）
720结果=self.\u slow\u forward（*输入，**kwargs）
721其他：
-->722结果=自转发（*输入，**kwargs）
723用于itertools.chain中的挂钩(
724 _全局_向前_hooks.values（），
正向（自身、x、y、长度、遮罩）
36小时=rnn（序号，小时）
37隐藏状态追加（h）
--->38 hidden_state=self.dropout（torch.stack（hidden_state））#在层之间应用dropout
39输入值=隐藏状态
40
RuntimeError:堆栈需要非空的TensorList

我想我修复了您的错误：

将转发方法替换为：

    def forward(self,x, y, lengths, mask):
        self.emb = torch.tanh(torch.matmul(x, self.W_emb) + self.b_emb)
        input_values = self.emb
        self.outputs = [input_values]
        for i, hiddenSize in enumerate([self.hiddenDimSize, self.hiddenDimSize]):  # iterate over layers
            rnn = EHRNN(self.inputDimSize,hiddenSize,self.embSize,self.batchSize,self.numClass) # calculate hidden states
            hidden_state = []
            h = self.init_hidden().cuda()
            for i,seq in enumerate(input_values): # loop over sequences in each batch
                h = rnn(seq, h)                    
                hidden_state.append(h)    
            hidden_state = self.dropout(torch.stack(hidden_state))    # apply dropout between layers
            input_values = hidden_state
       
        y_linear = torch.matmul(hidden_state, self.W_out)  + self.b_out # fully connected layer
        yhat = F.softmax(y_linear, dim=1)  # yhat
        yhat = yhat*mask[:,:,None]   # apply mask

并替换发生错误的行：

outputs, hidden, cost = model(x, y, lengths, mask)

---

它产生了一个运行时错误：堆栈需要一个非空的张量列表。我已经更新了这个问题