My code does not train

[RodrigoC26]

Good morning guys, I made a code in pytorch for the optimization of airfoils but it still has huge errors and can't train properly, I'll attach my excel file here and also my code in colab, maybe someone can tell me to help?
Copy the code to Colab and see what is happening!
Big hug guys!

PERFIS1.csv

import csv
import torch
import pandas as pd
import seaborn as sns
import numpy as np
from google.colab import drive

data_path= "./drive/MyDrive/PERFIS1.csv"

#drive.mount('/content/gdrive')
#dir = "./gdrive/My Drive/"

#df = pd.read_csv(dir+'PERFIS1.csv')

#npfile=np.load(dir+'data-airfoils.npz')

#df = pd.read_csv('heart_data.csv')
print(data_path)

#heart_disease= pd.read_csv(data_path, dtype= np.float32, delimiter = ';', skiprows=1)
heart_disease= np.loadtxt(data_path, dtype= np.float32, delimiter = ';', skiprows=1)
#np_array = np.fromstring(heart_disease, dtype='float', sep=" ")

#print(heart_disease)

x = heart_disease[:, 0:10]
y = heart_disease[:, 10:12]

x.shape

print(x)
print(y)

type(x), type(y),x.dtype, y.dtype, x.shape, y.shape

import pandas as pd
table = pd.DataFrame({'X1': x[:, 0], 'X2': x[:,1], 'X3': x[:, 2], 'X4': x[:,3],'X5': x[:, 4], 'X6': x[:,5],
'X7': x[:, 6], 'X8': x[:,7],'X9': x[:, 8], 'X10': x[:,9],'CL': y[:,0], 'CL/CD':y[:,1]})

table.head(50) # so ha 26 resultados //27

#convert data to tensors and then to train and test splits
import torch

from sklearn.model_selection import train_test_split

#turn data into tensors
x = torch.from_numpy(np.asarray(x)).type(torch.float) ##VER VER VER
y = torch.from_numpy(np.asarray(y)).type(torch.float) ##VER VER VER

#Split into train and test sets

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size= 0.2, random_state= 42)

x_train[:5], y_train[:5]

import torch
from torch import nn

#Make device agnostic code

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

device

#Build a model with non-linear activation functions
from torch import nn
class circlemodelV2(nn.Module):
def init(self):
super().init()
self.layer1 = nn.Linear(in_features=10, out_features=100)
self.relu = nn.ReLU()
self.layer2 = nn.Linear(in_features=100 , out_features = 100)
self.relu = nn.ReLU()
self.layer3 = nn.Linear(in_features=100 , out_features = 100)
self.relu = nn.ReLU()
self.layer4 = nn.Linear(in_features=100 , out_features = 100)
self.relu = nn.ReLU()
self.layer5 = nn.Linear(in_features=100 , out_features = 100)
self.relu = nn.ReLU()
self.layer6 = nn.Linear(in_features=100 , out_features = 100)
self.relu = nn.ReLU()
self.layer7 = nn.Linear(in_features=100 , out_features = 100)
self.relu = nn.ReLU()
self.layer8 = nn.Linear(in_features=100 , out_features = 100)
self.relu = nn.ReLU()
self.layer9 = nn.Linear(in_features=100 , out_features = 100)
self.relu = nn.ReLU()
self.layer10 = nn.Linear(in_features=100 , out_features = 2)
self.relu = nn.ReLU() #relu is a non linear activation fucntion

def forward(self, x):
# where should we put our non linear activation function?
return self.layer10(self.relu(self.layer9(self.relu(self.layer8(self.relu(self.layer7(self.relu(self.layer6(self.relu(self.layer5(self.relu(self.layer4(self.relu(self.layer3(self.relu(self.layer2(self.relu(self.layer1(x)))))))))))))))))))

model_0 = circlemodelV2().to(device)

model_0

#setup loss and optimizer

Loss function

#loss_fn = nn.BCEWithLogitsLoss()
loss_fn =nn.HingeEmbeddingLoss()

#Optimizer

optimizer = torch.optim.Adam(model_0.parameters(), lr= 0.1)

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

import requests
from pathlib import Path

if Path("helper_functions.py").is_file():
print("helper func")

else:
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)

from helper_functions import plot_predictions, plot_decision_boundary

#Random seeds
torch.manual_seed(42)
torch.cuda.manual_seed(42)

#Put all data on target 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)

#Loop trough data
epochs=1000

for epoch in range(epochs):

Training

model_0.train()

#1. Forward Pass
y_logits = model_0(x_train).squeeze()
y_pred = torch.round(torch.sigmoid(y_logits)) #logits -> prediction probabilities -> prediction labels

#2. Calculate the loss
loss = loss_fn(y_logits, y_train) #BCEWithLogitsLoss (takes in logits as first input)
acc= accuracy_fn(y_true = y_train, y_pred = y_pred)

#3. Optimizer zero gradient
optimizer.zero_grad()

#4. Loss Backward
loss.backward()

#5. Step the optimizer
optimizer.step()

##Testing
model_0.eval()
with torch.inference_mode():
test_logits = model_0(x_test).squeeze()
test_pred = 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_pred)

#print out what is happening
if epoch %100 == 0:
print(f'Epoch: {epoch}, Loss: {loss:.4f}, Acc: {acc:.4f}, Test Loss: {test_loss:.4f}')

#Make predictions
model_0.eval()
with torch.inference_mode():
y_preds= torch.round(torch.sigmoid(model_0(x_test))).squeeze()
y_preds[:10], y_test[:10]

