def find_best_width_coarse2fine_linesearch(self,
ld_val,
w_lb,
w_ub,
n_w,
eps=1e-1):
w_best_prev = T(0.0).to(self.device)
w_best = T(np.inf).to(self.device)
while (w_best - w_best_prev).abs() > eps:
w_rng = tc.linspace(w_lb, w_ub, n_w + 1)
error_best = T(np.inf).to(self.device)
for i, w in enumerate(w_rng):
self.set_width_max(w)
error = self.compute_error(ld_val)
if error < error_best:
error_best_prev = error_best
error_best = error
w_best_prev = w_best
w_best = w
w_lb = w_rng[i - 1] if i > 0 else w_lb
w_ub = w_rng[i + 1] if i < len(w_rng) - 1 else w_ub
print(
"[search width_max] "
"w = %.4f, w_lb = %.4f, w_ub = %.4f, best_w = %.4f, error = %.4f"
% (w, w_rng[0], w_rng[-1], w_best, error_best))
return w_best
def detransform(transformed_tensor, device='cpu'):
# This method doesn't modify input data
# Slower than in-place normalization of torchvision.transforms.Normalize
mean_tensor = T(constants.DATA_MEAN).reshape(3, 1, 1).to(device)
std_tensor = T(constants.DATA_STD).reshape((3, 1, 1)).to(device)
detransformed_tensor = transformed_tensor.mul(std_tensor).add(mean_tensor)
return to_numpy_image(detransformed_tensor)
def __init__(
self,
n_dft=512,
n_hop=None,
power_spectrogram=2.0,
return_decibel_spectrogram=False,
):
super().__init__()
if n_hop is None:
n_hop = n_dft // 2
self.n_dft = n_dft
self.n_hop = n_hop
self.power_spectrogram = float(power_spectrogram)
self.return_decibel_spectrogram = return_decibel_spectrogram
dft_real_kernels, dft_imag_kernels = self.get_stft_kernels(self.n_dft)
self.register_buffer(
"dft_real_kernels",
T(dft_real_kernels, requires_grad=False,
dtype=torch.float32).squeeze(1).swapaxes(0, 2),
)
self.register_buffer(
"dft_imag_kernels",
T(dft_imag_kernels, requires_grad=False,
dtype=torch.float32).squeeze(1).swapaxes(0, 2),
)
def __init__(self, mdl, eps=0.0, delta=0.0, n=0):
super().__init__()
self.mdl = mdl
self.T = nn.Parameter(T(0.0))
self.eps = nn.Parameter(T(eps), requires_grad=False)
self.delta = nn.Parameter(T(delta), requires_grad=False)
self.n = nn.Parameter(T(n), requires_grad=False)
def three_conv(dx, dy, dz, dt, fac=1):
#Factor for adding that single minus on the dt conv
conv = torch.nn.Conv3d(1, 4, 2)
conv.weight = torch.nn.Parameter(
T(np.concatenate([dx, dy, dz, fac * dt], axis=0)))
conv.bias = torch.nn.Parameter(T(np.array([0, 0, 0, 0])))
return conv
def create_hiddens(self, bsz=1):
# Uses Xavier init here.
hiddens = []
for l in self.layers:
std = math.sqrt(2.0 / (l.input_size + l.hidden_size))
hiddens.append([V(T(1, bsz, l.hidden_size).normal_(0, std)),
V(T(1, bsz, l.hidden_size).normal_(0, std))])
return hiddens
def __init__(self, model, action_size=1, init_value=0.0, *args, **kwargs):
super(DiagonalGaussianPolicy, self).__init__(model, *args, **kwargs)
self.init_value = init_value
self.logstd = th.zeros((1, action_size)) + self.init_value
self.logstd = P(self.logstd)
self.halflog2pie = V(T([2 * pi * exp(1)])) * 0.5
self.halflog2pi = V(T([2.0 * pi])) * 0.5
self.pi = V(T([pi]))
def pad_targets(self, targets, lengths):
max_length = lengths[0]
padded = []
for profile, seq_len in zip(targets, lengths):
padded.append(T(torch.nn.functional.pad(
T(profile), (0, max_length-seq_len), value=1)))
return padded
def __init__(self, model_F, eps, delta, n, load_root=None):
super().__init__()
self.model_F = model_F
self.T = nn.Parameter(T(0.0))
self.eps = nn.Parameter(T(eps), requires_grad=False)
self.delta = nn.Parameter(T(delta), requires_grad=False)
self.n = nn.Parameter(T(n), requires_grad=False)
assert (load_root is None)
def test_box_hw_to_corners(self):
box_hw = T([[1., 2., 0.5, 0.7],
[3.5, 4., 1.5, 2.]])
corners = losses.box_hw_to_corners(box_hw)
expected_corners = T([[0.75, 1.65, 1.25, 2.35],
[2.75, 3., 4.25, 5.]])
error = float(((expected_corners - corners) * (expected_corners - corners)).sum())
self.assertEqual(error, 0)
def __init__(self, input_size, learnable=True, epsilon=1e-6):
super(LayerNorm, self).__init__()
self.input_size = input_size
self.learnable = learnable
self.alpha = T(1, input_size).fill_(0)
self.beta = T(1, input_size).fill_(0)
self.epsilon = epsilon
self.alpha = nn.Parameter(self.alpha)
self.beta = nn.Parameter(self.beta)
self.init_weights()
def __init__(self, input_size, learnable=True, epsilon=1e-5):
super(BaLayerNorm, self).__init__()
self.input_size = input_size
self.learnable = learnable
self.epsilon = epsilon
self.alpha = T(1, input_size).fill_(0)
self.beta = T(1, input_size).fill_(0)
# Wrap as parameters if necessary
if learnable:
W = P
else:
W = V
self.alpha = W(self.alpha)
self.beta = W(self.beta)
def test_ssd_loss(self):
anchors = losses.create_anchors(grid_sizes=[(7, 7), (4, 4), (2, 2), (1, 1)], zoom_levels=[1], aspect_ratios=[1])
self.assertEqual(anchors.size(), (70, 4))
loss = losses.SSDLoss(anchors, constants.TRANSFORMED_IMAGE_SIZE, num_classes=10)
num_labels = 10
k = 1
batch_size = 4
num_channels = 3
image_size = (224, 224)
base_model = resnet34(pretrained=True)
head = SSDHead(k, num_labels, -3.)
ssd = SSDModel(base_model, head)
input = torch.zeros((batch_size, num_channels, image_size[0], image_size[1]), dtype=torch.float32)
out = ssd(input)
self.assertEqual(out[0].size(), (4, 70, 4))
self.assertEqual(out[1].size(), (4, 70, 11))
target = [(T([[0, 1, 2, 3], [4, 5, 6, 7]], dtype=torch.float32), T([1, 2], dtype=torch.long)),
(T([[0, 1, 2, 3], [4, 5, 6, 7]], dtype=torch.float32), T([1, 2], dtype=torch.long)),
(T([[0, 1, 2, 3], [4, 5, 6, 7]], dtype=torch.float32), T([1, 2], dtype=torch.long)),
(T([[0, 1, 2, 3], [4, 5, 6, 7]], dtype=torch.float32), T([1, 2], dtype=torch.long))]
l = loss.loss(out, target)
# Sanity check: nothing fails, returns dict of expected structure
self.assertEqual(len(l), 3)
self.assertTrue('classification' in l)
self.assertTrue('localization' in l)
self.assertTrue('total' in l)
def __init__(self):
self.starting_street = 1
K = Kuhn()
self.rule_params = K.rule_params
self.state_params = K.state_params
self.rule_params['mask_dict'] = ACTION_MASKS[5]
self.rule_params['action_dict'] = ACTION_ORDER
self.rule_params['bets_per_street'] = 2
self.rule_params['betsize_dict'] = {
0: T([0]),
1: T([0]),
2: T([1]),
3: T([1]),
4: T([2])
}
def __init__(
self,
sr,
n_dft=512,
n_hop=None,
n_mels=128,
htk=True,
power_melgram=1.0,
return_decibel_melgram=False,
padding="same",
):
super().__init__(
n_dft=n_dft,
n_hop=n_hop,
power_spectrogram=2.0,
return_decibel_spectrogram=False,
)
self.padding = padding
self.sr = sr
self.power_melgram = power_melgram
self.return_decibel_melgram = return_decibel_melgram
mel_basis = librosa.filters.mel(
sr=sr,
n_fft=n_dft,
n_mels=n_mels,
fmin=0,
fmax=sr // 2,
htk=htk,
norm=1,
)
self.register_buffer("mel_basis", T(mel_basis, requires_grad=False))
def __init__(self):
self.starting_street = 1
K = Kuhn()
self.rule_params = K.rule_params
self.state_params = K.state_params
self.state_params['stacksize'] = 3
self.rule_params['betsize'] = True
self.rule_params['state_index'] = 0
self.rule_params['mapping'] = {
'state': {
'previous_betsize': 2,
'previous_action': 1,
'rank': 0,
'hand': 0
},
'observation': {
'previous_betsize': 3,
'previous_action': 2,
'vil_rank': 1,
'vil_hand': 1,
'rank': 0,
'hand': 0
},
}
self.rule_params['mask_dict'] = ACTION_MASKS[5]
self.rule_params['action_dict'] = ACTION_ORDER
self.rule_params['bets_per_street'] = 2
self.rule_params['betsizes'] = T([0.5, 1.])
self.rule_params['bettype'] = LimitTypes.NO_LIMIT
def resize_boxes(boxes, original_size, new_size):
# Size is (height, width)
# Boxes are of shape (N, 4). Coordinates: (top, left, bottom, right)
m = (new_size[0] / original_size[0], new_size[1] / original_size[1])
boxes = boxes * T(np.asarray([m[0], m[1], m[0], m[1]]),
dtype=torch.float32)
return boxes
def test_argva():
model = ARGVA(encoder=lambda x: (x, x), discriminator=lambda x: T([0.5]))
x = torch.Tensor([[1, -1], [1, 2], [2, 1]])
model.encode(x)
model.reparametrize(model.mu, model.logvar)
assert model.kl_loss().item() > 0
def find_maximum_train_error_allow(self, eps, delta, n):
k_min = 0
k_max = n
bnd_min = half_line_bound_upto_k(n, k_min, eps)
if bnd_min > delta:
return None
assert (bnd_min <= delta)
k = n
while True:
# choose new k
k_prev = k
k = (T(k_min + k_max).float() / 2.0).round().long().item()
# terinate condition
if k == k_prev:
break
# check whether the current k satisfies the condition
bnd = half_line_bound_upto_k(n, k, eps)
if bnd <= delta:
k_min = k
else:
k_max = k
# confirm that the solution satisfies the condition
k_best = k_min
assert (half_line_bound_upto_k(n, k_best, eps) <= delta)
error_allow = float(k_best) / float(n)
return error_allow
def __init__(self,
root,
load_type,
frame_wh=(320, 240),
img_type="float",
bb_format="xywh"):
self.load_type = load_type
self.frame_wh = frame_wh
self.img_type = img_type
self.bb_format = bb_format
# load seq ids
self.seq_ids = os.listdir(root)
# load images
self.frames = sorted(glob.glob(os.path.join(root, "**/img/*.jpg")))
# keep start frame_id
self.start_frame_id = {}
for seq_id in self.seq_ids:
for f in self.frames:
if seq_id == f.split("/")[-3]:
self.start_frame_id[seq_id] = int(
f.split("/")[-1].split(".")[0])
break
# keep a pair of two adjacent frames
self.frames_pair = []
for fn_prev, fn_curr in zip(self.frames[:-1], self.frames[1:]):
seq_id_prev = fn_prev.split("/")[-3]
seq_id_curr = fn_curr.split("/")[-3]
if seq_id_prev != seq_id_curr:
continue
self.frames_pair.append([fn_prev, fn_curr])
# load bounding boxes: assume single-object tracking
self.bbox = {}
for seq_id in self.seq_ids:
root_seq = os.path.join(root, seq_id)
bb_fns = glob.glob(os.path.join(root_seq, "*.txt"))
try:
self.bbox[seq_id] = T(np.loadtxt(bb_fns[-1], delimiter=","))
except ValueError:
self.bbox[seq_id] = T(np.loadtxt(bb_fns[-1], delimiter="\t"))
# tform
self.tform_img = transforms.Compose([transforms.ToTensor()])
def __init__(self):
H = BaseHoldem()
self.rule_params = H.rule_params
self.state_params = H.state_params
self.state_params['stacksize'] = 2.
self.state_params['pot']= 2.
self.rule_params['betsizes'] = T([0.5,1.])
self.starting_street = Street.RIVER
def create_anchors(grid_sizes: List[Tuple[int, int]], zoom_levels,
aspect_ratios):
all_level_anchors = []
for grid_size in grid_sizes:
level_anchors = create_anchors_for_one_level(grid_size, zoom_levels,
aspect_ratios)
all_level_anchors.append(level_anchors)
return T(np.vstack(all_level_anchors)).float()
def __init__(self):
self.starting_street = 1
K = BetsizeKuhn()
self.rule_params = K.rule_params
self.rule_params['betsizes'] = T([0.5, 1.])
self.state_params = K.state_params
self.state_params['stacksize'] = 5
self.rule_params['bets_per_street'] = 2
def test_arga():
model = ARGA(encoder=lambda x: x, discriminator=lambda x: T([0.5]))
model.reset_parameters()
x = torch.Tensor([[1, -1], [1, 2], [2, 1]])
z = model.encode(x)
assert model.reg_loss(z).item() > 0
assert model.discriminator_loss(z).item() > 0
def __init__(self,
dim_in: int,
dropout: float,
score_type: str = 'dot') -> None:
super(Score_Net, self).__init__()
self.dim_in = dim_in
self.dropout = dropout
self.score_type = score_type
self.Dropout = nn.Dropout(dropout)
self.head = nn.Parameter(T(1, dim_in))
self.tail = nn.Parameter(T(1, dim_in))
self.layernorm = nn.LayerNorm(dim_in)
if score_type == 'bilinear':
self.func: Callable[[T, T], T] = nn.Bilinear(dim_in, dim_in, 1)
else:
self.func: Callable[[T, T], T] = torch.bmm
self.init_para()
def test_activation_reg(self):
# make deterministe
th.manual_seed(0)
# some dummy params
emb_size = 3
alpha = 1
model = net.AWD_LSTM(10, emb_size, 2)
# manually set the output to some random values
# in practice this is done automatically on each forward pass
# expects model output of shape (timesteps, batch_size, embedding_size)
# batch_size = 2
# timesteps = 3
model.output = T([[[3, 4, 5], [3, 4, 5]], [[3, 4, 5], [3, 4, 5]],
[[3, 4, 5], [3, 4, 5]]])
expect = (T([[3, 4, 5]]) @ T([[3, 4, 5]]).t()).pow(0.5)
# equivalently
# expect = th.sum(T([3, 4, 5]).pow(2)).pow(0.5)
ar = model.activation_reg(alpha)
self.assertEqual(ar, expect)
def test_temporal_activation_reg(self):
# make deterministe
th.manual_seed(0)
# some dummy params
emb_size = 3
beta = 1
model = net.AWD_LSTM(10, emb_size, 2)
# manually set the output to some random values
# in practice this is done automatically on each forward pass
# expects model output of shape (timesteps, batch_size, embedding_size)
# batch_size = 2
# timesteps = 2
model.output_nodrop = T([[[3, 4, 5], [3, 4, 5]], [[1, 1, 1], [1, 1,
1]]])
# We expect the L2 norm of the difference between the two timesteps
# L2(ht - ht+1)
expect = (T([[2, 3, 4]]) @ T([[2, 3, 4]]).t()).pow(0.5)
tar = model.temporal_activation_reg(beta)
self.assertEqual(tar, expect)
def neg_log_prob(self, yhs, yhs_var, ys):
N = yhs.size(1)
S = yhs.size(2)
loss_mah = 0.5 * dist_mah(ys, yhs, 1 / yhs_var, sqrt=False)
assert (all(loss_mah >= 0))
loss_const = 0.5 * T(2.0 * np.pi).log() * N * S
loss_logdet = 0.5 * yhs_var.log().sum(1).sum(1)
loss = loss_mah + loss_logdet + loss_const
return loss
def opt_flow(dimg, r=2):
d = dimg.shape[-1]
x = np.ones((1, 1, 2, 2, 2))
calc = (dimg[None, 0:3, ...] * dimg[:, None, ...])
conv_next = torch.nn.Conv3d(3, 3, 2)
conv_next.weight = torch.nn.Parameter(T(x))
conv_next.bias = torch.nn.Parameter(T(np.array([0])))
sum_conv = torch.cat(
[conv_next(i[:, None, ...]) for i in torch.unbind(calc, 1)], 1)
dim = sum_conv.shape[-1]
a = sum_conv
b = a.permute(2, 3, 4, 0, 1)
c = b[..., :-1, :].contiguous().view(-1, 3, 3)
d = b[..., -1, :].contiguous().view(-1, 3, 1)
inv = torch.stack([mat.inverse() for mat in torch.unbind(c, 0)])
out = torch.bmm(inv, d)
out = out.transpose(0, 1).contiguous().view(3, dim, dim, dim)
return out
def rotate_images(xs, deg, delta=1.0):
xs_rot_all = []
for d in np.arange(-deg, deg+delta, delta):
d_rad = d / 360.0 * 2 * np.pi
theta = T([[np.cos(d_rad), -np.sin(d_rad), 0.0], [np.sin(d_rad), np.cos(d_rad), 0.0]],
device=xs.device).repeat(xs.size(0), 1, 1)
grid = F.affine_grid(theta, xs.size())
xs_rot = F.grid_sample(xs, grid)
xs_rot_all.append(xs_rot.unsqueeze(1))
xs_rot_all = tc.cat(xs_rot_all, 1)
return xs_rot_all
