HYTOS

                            path = os.path.join(project.getTempPath(), 'Tile', item.getName())

                        app_doc_data.activeDrawing.image = None

                        worker.updateBatchProgress.emit(len(drawings), 4)

            symbolThreshold = targetSymbol.getThreshold() if not forTraining else targetSymbol.getThreshold() * 0.85

                    if forTraining:

                        sw, sh = sw + 20, sh + 20

                        if forTraining:

                            searchedItemSp = [searchedItemSp[0] - 10, searchedItemSp[1] - 10]

"""

@author: Viet Nguyen <nhviet1009@gmail.com>

"""

import torch

from torch.autograd import Variable

from torch.utils.data.dataloader import default_collate

def custom_collate_fn(batch):

    items = list(zip(*batch))

    items[0] = default_collate(items[0])

    items[1] = list(items[1])

    return items

def post_processing(logits, image_size, gt_classes, anchors, conf_threshold, nms_threshold):

    num_anchors = len(anchors)

    anchors = torch.Tensor(anchors)

    if isinstance(logits, Variable):

        logits = logits.data

    if logits.dim() == 3:

        logits.unsqueeze_(0)

    batch = logits.size(0)

    h = logits.size(2)

    w = logits.size(3)

    # Compute xc,yc, w,h, box_score on Tensor

    lin_x = torch.linspace(0, w - 1, w).repeat(h, 1).view(h * w)

    lin_y = torch.linspace(0, h - 1, h).repeat(w, 1).t().contiguous().view(h * w)

    anchor_w = anchors[:, 0].contiguous().view(1, num_anchors, 1)

    anchor_h = anchors[:, 1].contiguous().view(1, num_anchors, 1)

    if torch.cuda.is_available():

        lin_x = lin_x.cuda()

        lin_y = lin_y.cuda()

        anchor_w = anchor_w.cuda()

        anchor_h = anchor_h.cuda()

    logits = logits.view(batch, num_anchors, -1, h * w)

    logits[:, :, 0, :].sigmoid_().add_(lin_x).div_(w)

    logits[:, :, 1, :].sigmoid_().add_(lin_y).div_(h)

    logits[:, :, 2, :].exp_().mul_(anchor_w).div_(w)

    logits[:, :, 3, :].exp_().mul_(anchor_h).div_(h)

    logits[:, :, 4, :].sigmoid_()

    with torch.no_grad():

        cls_scores = torch.nn.functional.softmax(logits[:, :, 5:, :], 2)

    cls_max, cls_max_idx = torch.max(cls_scores, 2)

    cls_max_idx = cls_max_idx.float()

    cls_max.mul_(logits[:, :, 4, :])

    score_thresh = cls_max > conf_threshold

    score_thresh_flat = score_thresh.view(-1)

    if score_thresh.sum() == 0:

        predicted_boxes = []

        for i in range(batch):

            predicted_boxes.append(torch.Tensor([]))

    else:

        coords = logits.transpose(2, 3)[..., 0:4]

        coords = coords[score_thresh[..., None].expand_as(coords)].view(-1, 4)

        scores = cls_max[score_thresh]

        idx = cls_max_idx[score_thresh]

        detections = torch.cat([coords, scores[:, None], idx[:, None]], dim=1)

        max_det_per_batch = num_anchors * h * w

        slices = [slice(max_det_per_batch * i, max_det_per_batch * (i + 1)) for i in range(batch)]

        det_per_batch = torch.IntTensor([score_thresh_flat[s].int().sum() for s in slices])

        split_idx = torch.cumsum(det_per_batch, dim=0)

        # Group detections per image of batch

        predicted_boxes = []

        start = 0

        for end in split_idx:

            predicted_boxes.append(detections[start: end])

            start = end

    selected_boxes = []

    for boxes in predicted_boxes:

        if boxes.numel() == 0:

            return boxes

        a = boxes[:, :2]

        b = boxes[:, 2:4]

        bboxes = torch.cat([a - b / 2, a + b / 2], 1)

        scores = boxes[:, 4]

        # Sort coordinates by descending score

        scores, order = scores.sort(0, descending=True)

        x1, y1, x2, y2 = bboxes[order].split(1, 1)

        # Compute dx and dy between each pair of boxes (these mat contain every pair twice...)

        dx = (x2.min(x2.t()) - x1.max(x1.t())).clamp(min=0)

        dy = (y2.min(y2.t()) - y1.max(y1.t())).clamp(min=0)

        # Compute iou

        intersections = dx * dy

        areas = (x2 - x1) * (y2 - y1)

        unions = (areas + areas.t()) - intersections

        ious = intersections / unions

        # Filter based on iou (and class)

        conflicting = (ious > nms_threshold).triu(1)

        keep = conflicting.sum(0).byte()

        keep = keep.cpu()

        conflicting = conflicting.cpu()

        keep_len = len(keep) - 1

        for i in range(1, keep_len):

            if keep[i] > 0:

                keep -= conflicting[i]

        if torch.cuda.is_available():

            keep = keep.cuda()

        keep = (keep == 0)

        selected_boxes.append(boxes[order][keep[:, None].expand_as(boxes)].view(-1, 6).contiguous())

    final_boxes = []

    for boxes in selected_boxes:

        if boxes.dim() == 0:

            final_boxes.append([])

        else:

            boxes[:, 0:3:2] *= image_size

            boxes[:, 0] -= boxes[:, 2] / 2

            boxes[:, 1:4:2] *= image_size

            boxes[:, 1] -= boxes[:, 3] / 2

            final_boxes.append([[box[0].item(), box[1].item(), box[2].item(), box[3].item(), box[4].item(),

                                 gt_classes[int(box[5].item())]] for box in boxes])

    return final_boxes

