关于神经网络的问题

lqhenwunai

请大神赐教，我现在有一个n维样本X，它的方差为4点几，我用一个简单的网络，不进行任何训练（即不计算任何损失函数，不做反馈），相当于对X简单做一个函数变换F(X)，得到与X等维的Y。

但是不管我这个网络怎么设计，得到的Y的方差总是接近于0. 有什么办法让Y的方差接近X的方差？

以下是我的相关代码:

def ConvertTensor(vec,grad_flag=True):
        return torch.tensor(vec,dtype=torch.float32,requires_grad=grad_flag)

def Normalize(flat_geom):
                Nsample, ThreeN = flat_geom.shape
                mean_list = []
                std_list  = []
                norm_geom = copy.deepcopy(flat_geom)
        
                for i in range(Nsample):
                        each_geom = norm_geom[i]
                        mean      = np.mean(each_geom)
                        std       = np.std(each_geom)
                        norm_geom[i] = (each_geom-mean)/std                        
                        mean_list.append(mean)
                        std_list.append(std)

                
                return mean_list, std_list, norm_geom



class Generator(nn.Module):
        """ Architecture of the Generator, uses res-blocks """

        def __init__(self):
                super().__init__()
                
                self.activation_func = nn.ReLU()
                self.lr              = 2e-3
                self.inp_dim         = 186
                self.latent_dim      = 100        
                self.Nlayer          = 3
        
                self.model           = self.G_model()

        def G_model(self):
                module_list = []
                inp_dim = self.inp_dim

                latent_dim = self.latent_dim 
                activation_func = self.activation_func
                Nlayer = self.Nlayer

                module_list.append(nn.Linear(inp_dim,latent_dim))
                module_list.append(activation_func)        
        
                for i in range(Nlayer):
                        module_list.append(nn.Linear(latent_dim,latent_dim))
                        module_list.append(activation_func)

                module_list.append(nn.Linear (latent_dim, inp_dim)  )
                module_list.append(activation_func)        
                model = nn.Sequential(*module_list)

                return model

        def forward(self,inp_dat):
                input_tensor = ConvertTensor(inp_dat,True) #include grad
                out=self.model(input_tensor)
                
                return out

        def train(self,inp_data):

                gen_tensor  = self.forward(inp_data)

                return gen_tensor




if __name__=="__main__":
        filename="LessConfig.dat"
        flag=2
        inp_data = np.loadtxt(filename)

        norm_flag=1
        if norm_flag==1:
                inp_tensor = ConvertTensor(inp_data,False)
        if norm_flag==2:
                mean_list, std_list, norm_geom = Normalize(inp_data)                
                inp_tensor = ConvertTensor(norm_geom,False)
                
        generator = Generator() 

        for i in range(50):
                mean = torch.mean(inp_tensor[0]).detach().numpy()
                std  = torch.std(inp_tensor[0]).detach().numpy()
                print(" input mean and std:" , np.round(mean,4), np.round(std,4))
                gen_out = generator.train(inp_tensor[0])
                mean = torch.mean(gen_out).detach().numpy()
                std  = torch.std(gen_out).detach().numpy()
                print("output mean and std:" , np.round(mean,4), np.round(std,4))

FishC

在神经网络中，方差的变化通常与激活函数的选择和网络的层数有关。您可以尝试以下几种方法来增加输出Y的方差：

1. 使用不同的激活函数：您可以尝试使用具有较大梯度的激活函数，例如Sigmoid函数或Tanh函数。这些函数相对于ReLU函数会产生更大的输出范围，可能会增加Y的方差。

2. 增加网络的层数：通过增加网络的层数，信息传递的路径会更长，可能会增加输出的方差。您可以尝试增加Generator类中的Nlayer参数，看看是否对Y的方差产生影响。

3. 调整学习率：您可以尝试调整学习率（self.lr）的大小。过大的学习率可能导致网络训练发散，但在不进行训练的情况下，适当增大学习率可能会增加Y的方差。

4. 尝试其他网络架构：除了ResNet，您还可以尝试其他类型的网络，例如全连接网络或卷积网络。不同的网络架构可能会产生不同的输出方差。

另外，您提供的代码片段似乎只是生成了一个网络模型，并没有对其进行训练或调用生成器生成输出Y的过程。如果您想要得到非零方差的输出，您需要对生成器进行训练，并使用损失函数和反向传播方法来调整网络参数。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。