I have built my RBF net, before training, I am testing it. But I have met a strange problem. Sometimes the output is normal, sometimes the output is all nan .

The following is the minimal script reproducing the problem.

```
import torch
import torch.nn as nn
import torch.optim as optim
from torch.autograd import Variable
from torch.autograd import Function
import torch.nn.functional as F
class Gaussian(nn.Module):
def __init__(self,in_features,out_features):
super(Gaussian,self).__init__()
self.sigma=nn.Parameter(torch.Tensor(out_features))
self.center=nn.Parameter(torch.Tensor(out_features,in_features))
def forward(self,input):
dist=self.center-input
dist=torch.pow(dist,2)
dist=torch.sum(dist,1)
sigma=torch.pow(self.sigma,2)
dist=-1/2*sigma*dist
output=torch.exp(dist)
return output
class RBF(nn.Module):
def __init__(self,n_lin1,n_Gau1,n_lin2,n_Gau2,n_Soft):
super(RBF,self).__init__()
self.linear1 = nn.Linear(n_lin1,n_Gau1,bias=False)
self.Gaussian1 = Gaussian(n_Gau1,n_lin2)
self.linear2 = nn.Linear(n_lin2,n_Gau2,bias=False)
self.Gaussian2 = Gaussian(n_Gau2,n_lin3)
self.linear3 = nn.Linear(n_lin3,n_Gau3,bias=False)
self.Gaussian3 = Gaussian(n_Gau3,n_Soft)
self.Softmax = torch.nn.Softmax(0)
def forward(self,x):
x = self.linear1(x)
x = self.Gaussian1(x)
x = self.linear2(x)
x = self.Gaussian2(x)
x = self.Softmax (x)
return x
def Weight_init(m):
if isinstance(m,nn.Linear):
nn.init.normal(m.weight)
import loadcents
cents=torch.Tensor(loadcents.loadcents())
import random
def Gaussian_init(m):
if isinstance(m, Gaussian):
nn.init.normal(m.sigma,0,0.1)
n_in=m.center.size()[1]
n_out=m.center.size()[0]
tmp=m.center.clone()
nn.init.normal(tmp,0,0.3)
n_lin1=10
n_Gau1=10
n_lin2=10
n_Gau2=10
n_Soft=10
model=RBF(n_lin1,n_Gau1,n_lin2,n_Gau2,n_Soft)
model.apply(Weight_init)
model.apply(Gaussian_init)
x=Variable(torch.randn(10))
y=model(x)
print(y)
```