关于神经网络的问题

lqhenwunai

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

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

以下是我的相关代码:

1. def ConvertTensor(vec,grad_flag=True):
   
2.         return torch.tensor(vec,dtype=torch.float32,requires_grad=grad_flag)
   
3. 
   
4. def Normalize(flat_geom):
   
5.                 Nsample, ThreeN = flat_geom.shape
   
6.                 mean_list = []
   
7.                 std_list  = []
   
8.                 norm_geom = copy.deepcopy(flat_geom)
   
9.        
   
10.                 for i in range(Nsample):
    
11.                         each_geom = norm_geom[i]
    
12.                         mean      = np.mean(each_geom)
    
13.                         std       = np.std(each_geom)
    
14.                         norm_geom[i] = (each_geom-mean)/std                       
    
15.                         mean_list.append(mean)
    
16.                         std_list.append(std)
    
17. 
    
18.                
    
19.                 return mean_list, std_list, norm_geom
    
20. 
    
21. 
    
22. 
    
23. class Generator(nn.Module):
    
24.         """ Architecture of the Generator, uses res-blocks """
    
25. 
    
26.         def __init__(self):
    
27.                 super().__init__()
    
28.                
    
29.                 self.activation_func = nn.ReLU()
    
30.                 self.lr              = 2e-3
    
31.                 self.inp_dim         = 186
    
32.                 self.latent_dim      = 100       
    
33.                 self.Nlayer          = 3
    
34.        
    
35.                 self.model           = self.G_model()
    
36. 
    
37.         def G_model(self):
    
38.                 module_list = []
    
39.                 inp_dim = self.inp_dim
    
40. 
    
41.                 latent_dim = self.latent_dim
    
42.                 activation_func = self.activation_func
    
43.                 Nlayer = self.Nlayer
    
44. 
    
45.                 module_list.append(nn.Linear(inp_dim,latent_dim))
    
46.                 module_list.append(activation_func)       
    
47.        
    
48.                 for i in range(Nlayer):
    
49.                         module_list.append(nn.Linear(latent_dim,latent_dim))
    
50.                         module_list.append(activation_func)
    
51. 
    
52.                 module_list.append(nn.Linear (latent_dim, inp_dim)  )
    
53.                 module_list.append(activation_func)       
    
54.                 model = nn.Sequential(*module_list)
    
55. 
    
56.                 return model
    
57. 
    
58.         def forward(self,inp_dat):
    
59.                 input_tensor = ConvertTensor(inp_dat,True) #include grad
    
60.                 out=self.model(input_tensor)
    
61.                
    
62.                 return out
    
63. 
    
64.         def train(self,inp_data):
    
65. 
    
66.                 gen_tensor  = self.forward(inp_data)
    
67. 
    
68.                 return gen_tensor
    
69. 
    
70. 
    
71. 
    
72. 
    
73. if __name__=="__main__":
    
74.         filename="LessConfig.dat"
    
75.         flag=2
    
76.         inp_data = np.loadtxt(filename)
    
77. 
    
78.         norm_flag=1
    
79.         if norm_flag==1:
    
80.                 inp_tensor = ConvertTensor(inp_data,False)
    
81.         if norm_flag==2:
    
82.                 mean_list, std_list, norm_geom = Normalize(inp_data)               
    
83.                 inp_tensor = ConvertTensor(norm_geom,False)
    
84.                
    
85.         generator = Generator()
    
86. 
    
87.         for i in range(50):
    
88.                 mean = torch.mean(inp_tensor[0]).detach().numpy()
    
89.                 std  = torch.std(inp_tensor[0]).detach().numpy()
    
90.                 print(" input mean and std:" , np.round(mean,4), np.round(std,4))
    
91.                 gen_out = generator.train(inp_tensor[0])
    
92.                 mean = torch.mean(gen_out).detach().numpy()
    
93.                 std  = torch.std(gen_out).detach().numpy()
    
94.                 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 小助理，如未能正确解答您的问题，请继续追问。