"""

@author: Viet Nguyen <nhviet1009@gmail.com>

"""

import torch.nn as nn

import torch

class YoloD(nn.Module):

    def __init__(self, pre_model, num_classes,

                 anchors=[(1.3221, 1.73145), (3.19275, 4.00944), (5.05587, 8.09892), (9.47112, 4.84053),

                          (11.2364, 10.0071)]):

        super(YoloD, self).__init__()

        self.num_classes = num_classes

        self.anchors = anchors

        self.stage1_conv1 = pre_model.stage1_conv1

        self.stage1_conv2 = pre_model.stage1_conv2

        self.stage1_conv3 = pre_model.stage1_conv3

        self.stage1_conv4 = pre_model.stage1_conv4

        self.stage1_conv5 = pre_model.stage1_conv5

        self.stage1_conv6 = pre_model.stage1_conv6

        self.stage1_conv7 = pre_model.stage1_conv7

        self.stage1_conv8 = pre_model.stage1_conv8

        self.stage1_conv9 = pre_model.stage1_conv9

        self.stage1_conv10 = pre_model.stage1_conv10

        self.stage1_conv11 = pre_model.stage1_conv11

        self.stage1_conv12 = pre_model.stage1_conv12

        self.stage1_conv13 = pre_model.stage1_conv13

        self.stage2_a_maxpl = pre_model.stage2_a_maxpl

        self.stage2_a_conv1 = pre_model.stage2_a_conv1

        self.stage2_a_conv2 = pre_model.stage2_a_conv2

        self.stage2_a_conv3 = pre_model.stage2_a_conv3

        self.stage2_a_conv4 = pre_model.stage2_a_conv4

        self.stage2_a_conv5 = pre_model.stage2_a_conv5

        self.stage2_a_conv6 = pre_model.stage2_a_conv6

        self.stage2_a_conv7 = pre_model.stage2_a_conv7

        self.stage2_b_conv = pre_model.stage2_b_conv

        self.stage3_conv1 = pre_model.stage3_conv1

        self.stage3_conv2 = nn.Conv2d(1024, len(self.anchors) * (5 + num_classes), 1, 1, 0, bias=False)

    def forward(self, input):

        output = self.stage1_conv1(input)

        output = self.stage1_conv2(output)

        output = self.stage1_conv3(output)

        output = self.stage1_conv4(output)

        output = self.stage1_conv5(output)

        output = self.stage1_conv6(output)

        output = self.stage1_conv7(output)

        output = self.stage1_conv8(output)

        output = self.stage1_conv9(output)

        output = self.stage1_conv10(output)

        output = self.stage1_conv11(output)

        output = self.stage1_conv12(output)

        output = self.stage1_conv13(output)

        residual = output

        output_1 = self.stage2_a_maxpl(output)

        output_1 = self.stage2_a_conv1(output_1)

        output_1 = self.stage2_a_conv2(output_1)

        output_1 = self.stage2_a_conv3(output_1)

        output_1 = self.stage2_a_conv4(output_1)

        output_1 = self.stage2_a_conv5(output_1)

        output_1 = self.stage2_a_conv6(output_1)

        output_1 = self.stage2_a_conv7(output_1)

        output_2 = self.stage2_b_conv(residual)

        batch_size, num_channel, height, width = output_2.data.size()

        output_2 = output_2.view(batch_size, int(num_channel / 4), height, 2, width, 2).contiguous()

        output_2 = output_2.permute(0, 3, 5, 1, 2, 4).contiguous()

        output_2 = output_2.view(batch_size, -1, int(height / 2), int(width / 2))

        output = torch.cat((output_1, output_2), 1)

        output = self.stage3_conv1(output)

        output = self.stage3_conv2(output)

        return output

