'fprop function that does no proposal filtering'

def fprop(self, inputs, inference=False):

    assert (self.inference == inference), 'Model    was    configured    for    inference={}'.format(self.inference)
    (self.im_shape, self.im_scale, self.gt_boxes, self.gt_classes, self.num_gt_boxes, _) = self.dataloader.get_metadata_buffers()
    real_H = int(np.round((self.im_shape.get()[1] * self._scale)))
    real_W = int(np.round((self.im_shape.get()[0] * self._scale)))
    if (self.rpn_scores_v is None):
        self.rpn_scores_v = self.rpn_obj[0].outputs.reshape((2, (-1)))[1].T
    if (self.bbox_deltas_v is None):
        self.bbox_deltas_v = self.rpn_bbox[0].outputs.reshape((4, (-1))).T
    self._bbox_transform_inv(self._dev_anchors, self.bbox_deltas_v, output=self._proposals)
    self._clip_boxes(self._proposals, self.im_shape)
    keep = self._filter_boxes(self._proposals, (self.min_bbox_size * float(self.im_scale.get())))
    self._scores[:] = ((self.rpn_scores_v * keep) - (1 - keep))
    scores_np = self._scores.get()
    scores_np.reshape((-1), self._conv_height, self._conv_width)[:, real_H:] = (-1)
    scores_np.reshape((-1), self._conv_height, self._conv_width)[:, :, real_W:] = (-1)
    self._scores[:] = self.be.array(scores_np)
    top_N_ind = self.get_top_N_index(self._scores, self.pre_nms_N)
    self.dets.fill(0)
    self.dets[:len(top_N_ind), :4] = self._proposals[top_N_ind]
    self.dets[:len(top_N_ind), 4] = self._scores[top_N_ind]
    keep = self.be.nms(self.dets, self.nms_thresh)
    keep = keep[:self.post_nms_N]
    self.num_proposals = len(keep)
    if (self.debug or (not inference)):
        self.proposals = self.dets[keep, :4].get()
        self.scores = self.dets[(keep, (-1))].get()
    self.dev_proposals.fill(0)
    self.dev_proposals[:self.num_proposals, 1:] = self.dets[keep, :4]
    if (not inference):
        ((frcn_labels, frcn_labels_mask), (frcn_bbtargets, frcn_bbmask)) = self.dataloader.get_target_buffers()
        non_zero_gt_boxes = self.gt_boxes.get()
        num_gt_boxes = self.num_gt_boxes.get()[0][0]
        non_zero_gt_boxes = non_zero_gt_boxes[:num_gt_boxes]
        all_rois = np.vstack((self.proposals, non_zero_gt_boxes))
        overlaps = calculate_bb_overlap(all_rois, non_zero_gt_boxes)
        gt_assignment = overlaps.argmax(axis=1)
        max_overlaps = overlaps.max(axis=1)
        labels = self.gt_classes.get()[:num_gt_boxes]
        labels = labels[gt_assignment]
        (keep_inds, fg_rois_this_img) = self._sample_fg_bg(max_overlaps)
        labels = labels[keep_inds]
        labels[fg_rois_this_img:] = 0
        rois = all_rois[keep_inds]
        targets = compute_targets(non_zero_gt_boxes[gt_assignment[keep_inds]], rois)
        targets = ((targets - np.array(BBOX_NORMALIZE_MEANS)) / np.array(BBOX_NORMALIZE_STDS))
        num_proposals = rois.shape[0]
        (bbox_targets, bbox_inside_weights) = self._get_bbox_regression_labels(targets, labels)
        labels_full = self._onehot_labels(labels.ravel())
        frcn_labels[:] = labels_full
        labels_mask = np.zeros((self.num_rois, self.num_classes))
        labels_mask[:num_proposals, :] = 1.0
        frcn_labels_mask[:] = np.ascontiguousarray(labels_mask.T)
        frcn_bbtargets[:] = np.ascontiguousarray(bbox_targets.T)
        frcn_bbmask[:] = np.ascontiguousarray(bbox_inside_weights.T)
        rois = np.hstack([np.zeros((num_proposals, 1)), rois])
        rois = np.ascontiguousarray(rois, dtype=np.float32)
        self.dev_proposals_filtered.fill(0)
        self.dev_proposals_filtered[:num_proposals, :] = rois
        self.num_proposals = num_proposals
        return (inputs, self.dev_proposals_filtered.T)
    else:
        return (inputs, self.dev_proposals.T)
