Esempio n. 1
0
def val(epoch, args, criterion, val_loader, test_loader, filename=None):
    fcn_model.eval()
    total_ious = []
    pixel_accs = []
    iteration = 0
    val_loss = 0
    count = 0
    for iter, (data, target) in tqdm.tqdm(
            enumerate(val_loader), total=len(val_loader),
            desc='Valid iteration=%d' % iteration, ncols=80,
            leave=False):

        if use_gpu:
            inputs = Variable(data.cuda(gpu_used))
        else:
            inputs = Variable(data)

        output = fcn_model(inputs)

        if args.loss == "CE":
            val_loss += criterion(output, target.cuda(gpu_used)).item()
        else:
            val_loss += L.lovasz_softmax(output, target.cuda(gpu_used), classes=[1]).item()

        count = count + 1

        output = output.data.cpu().numpy()

        N, c, h, w = output.shape

        pred = output.transpose(0, 2, 3, 1).reshape(-1, n_class).argmax(axis=1).reshape(N, h, w)

        target = target.cpu().numpy().reshape(N, h, w)


        for p, t in zip(pred, target):

            total_ious.append(L.iou_binary(p, t))
            pixel_accs.append(pixel_acc(p, t))


        iteration += 1

    val_loss /= count
    pixel_accs = np.array(pixel_accs).mean()
    print("epoch: {}, pix_acc: {},  IoU: {}, val_loss: {}".format(epoch, pixel_accs, np.mean(total_ious), val_loss))

    if args.file == True:
        csv_file = open(filename, "a")
        csv_file.write(str(pixel_accs) + "," + str(np.mean(total_ious)) + "," + str(val_loss) + "\n")
        csv_file.close()

    early_stopping(np.mean(total_ious))#, model)

    if early_stopping.early_stop:
        print("Early stopping")
        #test_set(test_loader)
        test_set(test_loader, filename)
        sys.exit()
def criterion(inputs, target):
    sigmoid = torch.sigmoid(inputs['out'])
    sigmoid_aux = torch.sigmoid(inputs['aux'])
    preds = (inputs['out'].data > 0).long()

    loss = L.lovasz_softmax(sigmoid, target, classes=[1], ignore=128)
    loss_aux = L.lovasz_softmax(sigmoid_aux, target, classes=[1], ignore=128)

    iou = L.iou_binary(preds, target, ignore=128, per_image=True)

    return loss + 0.5 * loss_aux, iou
Esempio n. 3
0
def test_set(test_loader, filename):
    print("TEST SET EVALUATION")
    fcn_model.eval()

    total_ious = []
    pixel_accs = []

    for iter, (data, target) in tqdm.tqdm(
            enumerate(test_loader), total=len(test_loader),
            desc='Test iteration', ncols=80,
            leave=False):

        if use_gpu:
            inputs = Variable(data.cuda())
        else:
            inputs = Variable(data)

        output = fcn_model(inputs)
        output = output.data.cpu().numpy()

        N, c, h, w = output.shape
        pred = output.transpose(0, 2, 3, 1).reshape(-1, n_class).argmax(axis=1).reshape(N, h, w)
        target = target.cpu().numpy().reshape(N, h, w)

        if iter % 100 == 0:
            now = datetime.datetime.now()
            #if args.file == True:
            img_name  = "predictions/" + str(now.day) + "_" + str(now.hour) + "_" + str(now.minute) + "-" + str(iter) + "-prediction.jpg"
            targ_name = "predictions/" + str(now.day) + "_" + str(now.hour) + "_" + str(now.minute) + "-" + str(iter) + "-truth.jpg"
            #inp_name  = "predictions/" + str(now.day) + "_" + str(now.hour) + "_" + str(now.minute) + "-" + str(iter) + "-raw.jpg"
            scipy.misc.imsave(img_name, pred.squeeze())
            scipy.misc.imsave(targ_name, target.squeeze())
            #scipy.misc.imsave(inp_name, input_print)

        for p, t in zip(pred, target):
            total_ious.append(L.iou_binary(p, t))
            pixel_accs.append(pixel_acc(p, t))

    pixel_accs = np.array(pixel_accs).mean()
    print("pix_acc: {},  IoU: {}, file: {}".format(pixel_accs, np.mean(total_ious), filename))
    csv_file = open("test_fcn_combined_results" + ".csv", "a")
    csv_file.write(str(np.mean(total_ious)) + "\n")
    csv_file.close()