if __name__ == '__main__':

    pre_path = '../trained_models/only_params_trained_yolo_voc'

    pre_model = torch.load(pre_path)

    print(pre_model.keys())

    yolo_model = YoloD(pre_model, 35)

    img = torch.zeros([2,3,448,448])

"""

@author: Viet Nguyen <nhviet1009@gmail.com>

"""

import torch.nn as nn

import torch

class Yolo(nn.Module):

    def __init__(self, num_classes,

                 anchors=[(1.3221, 1.73145), (3.19275, 4.00944), (5.05587, 8.09892), (9.47112, 4.84053),

                          (11.2364, 10.0071)]):

        super(Yolo, self).__init__()

        self.num_classes = num_classes

        self.anchors = anchors

        self.stage1_conv1 = nn.Sequential(nn.Conv2d(3, 32, 3, 1, 1, bias=False), nn.BatchNorm2d(32),

                                          nn.LeakyReLU(0.1, inplace=True), nn.MaxPool2d(2, 2))

        self.stage1_conv2 = nn.Sequential(nn.Conv2d(32, 64, 3, 1, 1, bias=False), nn.BatchNorm2d(64),

                                          nn.LeakyReLU(0.1, inplace=True), nn.MaxPool2d(2, 2))

        self.stage1_conv3 = nn.Sequential(nn.Conv2d(64, 128, 3, 1, 1, bias=False), nn.BatchNorm2d(128),

                                          nn.LeakyReLU(0.1, inplace=True))

        self.stage1_conv4 = nn.Sequential(nn.Conv2d(128, 64, 1, 1, 0, bias=False), nn.BatchNorm2d(64),

                                          nn.LeakyReLU(0.1, inplace=True))

        self.stage1_conv5 = nn.Sequential(nn.Conv2d(64, 128, 3, 1, 1, bias=False), nn.BatchNorm2d(128),

                                          nn.LeakyReLU(0.1, inplace=True), nn.MaxPool2d(2, 2))

        self.stage1_conv6 = nn.Sequential(nn.Conv2d(128, 256, 3, 1, 1, bias=False), nn.BatchNorm2d(256),

                                          nn.LeakyReLU(0.1, inplace=True))

        self.stage1_conv7 = nn.Sequential(nn.Conv2d(256, 128, 1, 1, 0, bias=False), nn.BatchNorm2d(128),

                                          nn.LeakyReLU(0.1, inplace=True))

        self.stage1_conv8 = nn.Sequential(nn.Conv2d(128, 256, 3, 1, 1, bias=False), nn.BatchNorm2d(256),

                                          nn.LeakyReLU(0.1, inplace=True), nn.MaxPool2d(2, 2))

        self.stage1_conv9 = nn.Sequential(nn.Conv2d(256, 512, 3, 1, 1, bias=False), nn.BatchNorm2d(512),

                                          nn.LeakyReLU(0.1, inplace=True))

        self.stage1_conv10 = nn.Sequential(nn.Conv2d(512, 256, 1, 1, 0, bias=False), nn.BatchNorm2d(256),

                                           nn.LeakyReLU(0.1, inplace=True))

        self.stage1_conv11 = nn.Sequential(nn.Conv2d(256, 512, 3, 1, 1, bias=False), nn.BatchNorm2d(512),

                                           nn.LeakyReLU(0.1, inplace=True))

        self.stage1_conv12 = nn.Sequential(nn.Conv2d(512, 256, 1, 1, 0, bias=False), nn.BatchNorm2d(256),

                                           nn.LeakyReLU(0.1, inplace=True))

        self.stage1_conv13 = nn.Sequential(nn.Conv2d(256, 512, 3, 1, 1, bias=False), nn.BatchNorm2d(512),

                                           nn.LeakyReLU(0.1, inplace=True))

        self.stage2_a_maxpl = nn.MaxPool2d(2, 2)

        self.stage2_a_conv1 = nn.Sequential(nn.Conv2d(512, 1024, 3, 1, 1, bias=False),

                                            nn.BatchNorm2d(1024), nn.LeakyReLU(0.1, inplace=True))

        self.stage2_a_conv2 = nn.Sequential(nn.Conv2d(1024, 512, 1, 1, 0, bias=False), nn.BatchNorm2d(512),

                                            nn.LeakyReLU(0.1, inplace=True))

        self.stage2_a_conv3 = nn.Sequential(nn.Conv2d(512, 1024, 3, 1, 1, bias=False), nn.BatchNorm2d(1024),

                                            nn.LeakyReLU(0.1, inplace=True))

        self.stage2_a_conv4 = nn.Sequential(nn.Conv2d(1024, 512, 1, 1, 0, bias=False), nn.BatchNorm2d(512),

                                            nn.LeakyReLU(0.1, inplace=True))

        self.stage2_a_conv5 = nn.Sequential(nn.Conv2d(512, 1024, 3, 1, 1, bias=False), nn.BatchNorm2d(1024),

                                            nn.LeakyReLU(0.1, inplace=True))

        self.stage2_a_conv6 = nn.Sequential(nn.Conv2d(1024, 1024, 3, 1, 1, bias=False), nn.BatchNorm2d(1024),

                                            nn.LeakyReLU(0.1, inplace=True))

        self.stage2_a_conv7 = nn.Sequential(nn.Conv2d(1024, 1024, 3, 1, 1, bias=False), nn.BatchNorm2d(1024),

                                            nn.LeakyReLU(0.1, inplace=True))

        self.stage2_b_conv = nn.Sequential(nn.Conv2d(512, 64, 1, 1, 0, bias=False), nn.BatchNorm2d(64),

                                           nn.LeakyReLU(0.1, inplace=True))

        self.stage3_conv1 = nn.Sequential(nn.Conv2d(256 + 1024, 1024, 3, 1, 1, bias=False), nn.BatchNorm2d(1024),

                                          nn.LeakyReLU(0.1, inplace=True))

        self.stage3_conv2 = nn.Conv2d(1024, len(self.anchors) * (5 + num_classes), 1, 1, 0, bias=False)

    def forward(self, input):

        output = self.stage1_conv1(input)

        output = self.stage1_conv2(output)

        output = self.stage1_conv3(output)

        output = self.stage1_conv4(output)

        output = self.stage1_conv5(output)

        output = self.stage1_conv6(output)

        output = self.stage1_conv7(output)

        output = self.stage1_conv8(output)

        output = self.stage1_conv9(output)

        output = self.stage1_conv10(output)

        output = self.stage1_conv11(output)

        output = self.stage1_conv12(output)

        output = self.stage1_conv13(output)

        residual = output

        output_1 = self.stage2_a_maxpl(output)

        output_1 = self.stage2_a_conv1(output_1)

        output_1 = self.stage2_a_conv2(output_1)

        output_1 = self.stage2_a_conv3(output_1)

        output_1 = self.stage2_a_conv4(output_1)

        output_1 = self.stage2_a_conv5(output_1)

        output_1 = self.stage2_a_conv6(output_1)

        output_1 = self.stage2_a_conv7(output_1)

        output_2 = self.stage2_b_conv(residual)

        batch_size, num_channel, height, width = output_2.data.size()

        output_2 = output_2.view(batch_size, int(num_channel / 4), height, 2, width, 2).contiguous()

        output_2 = output_2.permute(0, 3, 5, 1, 2, 4).contiguous()

        output_2 = output_2.view(batch_size, -1, int(height / 2), int(width / 2))

        output = torch.cat((output_1, output_2), 1)

        output = self.stage3_conv1(output)

        output = self.stage3_conv2(output)

        return output

if __name__ == "__main__":

    net = Yolo(20)

    print(net.stage1_conv1[0])