Hi,
I’m programming a neural network that should give exact output if a human is sick or healthy. Given are 250 pieces of data with 5 properties and then the resulting state of health. Based on my program I could achieve 88% accuracy. How can i improve it? Here is the code:
import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
def train(D):
# Hyper-parameters
n_steps = 50
learning_rate = 0.025
weight_decay = 0.005
input_size = 13
output_size = 1
train, test = D[:round(len(D)*1)], D[round(len(D)*0.2):]
# Traindata
X = train[:, :-1].astype(np.float32)
y = train[:, -1].astype(np.float32)
X_train = torch.from_numpy(X)
y_train = torch.from_numpy(y)
feature_means = torch.mean(X_train, dim=0)
# Testdata
X = test[:, :-1].astype(np.float32)
y = test[:, -1].astype(np.float32)
X_test = torch.from_numpy(X)
y_test = torch.from_numpy(y)
# Definition of the model
class Model(nn.Module):
def __init__(self, input_size):
super(Model, self).__init__()
neur = 13
self.layers = nn.Sequential(
nn.Linear(input_size, neur),
nn.BatchNorm1d(neur, momentum = 0.03),
nn.ReLU(),
#nn.Dropout(0.01),
nn.Linear(neur, neur),
nn.PReLU(),
nn.Linear(neur, neur),
nn.ReLU(),
#nn.Dropout(0.02),
nn.Linear(neur, neur),
nn.LogSigmoid(),
nn.Linear(neur, neur),
nn.PReLU(),
nn.Softplus(),
nn.ReLU(),
#nn.Dropout(0.05),
nn.Linear(neur, neur),
nn.BatchNorm1d(neur, momentum = 0.01),
nn.PReLU(),
nn.Linear(neur, neur),
nn.ReLU(),
nn.Dropout(0.02),
nn.Linear(neur, output_size),
)
def forward(self, x):
x = x - feature_means
out = self.layers(x)
return out
"""def num_flat_features(self, x):
size = x.size()[1:]
num = 1
for i in size:
num *= i
return num"""
model = Model(input_size)
# optimizer
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, betas=(0.85, 0.875), eps=1e-16, weight_decay=weight_decay, amsgrad=False)
# training
for e in range(n_steps):
# forward pass
outputs = model.forward(X_train)[:, 0] # Xw (linear layer)
loss = criterion(outputs, y_train) # sigmoid and cross-entropy loss
# backward pass (automatically computes gradients)
optimizer.zero_grad() # reset gradients (torch accumulates them)
loss.backward() # computes gradients
# Learning_rate decay
#learning_rate -= 0.0001
# Regularisation
l1_crit = nn.L1Loss(size_average=False)
reg_loss = 0
for parameter in model.parameters():
reg_loss += l1_crit(parameter, loss)
factor = 0.00025
loss += factor * reg_loss
# Adaptive Learning Rate Decay
lr = learning_rate * (0.75 ** ((e // 10))) # Alle 10 Epochs lr ändern
for param_group in optimizer.param_groups:
param_group['lr'] = lr # vom Optimizer die lr = learning_rate ändern
# Adaptive Weight Rate Decay
w_d = weight_decay * (0.5 ** ((e // 10))) #Alle 10 Epochs weight_decay ändern
for param_group in optimizer.param_groups:
param_group['weight_decay'] = w_d # vom Optimizer die weight_decay ändern
def closure():
optimizer.zero_grad()
output = model.forward(X_train)[:, 0]
loss = criterion(output, y_train)
loss.backward()
l1_crit = nn.L1Loss(size_average=False)
reg_loss = 0
for parameter in model.parameters():
reg_loss += l1_crit(parameter, loss)
factor = 0.00025
loss += factor * reg_loss
return loss
# Optimizer-step
optimizer.step(closure)
# Train Accuracy
outputs = model.forward(X_train)[:, 0]
pred_y = outputs > 0
is_correct = torch.eq(pred_y, y_train.byte()).float()
accuracy_train = torch.mean(is_correct).item()
# Test Accuracy
outputs = model.forward(X_test)[:, 0]
pred_y = outputs > 0
is_correct = torch.eq(pred_y, y_test.byte()).float()
accuracy_test = torch.mean(is_correct).item()
return model
We achieved an accuracy between 79% and 86%.
Thank you very much 