Hello everybody! I am working on a code that tries to fit a theoretical curve to a set of observational data points. This could be easily achieved through least squares, but I have noticed that a very good and sophisticated way of doing it is through an algorithm of non-linear regression in PyTorch. The problem is that I don’t know any example code like this. The idea came to my mind when I was watching a video about linear regression in PyTorch, but this is the only way of doing a regression I know. What I want to do is to get the best free parameters so the theoretical curve is the best option to model the data.

Well, let’s explain the code. The class that defines the model is

```
class Mass_and_v(nn.Module):
def __init__(self, param):
super(Mass_and_v, self).__init__()
self.parameter = nn.Parameter(data=param, requires_grad=True)
# get v_circ_tot
def __call__(self, x):
r, mass_rar, _ = rar.model(self.parameter[3:], gradient_tracking=True)
r_max = r[-1]
mass_max = torch.max(mass_rar)
x_spline = x[x <= r_max]
mass_spline = chs.interp(r, mass_rar, x_spline)
v_circ = torch.where(x <= r_max,
torch.sqrt(v_circ_b(x, self.parameter[0])**2 + v_circ_MN(x, self.parameter[1:3])**2 + G_u*mass_spline/x),
torch.sqrt(v_circ_b(x, self.parameter[0])**2 + v_circ_MN(x, self.parameter[1:3])**2 + G_u*mass_max/x))
return v_circ
class FitModel(nn.Module):
def __init__(self):
super(FitModel, self).__init__()
self.nonlinear_stack = Mass_and_v(param_t)
def forward(self, x):
output = self.nonlinear_stack(x)
return output
```

Then, I instantiate the model object through

```
model = FitModel()
```

The external functions that I use are **rar.model**, **v_circ_b** and **v_circ_MN**, all of which are correctly coded using torch (let me know if you need to see the code of these functions).

So, when I run

```
for i in range(n_epoch):
pred = model(inputs)
# The loss function is a nn.MSELoss()
loss_fn = loss(pred, targets)
# We apply the backpropagation method using a torch.optim.Adam optimizer
optimizer.zero_grad()
""" The next step is to backpropagate this error through the network. Backward
propagation is kicked off when we call .backward() on the error tensor. Autograd
then calculates and stores the gradients for each model parameter in the parameter’s
.grad attribute."""
loss_fn.backward()
""" We call .step() to initiate Adam. The optimizer adjusts each parameter by
its gradient stored in .grad."""
optimizer.step()
```

I get a null grad for the **self.parameter[4:]** parameters used inside **rar.model**. Do you know what could be the problem?