Ok so the reply took some time as running two full networks on CPU only in parallel takes some time.
Nevertheless, doing so shows the following:
When running the same script in parallel (see bottom of paragraph) in cpu-only mode (so simple discarding any .cuda()-commands, for 4 days straight & 12 epochs in total), there is NO freezing/hang-up. When using GPUs, I get a freeze after roughly 1.5 hours or 10 epochs.
This is weird, since the script stays the same in both cases (with the exception of whether or not a GPU is used).

Below you can see the relevant functions I use, invoked subsequently:
General Setup
UNet        = network_library.UNet(**Network_Parameters)
UNet.weight_init('he_normal')

Base_Loss_t   = auxiliaries.Loss_Provider('dice_loss')
optimizer         = torch.optim.Adam(UNet.parameters(), lr=opt.lr, weight_decay=opt.l2_reg)
scheduler        = lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.2)

DataLoader-Setup
train_dataset       = Dataset_2D(path_to_data_files)
train_data_loader   = DataLoader(train_dataset, num_workers=6, batch_size=8, pin_memory=False, shuffle=True)

Note: I don’t think there is any error with the Dataloader now since it works fine using CPUs only.
Training Function
def training(epoch):
    _ = UNet.train()

    mini_dice1  = []
    mini_dice2  = []
    mini_loss   = []
    mini_time   = []

    train_data_iter = tqdm(train_data_loader, position=1)
    inp_string      = 'Epoch {} || Loss: --- | Dice: ---'.format(epoch)

    for slice_idx, full_file_dict in enumerate(train_data_iter):

        train_data_iter.set_description(inp_string)
        train_iter_start_time = time.time()

        training_slice  = full_file_dict["input_slice"]
        training_slice  = Variable(training_slice).type(torch.FloatTensor).cuda()

        #--- Run Training ---
        network_output = UNet(training_slice)

        ### BASE LOSS
        feed_dict = {'input':network_output}
        feed_dict['target'] = Variable(full_file_dict['ground_truth_mask']).cuda()

        loss       = Base_Loss_t(**feed_dict)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        mini_dice1.append(np.round(get_cuda(network_output)))
        mini_dice2.append(full_file_dict['ground_truth_mask'].numpy())

        mini_loss.append(loss.data.cpu().numpy()[0])
        mini_time.append(np.round(time.time()-train_iter_start_time,4))

I do hope I made some obvious mistake, but any help is appreciated!