Esempio n. 4
0
def val(fcn_model,
        epoch,
        args,
        criterion,
        val_loader,
        filename=None,
        filename1=None):
    fcn_model.eval()
    total_ious = []
    pixel_accs = []
    # pixel_background = []
    # pixel_building = []
    iteration = 0
    val_loss = 0
    count = 0
    for iter, (data, target) in enumerate(val_loader):

        if use_gpu:
            #print("CUDA")
            inputs = Variable(data.cuda(3))
        else:
            #print("NO CUDA")
            inputs = Variable(data)

        output = fcn_model(inputs)

        if args.loss == "CE":
            val_loss += criterion(output, target.cuda(3)).item()
        else:
            val_loss += L.lovasz_softmax(output, target.cuda(3),
                                         classes=[1]).item()

        count = count + 1

        output = output.data.cpu().numpy()

        N, c, h, w = output.shape

        pred = output.transpose(0, 2, 3,
                                1).reshape(-1, n_class).argmax(axis=1).reshape(
                                    N, h, w)
        #pred = output.transpose(0, 2, 3, 1).reshape(-1, 1).argmax(axis=1).reshape(N, h, w)

        target = target.cpu().numpy().reshape(N, h, w)

        # pixel_building.append(np.unique(target, return_counts=True)[1].item(1))
        # pixel_background.append(np.unique(target, return_counts=True)[1].item(0))

        # N, c, h, w = inputs.shape
        # input_print = inputs.cpu().numpy().reshape(c, h, w).transpose(1,2,0)

        if (iter + 1) % 700 == 0:
            now = datetime.datetime.now()
            #if args.file == True:
            img_name = "predictions/" + str(now.day) + "_" + str(
                now.hour) + "_" + str(now.minute) + "-" + str(
                    epoch) + "-" + str(iter) + "-prediction.jpg"
            targ_name = "predictions/" + str(now.day) + "_" + str(
                now.hour) + "_" + str(now.minute) + "-" + str(
                    epoch) + "-" + str(iter) + "-truth.jpg"
            #inp_name  = "predictions/" + str(now.day) + "_" + str(now.hour) + "_" + str(now.minute) + "-" + str(epoch) + "-" + str(iter) + "-raw.jpg"
            scipy.misc.imsave(img_name, pred.squeeze())
            scipy.misc.imsave(targ_name, target.squeeze())
            #scipy.misc.imsave(inp_name, input_print)

        for p, t in zip(pred, target):
            # total_ious.append(L.iou_binary(p, t))
            total_ious.append(L.iou_binary(p, t))
            pixel_accs.append(pixel_acc(p, t))

        iteration += 1

    val_loss /= count
    pixel_accs = np.array(pixel_accs).mean()
    print("epoch: {}, pix_acc: {},  IoU: {}, val_loss: {}".format(
        epoch, pixel_accs, np.mean(total_ious), val_loss))

    # if args.file == True:
    #     csv_file = open(filename, "a")
    #     csv_file.write(str(pixel_accs) + "," + str(np.mean(total_ious)) + "," + str(val_loss) + "\n")
    #     csv_file.close()

    early_stopping(np.mean(total_ious))  #, model)

    if early_stopping.early_stop:
        print("Early stopping")
        end_time = time.time()
        total_time = end_time - start_time
        print(total_time)
        timings_file = open(filename1, "a")
        timings_file.write(str(total_time) + " / " + str(epoch) + "\n")
        # model_name = "./best_fcn_models/" + filename + ".pth"
        # torch.save(fcn_model.state_dict(), model_name)
        sys.exit()
Esempio n. 5
0
def train_model(model, criterion, optimizer, scheduler, num_epochs=25):
    since = time.time()

    best_model_wts = copy.deepcopy(model.state_dict())
    best_acc = 0.0

    for epoch in range(num_epochs):
        print('Epoch {}/{}'.format(epoch, num_epochs - 1))
        print('-' * 10)
        iters = len(dataloaders['train'])
        # Each epoch has a training and validation phase
        for phase in ['train', 'val']:
            if phase == 'train':
                model.train()  # Set model to training mode
            else:
                model.eval()  # Set model to evaluate mode

            running_loss = 0.0
            running_corrects = 0
            # Iterate over data.
            for i, (inputs,
                    labels) in zip(tqdm(range(len(dataloaders[phase]))),
                                   dataloaders[phase]):
                inputs = inputs.to(device)
                labels = labels.to(device)
                if phase == 'train':
                    scheduler.step(epoch + i / iters)
                # zero the parameter gradients
                optimizer.zero_grad()

                # forward
                # track history if only in train
                with torch.set_grad_enabled(phase == 'train'):
                    output = model(inputs)
                    pred = (nn.Sigmoid()(output) > .5).long()
                    loss = criterion(output, labels, ignore=2)
                    # backward + optimize only if in training phase
                    if phase == 'train':
                        loss.backward()
                        optimizer.step()

                # statistics
                running_loss += loss.item() * inputs.size(0)
                running_corrects += L.iou_binary(
                    pred, labels, ignore=2, per_image=False) * inputs.size(0)

            epoch_loss = running_loss / dataset_sizes[phase]
            epoch_acc = running_corrects / dataset_sizes[phase]

            print('{} Overall Loss: {:.4f} IoU: {:.4f}'.format(
                phase, epoch_loss, epoch_acc))

            log = open(os.path.join(path, 'handEpoch.txt'), 'a')
            log.writelines(
                '{} Hand Overall Loss: {:.4f} No Hand IoU: {:.4f}\n\n'.format(
                    phase, epoch_loss, epoch_acc))
            log.close()
            # deep copy the model
            if phase == 'val' and epoch_acc > best_acc:
                best_acc = epoch_acc
                best_model_wts = copy.deepcopy(model.state_dict())

        print()
    time_elapsed = time.time() - since
    print('Training complete in {:.0f}m {:.0f}s'.format(
        time_elapsed // 60, time_elapsed % 60))
    print('Best val IoU: {:4f}'.format(best_acc))

    # load best model weights
    model.load_state_dict(best_model_wts)
    return model