[abdullahalrafi-bk]

Hi, could you format it properly as shown in the video please? Steps:

• Wrap the codes in three backticks (```)
• Write python after the starting backticks (```python)

print("Hello World")

[RodrigoC26]

Python'''
import csv
import torch
import pandas as pd
import seaborn as sns
import numpy as np
from google.colab import drive

data_path= "./drive/MyDrive/PERFIS1.csv"

#drive.mount('/content/gdrive')
#dir = "./gdrive/My Drive/"

#df = pd.read_csv(dir+'PERFIS1.csv')

#npfile=np.load(dir+'data-airfoils.npz')

#df = pd.read_csv('heart_data.csv')
print(data_path)

#heart_disease= pd.read_csv(data_path, dtype= np.float32, delimiter = ';', skiprows=1)
heart_disease= np.loadtxt(data_path, dtype= np.float32, delimiter = ';', skiprows=1)
#np_array = np.fromstring(heart_disease, dtype='float', sep=" ")

#print(heart_disease)

x = heart_disease[:, 0:10]
y = heart_disease[:, 10:12]

x.shape

print(x)
print(y)

type(x), type(y),x.dtype, y.dtype, x.shape, y.shape

import pandas as pd
table = pd.DataFrame({'X1': x[:, 0], 'X2': x[:,1], 'X3': x[:, 2], 'X4': x[:,3],'X5': x[:, 4], 'X6': x[:,5],
'X7': x[:, 6], 'X8': x[:,7],'X9': x[:, 8], 'X10': x[:,9],'CL': y[:,0], 'CL/CD':y[:,1]})

table.head(50) # so ha 26 resultados //27

#convert data to tensors and then to train and test splits
import torch

from sklearn.model_selection import train_test_split

#turn data into tensors
x = torch.from_numpy(np.asarray(x)).type(torch.float) ##VER VER VER
y = torch.from_numpy(np.asarray(y)).type(torch.float) ##VER VER VER

#Split into train and test sets

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size= 0.2, random_state= 42)

x_train[:5], y_train[:5]

import torch
from torch import nn

#Make device agnostic code

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

device

#Build a model with non-linear activation functions
from torch import nn
class circlemodelV2(nn.Module):
def init(self):
super().init()
self.layer1 = nn.Linear(in_features=10, out_features=100)
self.relu = nn.ReLU()
self.layer2 = nn.Linear(in_features=100 , out_features = 100)
self.relu = nn.ReLU()
self.layer3 = nn.Linear(in_features=100 , out_features = 100)
self.relu = nn.ReLU()
self.layer4 = nn.Linear(in_features=100 , out_features = 100)
self.relu = nn.ReLU()
self.layer5 = nn.Linear(in_features=100 , out_features = 100)
self.relu = nn.ReLU()
self.layer6 = nn.Linear(in_features=100 , out_features = 100)
self.relu = nn.ReLU()
self.layer7 = nn.Linear(in_features=100 , out_features = 100)
self.relu = nn.ReLU()
self.layer8 = nn.Linear(in_features=100 , out_features = 100)
self.relu = nn.ReLU()
self.layer9 = nn.Linear(in_features=100 , out_features = 100)
self.relu = nn.ReLU()
self.layer10 = nn.Linear(in_features=100 , out_features = 2)
self.relu = nn.ReLU() #relu is a non linear activation fucntion

def forward(self, x):

where should we put our non linear activation function?

return self.layer10(self.relu(self.layer9(self.relu(self.layer8(self.relu(self.layer7(self.relu(self.layer6(self.relu(self.layer5(self.relu(self.layer4(self.relu(self.layer3(self.relu(self.layer2(self.relu(self.layer1(x)))))))))))))))))))

model_0 = circlemodelV2().to(device)

model_0

#setup loss and optimizer

Loss function
#loss_fn = nn.BCEWithLogitsLoss()
loss_fn =nn.HingeEmbeddingLoss()

#Optimizer

optimizer = torch.optim.Adam(model_0.parameters(), lr= 0.1)

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

import requests
from pathlib import Path

if Path("helper_functions.py").is_file():
print("helper func")

else:
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)

from helper_functions import plot_predictions, plot_decision_boundary

#Random seeds
torch.manual_seed(42)
torch.cuda.manual_seed(42)

#Put all data on target 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)

#Loop trough data
epochs=1000

for epoch in range(epochs):

Training
model_0.train()

#1. Forward Pass
y_logits = model_0(x_train).squeeze()
y_pred = torch.round(torch.sigmoid(y_logits)) #logits -> prediction probabilities -> prediction labels

#2. Calculate the loss
loss = loss_fn(y_logits, y_train) #BCEWithLogitsLoss (takes in logits as first input)
acc= accuracy_fn(y_true = y_train, y_pred = y_pred)

#3. Optimizer zero gradient
optimizer.zero_grad()

#4. Loss Backward
loss.backward()

#5. Step the optimizer
optimizer.step()

##Testing
model_0.eval()
with torch.inference_mode():
test_logits = model_0(x_test).squeeze()
test_pred = 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_pred)
#print out what is happening
if epoch %100 == 0:
print(f'Epoch: {epoch}, Loss: {loss:.4f}, Acc: {acc:.4f}, Test Loss: {test_loss:.4f}')

#Make predictions
model_0.eval()
with torch.inference_mode():
y_preds= torch.round(torch.sigmoid(model_0(x_test))).squeeze()
y_preds[:10], y_test[:10]
'''python