Runs a command and returns a list of output lines.

Plot a bar chart. The result of x should be list or dictionary.

I mathed this one out on the piece of paper. Resulting width*height = approx max_size^2

Convert prior_boxes to (cx, cy, w, h) representation for comparison to center-size form ground truth data. Args: boxes: (tensor) poin

"Crop" predicted masks by zeroing out everything not in the predicted bbox. Vectorized by Chong (thanks Chong). Args: - masks sh

Perform nms for only the max scoring class that isn't background (class 0)

transformed_cat_id is [0,80) as indices in cfg.dataset.class_names

Initialize weights for training.

Loads weights from a compressed save file.

Convert prior_boxes to (xmin, ymin, xmax, ymax) representation for comparison to point form ground truth data. Args: boxes: (tensor)

Args: index (int): Index Returns: tuple: Tuple (image, target, masks, height, width, crowd).

Given a query string (can be already decoded for faster computation), query the entire log and return all values found by that query.

Sets the dataset of the current config.

Start timing the specific function. Note: If use_stack is True, only one timer can be active at a time. Once you stop this timer, the previo

If use_stack is True, this will stop the currently running timer and restore the previous timer on the stack if that exists. Note if use_stack is T

Log information that does not change between iterations here. This is to cut down on the file size so you're not outputing this every

Each layer is a sequence of conv layers usually preceded by a max pooling. Adapted from torchvision.models.vgg.make_layers.

Note that bbox should be a list or tuple of (x1, y1, x2, y2)

Call this once per image.

Add a downsample layer to the backbone as per what SSD does.

The segmentation should be the full mask, the size of the image and with size [h, w].

Just a quick and dirty hash function for doing a deterministic shuffle based on image_id. Source: https://stackoverflow.com/questions/66

Compute the d_change metric proposed in Box2Pix: https://lmb.informatik.uni-freiburg.de/Publications/2018/UB18/paper-box2pix.pdf Inp

coeffs should be size [num_pos, num_coeffs] instance_t should be size [num_pos] and be values from 0 to num_instances-1

Instead of using softmax, use class[0] to be p(obj) * p(IoU) as in YOLO. Then for the rest of the classes, softmax them and apply CE

Constructs a backbone given a backbone config object (see config.py).

Crops the gt masks using the predicted bboxes, scales them down, and outputs the BCE loss.

Dumps it in the format for my web app. Warning: bad code ahead!

Does the same as above but instead of pairwise, elementwise along the inner dimension.

Encode bboxes matched with each prior into the format produced by the network. See decode for more details on this format. Note that enco

Ensures that the image is the given size without distorting aspect ratio.