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