This is a beginner question. I come from C++ and a python beginner. I’m confused by how the handles are passed around.

Here is the sample code

import torch

import torch.nn.functional as F

x_data = torch.Tensor(torch.Tensor([[1.0], [2.0], [3.0], [4.0]]))

y_data = torch.Tensor(torch.Tensor([[0.], [0.], [1.], [1.0]]))

class Model(torch.nn.Module):

def **init**(self):

super(Model, self).**init**()

self.linear = torch.nn.Linear(1, 1)

```
def forward(self, x):
y_pred = F.sigmoid(self.linear(x))
return y_pred
```

model = Model()

criterion = torch.nn.BCELoss(reduction=‘mean’)

optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

for epoch in range(1000):

y_pred = model(x_data)

loss = criterion(y_pred, y_data)

print(epoch, loss.data, type(loss.data))

```
optimizer.zero_grad()
loss.backward()
optimizer.step()
```

hour_var = torch.Tensor([[1.0]])

print(hour_var)

My question is that, when loss.backward() is called, how does python know it needs to look into model? criterion(y_pred, y_data) receives two tensors and call BCELoss.**forward**(). But how loss knows the calculation inside Model (e.g., Model.forward())? Is this related to the computational graph? I learned the basics, but I don’t know how the computational graph is implemented in this sample code. For example, does the tensor y_pred preserve the information about how y_pred is calculated?

Thanks in advance!