The output changes every time I run the code

[ashraful-i]

My error

I am not sure if it's expected or not. I just want to know why my output changes each time I run the code.
I am currently running it in my environment and using Pycharm.

Currently following: https://github.com/mrdbourke/pytorch-deep-learning/blob/main/02_pytorch_classification.ipynb

My code

def make_dataset(sample_count):
    n_samples = sample_count
    X, y = make_circles(n_samples=n_samples, noise=0.03, random_state=42)

    circles = pd.DataFrame({"X1": X[:, 0], "X2": X[:, 1], "label": y})
    return X, y, circles


class CircleModelV0(nn.Module):
    def __init__(self):
        super(CircleModelV0, self).__init__()
        self.layer_1 = nn.Linear(in_features=2, out_features=5)
        self.layer_2 = nn.Linear(in_features=5, out_features=1)
        '''
        self.two_linear_layer = nn.Sequential(
            nn.Linear(in_features=2, out_features=5),
            nn.Linear(in_features=5, out_features=1)
            ).to(device)
        '''

    def forward(self, x):
        return self.layer_2(self.layer_1(x))



def accuracy_fn(y_true, y_pred):
    correct = torch.eq(y_true, y_pred).sum().item()
    acc = (correct / len(y_pred)) * 100
    return acc


def train_model(model_train: nn.Module, X_train_fn: torch.Tensor, y_train_fn: torch.Tensor):
    torch.manual_seed(42)
    loss_fn = nn.BCEWithLogitsLoss()
    optimizer = torch.optim.SGD(params=model_train.parameters(),
                                lr=0.1)

    epochs = 100
    for epoch in range(epochs):
        model_train.train()
        # 1. Forward pass (model outputs raw logits)
        y_logits = model_train(
            X_train_fn).squeeze()  # squeeze to remove extra `1` dimensions, this won't work unless model and data are on same device
        y_pred = torch.round(torch.sigmoid(y_logits))  # turn logits -> pred probs -> pred labls

        # y_logits = model_train(X_train_fn).squeeze()

        loss = loss_fn(y_logits, y_train_fn)

        acc = accuracy_fn(y_true=y_train_fn, y_pred=y_pred)

        optimizer.zero_grad()

        loss.backward()
        optimizer.step()
        ### Testing
        model_train.eval()
        with torch.inference_mode():
            # 1. Forward pass
            test_logits = model_train(X_test).squeeze()
            test_pred = torch.round(torch.sigmoid(test_logits))
            # 2. Caculate loss/accuracy
            test_loss = loss_fn(test_logits,
                                y_test)
            test_acc = accuracy_fn(y_true=y_test,
                                   y_pred=test_pred)

            # Print out what's happening every 10 epochs
            if epoch % 10 == 0:
                print(f"Epoch: {epoch} | Loss: {loss:.5f}, Accuracy: {acc:.2f}% | Test loss: {test_loss:.5f}, "
                      f"Test acc: {test_acc:.5f}")
    return model_train


def helper_func_download():
    if Path("helper_functions.py").is_file():
        print("helper_functions.py already exists, skipping download")
    else:
        print("Downloading helper_functions.py")
        request = requests.get(
            "https://raw.githubusercontent.com/mrdbourke/pytorch-deep-learning/main/helper_functions.py")
        with open("helper_functions.py", "wb") as f:
            f.write(request.content)


def plot_decision_boundary_local(model_plt: nn.Module, X_train_plt: torch.Tensor, y_train_plt: torch.Tensor,
                                 X_test_plt: torch.Tensor, y_test_plt: torch.Tensor):
    # Plot decision boundaries for training and test sets
    from helper_functions import plot_predictions, plot_decision_boundary
    plt.figure(figsize=(12, 6))
    plt.subplot(1, 2, 1)
    plt.title("Train")
    plot_decision_boundary(model_plt, X_train_plt, y_train_plt)
    plt.subplot(1, 2, 2)
    plt.title("Test")
    plot_decision_boundary(model_plt, X_test_plt, y_test_plt)
    plt.show()


if __name__ == "__main__":
    X, y, df_01 = make_dataset(sample_count=1000)
    X = torch.from_numpy(X).type(torch.float)
    y = torch.from_numpy(y).type(torch.float)

    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
                                                        random_state=42)

    print(len(X_train), len(X_test))

    device = "cuda" if torch.cuda.is_available() else "cpu"
    model_0 = CircleModelV0().to(device=device)

    X_train, y_train = X_train.to(device), y_train.to(device)
    X_test, y_test = X_test.to(device), y_test.to(device)

    print("Start training")
    updated_model = train_model(model_train=model_0, X_train_fn=X_train, y_train_fn=y_train)

    helper_func_download()
    plot_decision_boundary_local(model_plt=updated_model, X_train_plt=X_train, y_train_plt=y_train, X_test_plt=X_test,
                                 y_test_plt=y_test)

What I've tried so far

made sure I have added torch.manual_seed(42) and random_state=42

[sriram-gupta]

I ran the same code on collab , getting same results everytime .

same loss, same epoch , same accuracy

[ashraful-i]

I get a different plot each time when I run the plot_decision_boundary_local.
The overall theme looks the same, Linear line dividing a circle. But 2 plots are divided in different positions.
I think it's not a big deal. But I would have liked it to be same each time.

[sriram-gupta]

can you share the image

[sriram-gupta]

@ashraful-i Found it ,
You should set the seed value on top of the code for safe side , not while training it.

torch.manual_seed(42)

During nn.Linear() it initializes everything without seeing the manual_seed set.
Hence

Reproducibility was becoming a problem . :) I hope that helps

[sriram-gupta]

Example here ^^

@ashraful-i You can mark it answered now. :)

[ashraful-i]

Yes, you are right .. I need to set it outside the function. Thank you @sriram-gupta