import torch

from sklearn import datasets

from sklearn.model_selection import train_test_split

X, Y = datasets.load_breast_cancer(return_X_y=True)

X_train, X_test, Y_train, Y_test = train_test_split(X, Y, train_size=0.8,

stratify=Y, random_state=123)

X_train, X_test, Y_train, Y_test = torch.tensor(X_train,

dtype=torch.float32),torch.tensor(X_test,
dtype=torch.float32),torch.tensor(Y_train, dtype=torch.long),torch.tensor(Y_test,
dtype=torch.long)

samples, features = X_train.shape

classes = Y_test.unique()
print(features)
print(X_train.shape, X_test.shape, Y_train.shape, Y_test.shape)
30
torch.Size([455, 30]) torch.Size([114, 30]) torch.Size([455]) torch.Size([114])
mean = X_train.mean(axis=0)
std = X_train.std(axis=0)

X_train = (X_train - mean)/ std

X_test = (X_test - mean)/ std

from torch import nn

class Regressor(nn.Module):
def __init__(self):
super(Regressor, self).__init__()
self.first_layer = nn.Linear(features, 5)
self.second_layer = nn.Linear(5, 10)
self.third_layer = nn.Linear(10, 15)
self.final_layer = nn.Linear(15,1)
self.relu = nn.ReLU()

def forward(self, X_batch):

layer_out = self.relu(self.first_layer(X_batch))
layer_out = self.relu(self.second_layer(layer_out))
layer_out = self.relu(self.third_layer(layer_out))

return self.final_layer(layer_out)
regressor = Regressor()

preds = regressor(X_train[:5])

preds
tensor([[0.3754],
[0.3797],
[0.2975],
[0.3576],
[0.3573]], grad_fn=<AddmmBackward>)
def TrainModel(model, loss_func, optimizer, X, Y, epochs=500):
for i in range(epochs):
preds = model(X) ## Make Predictions by forward pass through network

loss = loss_func(preds.ravel(), Y) ## Calculate Loss

 optimizer.zero_grad() ## Zero weights before calculating gradients
loss.backward() ## Calculate Gradients
optimizer.step() ## Update Weights

if i % 100 == 0: ## Print MSE every 100 epochs

print("MSE : {:.2f}".format(loss))
from torch.optim import SGD, RMSprop, Adam

torch.manual_seed(42) ##For reproducibility.This will make sure that same random

weights are initialized each time.

epochs = 1000
learning_rate = torch.tensor(1/1e3) # 0.001

regressor = Regressor()
mse_loss = nn.MSELoss()
optimizer = SGD(params=regressor.parameters(), lr=learning_rate)

TrainModel(regressor, mse_loss, optimizer, X_train, Y_train, epochs=epochs)

test_preds = regressor(X_test) ## Make Predictions on test dataset

test_preds[:5]
tensor([[1.3256],
[0.3810],
[2.1005],
[1.3095],
[1.4247]], grad_fn=<SliceBackward>)
train_preds = regressor(X_train) ## Make Predictions on train dataset

train_preds[:5]
tensor([[0.2373],
[0.3285],
[1.2933],
[0.3293],
[0.2826]], grad_fn=<SliceBackward>)
from sklearn.metrics import r2_score

print("Train R^2 Score :

{:.2f}".format(r2_score(train_preds.detach().numpy().squeeze(),
Y_train.detach().numpy())))
print("Test R^2 Score :
{:.2f}".format(r2_score(test_preds.detach().numpy().squeeze(),
Y_test.detach().numpy())))