def test_rmse(model, data_obj=None, device="cpu"):
if torch.cuda.is_available():
device = torch.device(torch.cuda.current_device())
dset_test = data_obj.load_test_data()
test_loader = DataframeDataLoader(
dset_test,
batch_size=4,
shuffle=False,
)
SSE = 0
total = 0
with torch.no_grad():
for data in test_loader:
inputs, targets = data
inputs = Variable(inputs.permute(0, 2, 1).cuda()).contiguous()
targets = Variable(targets.cuda())
# inputs, targets = inputs.to(device), Variable(targets.cuda()).to(device)
outputs = model(inputs).squeeze()
total += targets.size(0)
SSE += np.sum(np.power((outputs - targets).cpu().numpy(), 2))
return (np.sqrt(SSE/total))
def predict_cgm(data_obj, model: nn.Module) -> np.ndarray:
dset_test = data_obj.load_test_data()
test_loader = DataframeDataLoader(
dset_test,
batch_size=8,
shuffle=False,
)
device = "cpu"
if torch.cuda.is_available():
device = "cuda:0"
if torch.cuda.device_count() > 1:
model = nn.DataParallel(model)
model = model.to(device)
model.eval()
outputs = []
#loss = 0
with torch.no_grad():
for (data, target) in test_loader:
data = Variable(data.permute(0, 2, 1)).contiguous()
data = data.to(device)
target = Variable(target.unsqueeze_(1))
output = model(data)
outputs.append(output.detach().cpu())
return np.concatenate(outputs).squeeze()
def __init__(self, dataObject, model: nn.Module):
# Extract test data from data obejct
self.test_set = dataObject.load_test_data()
self.n_elements = count_iterable(self.test_set)
self.test_loader = DataframeDataLoader(
self.test_set,
batch_size=self.n_elements,
shuffle=False,
)
self.test_df = self.test_loader.sample_dataframe
self.test_predictions_delta = predict_cgm(dataObject, model)
self.test_predictions_absolute = self.test_predictions_delta + self.test_df[
'CGM']
def predict_cgm(data_obj, model: nn.Module) -> np.ndarray:
dset_test = data_obj.load_test_data()
test_loader = DataframeDataLoader(
dset_test,
batch_size=8,
shuffle=False,
)
model.eval()
outputs = []
#loss = 0
with torch.no_grad():
for (data, target) in test_loader:
data = Variable(data.permute(0, 2, 1)).contiguous()
target = Variable(target.unsqueeze_(1))
output = model(data)
outputs.append(output)
return np.concatenate(outputs).squeeze()
def train_cgm(config: dict,
data_obj=None,
max_epochs=10,
n_epochs_stop=5,
grace_period=5,
useRayTune=True,
checkpoint_dir=None):
'''
max_epochs : Maximum allowed epochs
n_epochs_stop : Number of epochs without imporvement in validation error before the training terminates
grace_period : Number of epochs before termination is allowed
'''
# Build network
model = DilatedNet(h1=config["h1"], h2=config["h2"])
# Move model between cpu and gpu
device = "cpu"
if torch.cuda.is_available():
device = "cuda:0"
if torch.cuda.device_count() > 1:
model = nn.DataParallel(model)
model.to(device)
# Optimizser and loss criterion
#criterion = nn.SmoothL1Loss(reduction='sum')
criterion = nn.MSELoss(reduction='sum')
optimizer = optim.RMSprop(model.parameters(),
lr=config['lr'],
weight_decay=config['wd']) # n
if checkpoint_dir:
model_state, optimizer_state = torch.load(
os.path.join(checkpoint_dir, "checkpoint"))
model.load_state_dict(model_state)
optimizer.load_state_dict(optimizer_state)
# Load data
trainset, valset = data_obj.load_train_and_val()
train_loader = DataframeDataLoader(
trainset,
batch_size=int(config['batch_size']),
shuffle=True,
drop_last=True,
)
val_loader = DataframeDataLoader(
valset,
batch_size=int(config['batch_size']),
shuffle=False,
)
min_val_loss = np.Inf
epochs_no_improve = 0
early_stop = False
try:
for epoch in range(max_epochs): # loop over the dataset multiple times
epoch_loss = 0.0
running_loss = 0.0
epoch_steps = 0
for i, data in enumerate(train_loader, 0):
# get the inputs; data is a list of [inputs, targets]
inputs, targets = data
inputs = Variable(inputs.permute(0, 2, 1)).contiguous()
if targets.size(0) == int(config['batch_size']):
inputs, targets = inputs.to(device), targets.to(device)
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = model(inputs)
loss = criterion(outputs, targets.reshape(-1, 1))
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
epoch_loss += loss.item()
epoch_steps += 1
print_every = -50
if i % print_every == (print_every -
1): # print every nth mini-batches
print(
"[%d, %5d] Avg loss pr element in mini batch: %.3f"
% (epoch + 1, i + 1, running_loss /
(print_every * int(config['batch_size']))))
running_loss = 0.0
# Validation loss
val_loss = 0.0
val_steps = 0
for i, data in enumerate(val_loader, 0):
with torch.no_grad():
inputs, targets = data
inputs = Variable(inputs.permute(0, 2, 1)).contiguous()
if targets.size(0) == int(config['batch_size']):
inputs, targets = inputs.to(device), targets.to(device)
outputs = model(inputs)
loss = criterion(outputs, targets.reshape(-1, 1))
val_loss += loss.cpu().numpy()
val_steps += 1
if useRayTune:
with tune.checkpoint_dir(epoch) as checkpoint_dir:
path = os.path.join(checkpoint_dir, "checkpoint")
torch.save((model.state_dict(), optimizer.state_dict()),
path)
tune.report(loss=(val_loss / val_steps))
if (val_loss / val_steps) < min_val_loss:
epoch_no_improve = 0
min_val_loss = val_loss / val_steps
if not useRayTune:
path = code_path / 'src' / 'model_state_tmp'
path.mkdir(exist_ok=True, parents=True)
path = path / 'checkpoint'
torch.save((model.state_dict(), optimizer.state_dict()),
path)
print("Saved better model!")
else:
epoch_no_improve += 1
if not useRayTune:
print('Epoch {0}'.format(epoch + 1), end='')
print(f', Training loss: {(epoch_loss/epoch_steps):1.2E}',
end='')
print(f', Validation loss: {(val_loss/val_steps):1.2E}')
if epoch > grace_period and epoch_no_improve == n_epochs_stop:
print('Early stopping!')
early_stop = True
break
if early_stop:
print("Stopped")
break
except KeyboardInterrupt:
print('-' * 89)
print('Forced early training exit')
print("Finished Training")
"wd": 4e-3,
}
model = DilatedNet(
h1=config["h1"],
h2=config["h2"],
h3=config["h3"],
h4=config["h4"],
)
model = model.cuda()
# Load training data
trainset, valset = data_obj.load_train_and_val()
train_loader = DataframeDataLoader(
trainset,
batch_size=int(config['batch_size']),
shuffle=True,
drop_last=True,
)
# Perform a single prediction
data = next(iter(train_loader))
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
inputs, targets = data
inputs, targets = inputs.to(device), targets.to(device)
# It is important to permute the dimensions of the input!!
inputs = Variable(inputs.permute(0, 2, 1)).contiguous()
output = model(inputs)
# %%
# ---------------------------------------------------------------------
