def random(Boxes, num=1, scale=1.0, format='xywh', rng=None, tensor=False):
"""
Makes random boxes
Example:
>>> # xdoctest: +IGNORE_WHITESPACE
>>> Boxes.random(3, rng=0, scale=100)
<Boxes(xywh,
array([[27, 35, 30, 27],
[21, 32, 21, 44],
[48, 19, 39, 26]]))>
>>> Boxes.random(3, rng=0, scale=100, tensor=True)
<Boxes(xywh,
tensor([[ 27, 35, 30, 27],
[ 21, 32, 21, 44],
[ 48, 19, 39, 26]]))>
"""
from netharn import util
rng = util.ensure_rng(rng)
xywh = (rng.rand(num, 4) * scale / 2)
as_integer = isinstance(scale, int)
if as_integer:
xywh = xywh.astype(np.int)
if tensor:
if as_integer:
xywh = torch.LongTensor(xywh)
else:
xywh = torch.FloatTensor(xywh)
boxes = Boxes(xywh, format='xywh').toformat(format, copy=False)
return boxes
def __init__(self, size=4, border=1, n=100, rng=None):
rng = util.ensure_rng(rng)
h = w = size
whiteish = 1 - (np.abs(rng.randn(n, 1, h, w) / 4) % 1)
blackish = (np.abs(rng.randn(n, 1, h, w) / 4) % 1)
fw = border
slices = [slice(None, fw), slice(-fw, None)]
# class 0 is white block inside a black frame
data1 = whiteish.copy()
for sl1, sl2 in it.product(slices, slices):
data1[..., sl1, :] = blackish[..., sl1, :]
data1[..., :, sl2] = blackish[..., :, sl2]
# class 1 is black block inside a white frame
data2 = blackish.copy()
for sl1, sl2 in it.product(slices, slices):
data2[..., sl1, :] = whiteish[..., sl1, :]
data2[..., :, sl2] = whiteish[..., :, sl2]
self.data = np.concatenate([data1, data2], axis=0)
self.labels = np.array(([0] * n) + ([1] * n))
def compare_loss_speed():
"""
python ~/code/netharn/netharn/models/yolo2/light_region_loss.py compare_loss_speed
Example:
>>> compare_loss_speed()
"""
from netharn.models.yolo2.light_yolo import Yolo
import netharn.models.yolo2.light_region_loss
import lightnet.network
import ubelt as ub
torch.random.manual_seed(0)
network = Yolo(num_classes=2, conf_thresh=4e-2)
self1 = netharn.models.yolo2.light_region_loss.RegionLoss(
num_classes=network.num_classes, anchors=network.anchors)
self2 = lightnet.network.RegionLoss(num_classes=network.num_classes,
anchors=network.anchors)
# Win, Hin = 416, 416
Win, Hin = 96, 96
# ----- More targets -----
rng = util.ensure_rng(0)
import netharn as nh
bsize = 4
# Make a random semi-realistic set of groundtruth items
n_targets = [rng.randint(0, 10) for _ in range(bsize)]
target_list = [
torch.FloatTensor(
np.hstack([
rng.randint(0, network.num_classes, nT)[:, None],
util.Boxes.random(nT, scale=1.0, rng=rng).data
])) for nT in n_targets
]
target = nh.data.collate.padded_collate(target_list)
im_data = torch.randn(len(target), 3, Hin, Win)
output = network.forward(im_data)
self1.iou_mode = 'c'
for timer in ub.Timerit(100, bestof=10, label='cython_ious'):
with timer:
loss_cy = float(self1(output, target))
self1.iou_mode = 'py'
for timer in ub.Timerit(100, bestof=10, label='python_ious'):
with timer:
loss_py = float(self1(output, target))
for timer in ub.Timerit(100, bestof=10, label='original'):
with timer:
loss_orig = float(self2(output, target))
print('loss_cy = {!r}'.format(loss_cy))
print('loss_py = {!r}'.format(loss_py))
print('loss_orig = {!r}'.format(loss_orig))
def __init__(self, needed_std=1.0, std_tol=0.1, max_attempts=10,
do_orthonorm=True, rng=None):
self.rng = util.ensure_rng(rng)
self.do_orthonorm = do_orthonorm
self.needed_std = needed_std
self.std_tol = std_tol
self.max_attempts = max_attempts
def __init__(self, rng=None):
"""
Spiral 2d data points
CommandLine:
python ~/code/netharn/netharn/data/toydata.py ToyData1d --show
Example:
>>> dset = ToyData1d()
>>> data, labels = next(iter(dset.make_loader(batch_size=2000)))
>>> # xdoctest: +REQUIRES(--show)
>>> from netharn.util import mplutil
>>> mplutil.qtensure() # xdoc: +SKIP
>>> mplutil.figure(fnum=1, doclf=True)
>>> cls1 = data[labels == 0]
>>> cls2 = data[labels == 1]
>>> from matplotlib import pyplot as plt
>>> plt.plot(*cls1.T.numpy(), 'rx')
>>> plt.plot(*cls2.T.numpy(), 'bx')
>>> mplutil.show_if_requested()
"""
rng = util.ensure_rng(rng)
# spiral equation in parameteric form:
# x(t) = r(t) * cos(t)
# y(t) = r(t) * sin(t)
# class 1
n = 1000
theta1 = rng.rand(n) * 10
x1 = theta1 * np.cos(theta1)
y1 = theta1 * np.sin(theta1)
theta2 = rng.rand(n) * 10
x2 = -theta2 * np.cos(theta2)
y2 = -theta2 * np.sin(theta2)
data = []
labels = []
data.extend(list(zip(x1, y1)))
labels.extend([0] * n)
data.extend(list(zip(x2, y2)))
labels.extend([1] * n)
data = np.array(data)
labels = np.array(labels)
self.data = data
self.labels = labels
def svd_orthonormal(shape, rng=None, cache_key=None):
"""
If cache_key is specified, then the result will be cached, and subsequent
calls with the same key and shape will return the same result.
References:
Orthonorm init code is taked from Lasagne
https://github.com/Lasagne/Lasagne/blob/master/lasagne/init.py
"""
rng = util.ensure_rng(rng)
if len(shape) < 2:
raise RuntimeError("Only shapes of length 2 or more are supported.")
flat_shape = (shape[0], np.prod(shape[1:]))
enabled = False and cache_key is not None
if enabled:
rand_sequence = rng.randint(0, 2**16)
depends = [shape, cache_key, rand_sequence]
cfgstr = ub.hash_data(depends)
else:
cfgstr = ''
# this process can be expensive, cache it
# TODO: only cache very large matrices (4096x4096)
# TODO: only cache very large matrices, not (256,256,3,3)
cacher = ub.Cacher('svd_orthonormal',
appname='netharn',
enabled=enabled,
cfgstr=cfgstr)
q = cacher.tryload()
if q is None:
# print('Compute orthonormal matrix with shape ' + str(shape))
a = rng.normal(0.0, 1.0, flat_shape)
u, _, v = np.linalg.svd(a, full_matrices=False)
q = u if u.shape == flat_shape else v
# print(shape, flat_shape)
q = q.reshape(shape)
q = q.astype(np.float32)
cacher.save(q)
return q
def profile_loss_speed():
"""
python ~/code/netharn/netharn/models/yolo2/light_region_loss.py profile_loss_speed --profile
Benchmark:
>>> profile_loss_speed()
"""
from netharn.models.yolo2.light_yolo import Yolo
import netharn.models.yolo2.light_region_loss
import lightnet.network
import netharn as nh
rng = util.ensure_rng(0)
torch.random.manual_seed(0)
network = Yolo(num_classes=2, conf_thresh=4e-2)
self1 = netharn.models.yolo2.light_region_loss.RegionLoss(
num_classes=network.num_classes, anchors=network.anchors)
self2 = lightnet.network.RegionLoss(num_classes=network.num_classes,
anchors=network.anchors)
bsize = 8
# Make a random semi-realistic set of groundtruth items
n_targets = [rng.randint(0, 20) for _ in range(bsize)]
target_list = [
torch.FloatTensor(
np.hstack([
rng.randint(0, network.num_classes, nT)[:, None],
util.Boxes.random(nT, scale=1.0, rng=rng).data
])) for nT in n_targets
]
target = nh.data.collate.padded_collate(target_list)
Win, Hin = 416, 416
im_data = torch.randn(len(target), 3, Hin, Win)
output = network.forward(im_data)
loss1 = float(self1(output, target))
loss2 = float(self2(output, target))
print('loss1 = {!r}'.format(loss1))
print('loss2 = {!r}'.format(loss2))
def random(Boxes,
num=1,
scale=1.0,
format='tlwh',
rng=None,
tensor=False,
anchors=None,
anchor_std=1.0 / 6):
"""
Makes random boxes
Args:
num (int): number of boxes to generate
scale (float): size of imgdims
format (str): format of boxes to be created (e.g. tlbr, xywh)
anchors (ndarray): normalized width / heights of anchor boxes to
perterb and randomly place. (must be in range 0-1)
Example:
>>> # xdoctest: +IGNORE_WHITESPACE
>>> Boxes.random(3, rng=0, scale=100)
<Boxes(tlwh,
array([[54, 54, 6, 17],
[42, 64, 1, 25],
[79, 38, 17, 14]]))>
>>> Boxes.random(3, rng=0, scale=100, tensor=True)
<Boxes(tlwh,
tensor([[ 54, 54, 6, 17],
[ 42, 64, 1, 25],
[ 79, 38, 17, 14]]))>
>>> anchors = np.array([[.5, .5], [.3, .3]])
>>> Boxes.random(3, rng=0, scale=100, anchors=anchors)
<Boxes(tlwh,
array([[ 2, 13, 51, 51],
[32, 51, 32, 36],
[36, 28, 23, 26]]))>
"""
from netharn import util
rng = util.ensure_rng(rng)
as_integer = isinstance(scale, int)
if anchors is None:
tlbr = rng.rand(num, 4)
tl_x = np.minimum(tlbr[:, 0], tlbr[:, 2])
tl_y = np.minimum(tlbr[:, 1], tlbr[:, 3])
br_x = np.maximum(tlbr[:, 0], tlbr[:, 2])
br_y = np.maximum(tlbr[:, 1], tlbr[:, 3])
tlbr[:, 0] = tl_x
tlbr[:, 1] = tl_y
tlbr[:, 2] = br_x
tlbr[:, 3] = br_y
else:
anchors = np.asarray(anchors)
assert np.all(anchors <= 1.0)
assert np.all(anchors > 0.0)
anchor_xs = rng.randint(0, len(anchors), size=num)
base_whs = anchors[anchor_xs]
rand_whs = np.clip(
base_whs * np.exp(rng.randn(num, 2) * anchor_std), 0, 1)
# Allow cxy to vary within the allowed range
min_cxy = rand_whs / 2
max_cxy = (1 - min_cxy)
rel_cxy = rng.rand(num, 2) * .99
rand_cxwy = rel_cxy * (max_cxy - min_cxy) + min_cxy
cxywh = np.hstack([rand_cxwy, rand_whs])
tlbr = Boxes(cxywh, 'cxywh').to_tlbr().data
tlbr = tlbr * scale
if as_integer:
tlbr = tlbr.astype(np.int)
if tensor:
if as_integer:
tlbr = torch.LongTensor(tlbr)
else:
tlbr = torch.FloatTensor(tlbr)
boxes = Boxes(tlbr, format='tlbr').toformat(format, copy=False)
return boxes
def __init__(self, rng=None):
self.rng = util.ensure_rng(rng)
