def train(X, y, weight_factor=10):
X = torch.tensor(X, dtype=torch.float32).to(
device) # X: (bs, features, x, y) y: (bs, classes, x, y)
y = torch.tensor(y, dtype=torch.float32).to(device)
optimizer.zero_grad()
net.train()
outputs, outputs_sigmoid = net(
X) # forward # outputs: (bs, classes, x, y)
if weight_factor > 1:
# weights = torch.ones((self.HP.BATCH_SIZE, self.HP.NR_OF_CLASSES, self.HP.INPUT_DIM[0], self.HP.INPUT_DIM[1])).cuda()
weights = torch.ones(
(self.HP.BATCH_SIZE, self.HP.NR_OF_CLASSES, y.shape[2],
y.shape[3])).cuda()
bundle_mask = y > 0
weights[bundle_mask.data] *= weight_factor # 10
if self.HP.EXPERIMENT_TYPE == "peak_regression":
loss = criterion(outputs, y, weights)
else:
loss = nn.BCEWithLogitsLoss(weight=weights)(outputs, y)
else:
if self.HP.LOSS_FUNCTION == "soft_sample_dice" or self.HP.LOSS_FUNCTION == "soft_batch_dice":
loss = criterion(outputs_sigmoid, y)
# loss = criterion(outputs_sigmoid, y) + nn.BCEWithLogitsLoss()(outputs, y)
else:
loss = criterion(outputs, y)
loss.backward() # backward
optimizer.step() # optimise
if self.HP.EXPERIMENT_TYPE == "peak_regression":
# f1 = PytorchUtils.f1_score_macro(y.data, outputs.data, per_class=True)
# f1_a = MetricUtils.calc_peak_dice_pytorch(self.HP, outputs.data, y.data, max_angle_error=self.HP.PEAK_DICE_THR)
f1 = MetricUtils.calc_peak_length_dice_pytorch(
self.HP,
outputs.detach(),
y.detach(),
max_angle_error=self.HP.PEAK_DICE_THR,
max_length_error=self.HP.PEAK_DICE_LEN_THR)
# f1 = (f1_a, f1_b)
elif self.HP.EXPERIMENT_TYPE == "dm_regression": #density map regression
f1 = PytorchUtils.f1_score_macro(y.detach() > 0.5,
outputs.detach(),
per_class=True)
else:
f1 = PytorchUtils.f1_score_macro(y.detach(),
outputs_sigmoid.detach(),
per_class=True,
threshold=self.HP.THRESHOLD)
if self.HP.USE_VISLOGGER:
# probs = outputs_sigmoid.detach().cpu().numpy().transpose(0,2,3,1) # (bs, x, y, classes)
probs = outputs_sigmoid
else:
probs = None #faster
return loss.item(), probs, f1
def train(X, y, weight_factor=10):
X = torch.from_numpy(X.astype(np.float32))
y = torch.from_numpy(y.astype(np.float32))
if torch.cuda.is_available():
X, y = Variable(X.cuda()), Variable(y.cuda(
)) # X: (bs, features, x, y) y: (bs, classes, x, y)
else:
X, y = Variable(X), Variable(y)
optimizer.zero_grad()
net.train()
outputs = net(X) # forward # outputs: (bs, classes, x, y)
loss = criterion(outputs, y)
loss.backward() # backward
optimizer.step() # optimise
f1 = PytorchUtils.f1_score_macro(y.data,
outputs.data,
per_class=True)
if self.HP.USE_VISLOGGER:
probs = outputs.data.cpu().numpy().transpose(
0, 2, 3, 1) # (bs, x, y, classes)
else:
probs = None #faster
return loss.data[0], probs, f1
def train(X, y, weight_factor=10):
X = torch.from_numpy(X.astype(np.float32))
y = torch.from_numpy(y.astype(np.float32))
if torch.cuda.is_available():
X, y = Variable(X.cuda()), Variable(y.cuda()) # X: (bs, features, x, y) y: (bs, classes, x, y)
else:
X, y = Variable(X), Variable(y)
optimizer.zero_grad()
net.train()
outputs = net(X) # forward # outputs: (bs, classes, x, y)
weights = torch.ones((self.HP.BATCH_SIZE, self.HP.NR_OF_CLASSES, self.HP.INPUT_DIM[0], self.HP.INPUT_DIM[1])).cuda()
bundle_mask = y > 0
weights[bundle_mask.data] *= weight_factor # 10
criterion = nn.BCEWithLogitsLoss(weight=weights)
loss = criterion(outputs, y)
# loss = PytorchUtils.soft_dice(outputs, y)
loss.backward() # backward
optimizer.step() # optimise
f1 = PytorchUtils.f1_score_macro(y.data, outputs.data, per_class=True)
if self.HP.USE_VISLOGGER:
probs = outputs.data.cpu().numpy().transpose(0,2,3,1) # (bs, x, y, classes)
else:
probs = None #faster
return loss.data[0], probs, f1
def train(X, y, weight_factor=10):
X = torch.from_numpy(X.astype(np.float32))
y = torch.from_numpy(y.astype(np.float32))
if torch.cuda.is_available():
X, y = Variable(X.cuda()), Variable(y.cuda()) # X: (bs, features, x, y) y: (bs, classes, x, y)
else:
X, y = Variable(X), Variable(y)
optimizer.zero_grad()
net.train()
outputs = net(X) # forward # outputs: (bs, classes, x, y)
loss = criterion(outputs, y)
loss.backward() # backward
optimizer.step() # optimise
if self.HP.CALC_F1:
f1 = PytorchUtils.f1_score_macro(y.data > self.HP.THRESHOLD, outputs.data, per_class=True, threshold=self.HP.THRESHOLD)
else:
f1 = np.ones(outputs.shape[3])
if self.HP.USE_VISLOGGER:
probs = outputs.data.cpu().numpy().transpose(0,2,3,1) # (bs, x, y, classes)
else:
# probs = outputs.data.cpu().numpy().transpose(0,2,3,1) # (bs, x, y, classes)
probs = None #faster
return loss.data[0], probs, f1
def test(X, y, weight_factor=10):
X = torch.from_numpy(X.astype(np.float32))
y = torch.from_numpy(y.astype(np.float32))
if torch.cuda.is_available():
X, y = Variable(X.cuda(),
volatile=True), Variable(y.cuda(),
volatile=True)
else:
X, y = Variable(X, volatile=True), Variable(y, volatile=True)
net.train(False)
outputs = net(X) # forward
weights = torch.ones(
(self.HP.BATCH_SIZE, self.HP.NR_OF_CLASSES,
self.HP.INPUT_DIM[0], self.HP.INPUT_DIM[1])).cuda()
bundle_mask = y > 0
weights[bundle_mask.data] *= weight_factor # 10
criterion = nn.BCEWithLogitsLoss(weight=weights)
loss = criterion(outputs, y)
# loss = criterion(outputs, y)
# loss = PytorchUtils.soft_dice(outputs, y)
f1 = PytorchUtils.f1_score_macro(y.data,
outputs.data,
per_class=True)
# probs = outputs.data.cpu().numpy().transpose(0,2,3,1) # (bs, x, y, classes)
probs = None # faster
return loss.data[0], probs, f1
def train(X, y, weight_factor=10):
X = torch.from_numpy(X.astype(np.float32))
y = torch.from_numpy(y.astype(np.float32))
if torch.cuda.is_available():
X, y = Variable(X.cuda()), Variable(y.cuda(
)) # X: (bs, features, x, y) y: (bs, classes, x, y)
else:
X, y = Variable(X), Variable(y)
optimizer.zero_grad()
net.train()
outputs = net(X) # forward # outputs: (bs, classes, x, y)
weights = torch.ones(
(self.HP.BATCH_SIZE, self.HP.NR_OF_CLASSES,
self.HP.INPUT_DIM[0], self.HP.INPUT_DIM[1])).cuda()
bundle_mask = y > 0
weights[bundle_mask.data] *= weight_factor # 10
criterion = nn.BCEWithLogitsLoss(weight=weights)
loss = criterion(outputs, y)
# loss = PytorchUtils.soft_dice(outputs, y)
loss.backward() # backward
optimizer.step() # optimise
f1 = PytorchUtils.f1_score_macro(y.data,
outputs.data,
per_class=True)
if self.HP.USE_VISLOGGER:
probs = outputs.data.cpu().numpy().transpose(
0, 2, 3, 1) # (bs, x, y, classes)
else:
probs = None #faster
return loss.data[0], probs, f1
def test(X, y):
X = torch.from_numpy(X.astype(np.float32))
y = torch.from_numpy(y.astype(np.float32))
if torch.cuda.is_available():
X, y = Variable(X.cuda(), volatile=True), Variable(y.cuda(), volatile=True)
else:
X, y = Variable(X, volatile=True), Variable(y, volatile=True)
net.train(False)
outputs = net(X) # forward
loss = criterion(outputs, y)
f1 = PytorchUtils.f1_score_macro(y.data, outputs.data, per_class=True)
# probs = outputs.data.cpu().numpy().transpose(0,2,3,1) # (bs, x, y, classes)
probs = None # faster
return loss.data[0], probs, f1
def train(X, y):
X = torch.from_numpy(X.astype(np.float32))
y = torch.from_numpy(y.astype(np.float32))
if torch.cuda.is_available():
X, y = Variable(X.cuda()), Variable(y.cuda()) # X: (bs, features, x, y) y: (bs, classes, x, y)
else:
X, y = Variable(X), Variable(y)
optimizer.zero_grad()
net.train()
outputs = net(X) # forward # outputs: (bs, classes, x, y)
loss = criterion(outputs, y)
loss.backward() # backward
optimizer.step() # optimise
f1 = PytorchUtils.f1_score_macro(y.data, outputs.data, per_class=True)
# probs = outputs.data.cpu().numpy().transpose(0,2,3,1) # (bs, x, y, classes)
probs = None #faster
return loss.data[0], probs, f1
def test(X, y, weight_factor=10):
X = torch.from_numpy(X.astype(np.float32))
y = torch.from_numpy(y.astype(np.float32))
if torch.cuda.is_available():
X, y = Variable(X.cuda(),
volatile=True), Variable(y.cuda(),
volatile=True)
else:
X, y = Variable(X, volatile=True), Variable(y, volatile=True)
net.train(False)
outputs = net(X) # forward
loss = criterion(outputs, y)
f1 = PytorchUtils.f1_score_macro(y.data,
outputs.data,
per_class=True)
# probs = outputs.data.cpu().numpy().transpose(0,2,3,1) # (bs, x, y, classes)
probs = None # faster
return loss.data[0], probs, f1
def test(X, y, weight_factor=10):
X = torch.from_numpy(X.astype(np.float32))
y = torch.from_numpy(y.astype(np.float32))
if torch.cuda.is_available():
X, y = Variable(X.cuda(), volatile=True), Variable(y.cuda(), volatile=True)
else:
X, y = Variable(X, volatile=True), Variable(y, volatile=True)
net.train(False)
outputs = net(X) # forward
loss = criterion(outputs, y)
if self.HP.CALC_F1:
f1 = PytorchUtils.f1_score_macro(y.data > self.HP.THRESHOLD, outputs.data, per_class=True, threshold=self.HP.THRESHOLD)
else:
f1 = np.ones(outputs.shape[3])
# probs = outputs.data.cpu().numpy().transpose(0,2,3,1) # (bs, x, y, classes)
probs = None # faster
return loss.data[0], probs, f1
def test(X, y, weight_factor=10):
X = torch.from_numpy(X.astype(np.float32))
y = torch.from_numpy(y.astype(np.float32))
if torch.cuda.is_available():
X, y = Variable(X.cuda(), volatile=True), Variable(y.cuda(), volatile=True)
else:
X, y = Variable(X, volatile=True), Variable(y, volatile=True)
net.train(False)
outputs = net(X) # forward
weights = torch.ones((self.HP.BATCH_SIZE, self.HP.NR_OF_CLASSES, self.HP.INPUT_DIM[0], self.HP.INPUT_DIM[1])).cuda()
bundle_mask = y > 0
weights[bundle_mask.data] *= weight_factor # 10
criterion = nn.BCEWithLogitsLoss(weight=weights)
loss = criterion(outputs, y)
# loss = criterion(outputs, y)
# loss = PytorchUtils.soft_dice(outputs, y)
f1 = PytorchUtils.f1_score_macro(y.data, outputs.data, per_class=True)
# probs = outputs.data.cpu().numpy().transpose(0,2,3,1) # (bs, x, y, classes)
probs = None # faster
return loss.data[0], probs, f1