Binary Classification on Circular Data

[sam009-ik]

#MAke and PLot data
import matplotlib.pyplot as plt
from sklearn.datasets import make_circles
import seaborn as sns
import pandas as pd

n_samples = 1000

_X, _y = make_circles(n_samples, noise=0.3, random_state=42)
#Here We have two features and y are the Labels (0 or 1 in this case for each sample)
print(_X.shape, _y.shape)
circles_df = pd.DataFrame({"X1": _X[:, 0],
                            "X2": _X[:, 1],
                            "y_label": _y}
                         )
print(circles_df.head())
plt.figure(figsize=(12, 8))
sns.scatterplot(data=circles_df, x="X1", y="X2", hue="y_label", palette="Paired")
_X.dtype
type(_X) #Gives numpy.ndarray```

``` import torch
from sklearn.model_selection import train_test_split

#Turn Data into Tensors
_X = torch.from_numpy(_X).type(torch.float32)
_y = torch.from_numpy(_y).type(torch.float32)

#Split Data
X_train, X_test, y_train, y_test = train_test_split(_X, _y, test_size=0.2, random_state=42)
len(X_train), len(X_test), len(y_train), len(y_test) ```

# Next I create my Model::
``` from torch import nn
class CircleModelV3(nn.Module):
    def __init__(self):
        super().__init__()
        self.layer_1 = nn.Linear(in_features=2, out_features=16)
        self.layer_2 = nn.Linear(in_features=16, out_features=10)
        self.layer_3 = nn.Linear(in_features=10, out_features=1)
        self.relu = nn.ReLU()

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

circle_model_v3 = CircleModelV3()
circle_model_v3
 
#Loss Function and Optimizer
loss_fn = nn.BCEWithLogitsLoss()
optimizer_v3 = torch.optim.Adam(params=circle_model_v3.parameters(), lr=0.001)

And Finally the training and testing Loop:

torch.manual_seed(42)
epochs = 1000
for epoch in range(epochs):
    #Do the forward pass
    circle_model_v3.train()
    y_logits = circle_model_v3(X_train).squeeze()
    y_preds = torch.round(torch.sigmoid(y_logits))
    #Calculate the loss
    loss = loss_fn(y_logits, y_train)
    acc = accuracy_fn(y_true=y_train, y_pred=y_preds)
    #
    optimizer_v3.zero_grad()
    #DO the backward pass
    loss.backward()
    #Step Gradient descent
    optimizer_v3.step()

    #Testing
    circle_model_v3.eval()
    with torch.inference_mode():
        test_logits = circle_model_v3(X_test).squeeze()
        test_preds = torch.round(torch.sigmoid(test_logits))
        test_loss = loss_fn(test_logits, y_test)
        test_acc = accuracy_fn(y_true=y_test, y_pred=test_preds)
    if epoch % 100 == 0:
         print(f"Epoch: {epoch} | Loss: {loss:.5f}, acc: {acc:.2f} | Test Loss: {test_loss:.5f}, Test Acc: {test_acc:.2f}") ```

My O/P: 
Epoch: 0 | Loss: 0.57831, acc: 69.75 | Test Loss: 0.82043, Test Acc: 54.50
Epoch: 100 | Loss: 0.57831, acc: 69.75 | Test Loss: 0.81937, Test Acc: 52.00
Epoch: 200 | Loss: 0.57832, acc: 69.75 | Test Loss: 0.81914, Test Acc: 52.50
Epoch: 300 | Loss: 0.57830, acc: 69.75 | Test Loss: 0.81946, Test Acc: 52.00
Epoch: 400 | Loss: 0.57830, acc: 69.75 | Test Loss: 0.81895, Test Acc: 52.00
Epoch: 500 | Loss: 0.57830, acc: 69.75 | Test Loss: 0.81924, Test Acc: 52.00
Epoch: 600 | Loss: 0.57829, acc: 69.88 | Test Loss: 0.81908, Test Acc: 52.00
Epoch: 700 | Loss: 0.57829, acc: 69.88 | Test Loss: 0.81912, Test Acc: 52.00
Epoch: 800 | Loss: 0.57829, acc: 70.00 | Test Loss: 0.81929, Test Acc: 52.50
Epoch: 900 | Loss: 0.57828, acc: 70.00 | Test Loss: 0.81899, Test Acc: 52.50

Basically, I have tried changing my optimizer, and learning rate , and running for more epochs, even adjusting neurons. Yet for some reason the Test loss is increasing rather, and test_acc remains same mostly...........

[sam009-ik]

I think i got it, i was adding too much noise too my model which is why it wasn't learning very well.
Once I changed noise here from 0.3 to 0.03 it works : _X, _y = make_circles(n_samples, noise=0.03, random_state=42)