如何初始化特定任务的权重和反向传播修改

Question

我的模型用于基于最小化损失函数 L 来预测值。但是，损失函数没有单一的全局最小值，而是有大量达到全局最小值的位置。

所以，模型是这样的：

模型输入为[nXn]张量（假设：inp=[ [i_11, i_12, i_13, ..., i_1n],[i_21, i_22, ..., i_2n],...,[i_n1,i_n2, ..., i_nn] ]），模型输出为[nX1]张量（假设：out1=[o_1, o_2,..., o_n ]）

输出张量为out1，在函数f中传递得到out2（比方说： f(o_1, o_2, o_3,..., o_n)=[O_1, O_2, O_3, ..., O_n]）

这两个值（即out1 和out2）使用MSELoss 最小化，即Loss = ||out1 - out2||

现在，[o_1, o_2, ..., o_n] 有很多值，其损失降至最低。

但是，我想要[o_1, o_2, ..., o_n] 的值，其中|o_1| + |o_2| + |o_3| + ... + |o_n| 是最大值

现在，权重是随机初始化的：

self.weight = torch.nn.parameter.Parameter(torch.FloatTensor(in_features, out_features)) for some value of in_features and out_features

但是通过这样做，我得到了[o_1, o_2, ..., o_n] 的值，其中|o_1| + |o_2| + |o_3| + ... + |o_n| 是最小值。

我知道这个问题可以通过不使用深度学习来解决，但我正在尝试为某些任务计算获得这样的结果。

有没有办法改变这一点以获得神经网络输出预测的最大值？

或者是否有任何其他技术（反向传播更改）来更改它以获得所需的最大值输出？

提前致谢。

编辑 1：

基于answer，out1=[o_1, o_2,..., o_n ] 趋向于零值张量。在初始时期，out2=[O_1, O_2, O_3, ..., O_n] 采用非常大的值，但随后会下降到较低的值。

下面的sn-p代码将给出这个想法：

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np


class Model(nn.Module):
    def __init__(self, inp_l, hid_l, out_l=1):
        super(Model, self).__init__()
     
        self.lay1 = nn.Linear(inp_l ,hid_l)
        self.lay2 = nn.Linear(hid_l ,out_l)
        self.dp = nn.Dropout(p=0.5)
        
    def forward(self, inp):
                
        self.out1= torch.tensor([]).float()
        
        for row in range(x.shape[0]):
            y = self.lay1(inp[row])
            y = F.relu(y)
            y = self.dp(y.float())
            y = self.lay2(y)
            y = F.relu(y)
            self.out1= torch.cat((self.out1, y))
            
        return self.out1.view(inp.shape[0],-1)

def function_f(inp, out1):
    '''
    Some functional computation is done to return out2.
    '''
    return out2

def train_model(epoch):
    model.train()
    t = time.time()
    optimizer.zero_grad()
    out1 = model(inp)
    
    out2 = function_f(inp, out1)
    
    loss1 = ((out1-out2)**2).mean()
    loss2 = -out1.abs().mean()
    loss_train = loss1 + loss2
    
    loss_train.backward(retain_graph=True)

    optimizer.step()
    
    if epoch%40==0:
        print('Epoch: {:04d}'.format(epoch+1),
                  'loss_train: {:.4f}'.format(loss_train.item()),
                  'time: {:.4f}s'.format(time.time() - t))

model= Model(inp_l=10, hid_l=5, out_l=1)
optimizer = optim.Adam(model.parameters(), lr=0.001)

inp = torch.randint(100, (10, 10))

for ep in range(100):
       train_model(ep)

但是，out1 值是平凡解，即零值张量，它是最小值解。正如 EDIT 之前提到的，我想得到最大值的解决方案。

谢谢。

Answer 1

我不确定我是否明白你想要什么。

您的权重初始化也过于复杂，您可以这样做：

self.weight = torch.nn.Linear(in_features, out_featues)

如果您想获得一批输入中的最大值，您可以简单地这样做：

    y = self.weight(x)
    return y.max(dim=0)[0]

但我不完全确定你的问题是什么意思。

编辑：

看来你有两个目标。我会尝试的第一件事是将它们都转换为损失以由优化器最小化。

    loss1 = MSE(out1, out2)
    loss2 = - out1.abs().mean()
    loss = loss1 + loss2

最小化loss 将同时最小化out1 和out2 之间的MSE 并最大化out1 的绝对值。 （最小化- out1.abs().mean() 与最大化out1.abs().mean() 相同）。

请注意，作为目标的惰性解决方案，您的神经网络可能只会产生较大的偏差并将权重归零。你可能会转向偏见来避免这个问题，但我仍然预计会有其他一些训练问题。