我们从Python开源项目中，提取了以下23个代码示例，用于说明如何使用torch.ger()。
def backward(self, grad_output): matrix, vector = self.saved_tensors grad_add_vector = grad_matrix = grad_vector = None if self.needs_input_grad[0]: grad_add_vector = grad_output if self.alpha != 1: grad_add_vector = grad_add_vector.mul(self.alpha) if self.needs_input_grad[1]: grad_matrix = torch.ger(grad_output, vector) if self.beta != 1: grad_matrix *= self.beta if self.needs_input_grad[2]: grad_vector = torch.mv(matrix.t(), grad_output) if self.beta != 1: grad_vector *= self.beta return grad_add_vector, grad_matrix, grad_vector
def _kernel_matching(q1_x, q1_mu, xt_x, xt_mu, radius) : """ Given two measures q1 and xt represented by locations/weights arrays, outputs a kernel-fidelity term and an empty 'info' array. """ K_qq, K_qx, K_xx = _cross_kernels(q1_x, xt_x, radius) cost = .5 * ( torch.sum(K_qq * torch.ger(q1_mu,q1_mu)) \ + torch.sum(K_xx * torch.ger(xt_mu,xt_mu)) \ -2*torch.sum(K_qx * torch.ger(q1_mu,xt_mu)) ) # Info = the 2D graph of the blurred distance function # Increase res if you want to get nice smooth pictures... res = 10 ; ticks = np.linspace( 0, 1, res + 1)[:-1] + 1/(2*res) X,Y = np.meshgrid( ticks, ticks ) points = Variable(torch.from_numpy(np.vstack( (X.ravel(), Y.ravel()) ).T).type(dtype), requires_grad=False) info = _k( points, q1_x , radius ) @ q1_mu \ - _k( points, xt_x , radius ) @ xt_mu return [cost , info.view( (res,res) ) ]
def backward(ctx, grad_output): matrix, vector = ctx.saved_variables grad_add_vector = grad_matrix = grad_vector = None if ctx.needs_input_grad[0]: grad_add_vector = grad_output if ctx.alpha != 1: grad_add_vector = grad_add_vector.mul(ctx.alpha) if ctx.needs_input_grad[1]: grad_matrix = torch.ger(grad_output, vector) if ctx.beta != 1: grad_matrix *= ctx.beta if ctx.needs_input_grad[2]: grad_vector = torch.mv(matrix.t(), grad_output) if ctx.beta != 1: grad_vector *= ctx.beta return grad_add_vector, grad_matrix, grad_vector, None, None, None
def forward(ctx, theta, size): assert type(size) == torch.Size N, C, H, W = size ctx.size = size if theta.is_cuda: ctx.is_cuda = True AffineGridGenerator._enforce_cudnn(theta) grid = theta.new(N, H, W, 2) theta = theta.contiguous() torch._C._cudnn_affine_grid_generator_forward(theta, grid, N, C, H, W) else: ctx.is_cuda = False base_grid = theta.new(N, H, W, 3) linear_points = torch.linspace(-1, 1, W) if W > 1 else torch.Tensor([-1]) base_grid[:, :, :, 0] = torch.ger(torch.ones(H), linear_points).expand_as(base_grid[:, :, :, 0]) linear_points = torch.linspace(-1, 1, H) if H > 1 else torch.Tensor([-1]) base_grid[:, :, :, 1] = torch.ger(linear_points, torch.ones(W)).expand_as(base_grid[:, :, :, 1]) base_grid[:, :, :, 2] = 1 ctx.base_grid = base_grid grid = torch.bmm(base_grid.view(N, H * W, 3), theta.transpose(1, 2)) grid = grid.view(N, H, W, 2) return grid
def backward(ctx, grad_output): matrix, vector = ctx.saved_variables grad_add_vector = grad_matrix = grad_vector = None if ctx.needs_input_grad[0]: grad_add_vector = maybe_unexpand(grad_output, ctx.add_vector_size) if ctx.alpha != 1: grad_add_vector = grad_add_vector.mul(ctx.alpha) if ctx.needs_input_grad[1]: grad_matrix = torch.ger(grad_output, vector) if ctx.beta != 1: grad_matrix *= ctx.beta if ctx.needs_input_grad[2]: grad_vector = torch.mv(matrix.t(), grad_output) if ctx.beta != 1: grad_vector *= ctx.beta return grad_add_vector, grad_matrix, grad_vector, None, None, None
def test_backward_inv_mv(): a = torch.Tensor([ [5, -3, 0], [-3, 5, 0], [0, 0, 2], ]) b = torch.ones(3, 3).fill_(2) c = torch.randn(3) actual_a_grad = -torch.ger(a.inverse().mul_(0.5).mv(torch.ones(3)), a.inverse().mul_(0.5).mv(c)) * 2 * 2 actual_c_grad = (a.inverse() / 2).t().mv(torch.ones(3)) * 2 a_var = Variable(a, requires_grad=True) c_var = Variable(c, requires_grad=True) out_var = a_var.mul(Variable(b)) out_var = gpytorch.inv_matmul(out_var, c_var) out_var = out_var.sum() * 2 out_var.backward() a_res = a_var.grad.data c_res = c_var.grad.data assert(torch.norm(actual_a_grad - a_res) < 1e-4) assert(torch.norm(actual_c_grad - c_res) < 1e-4)
def forward(ctx, theta, size): assert type(size) == torch.Size N, C, H, W = size ctx.size = size if theta.is_cuda: AffineGridGenerator._enforce_cudnn(theta) assert False ctx.is_cuda = False base_grid = theta.new(N, H, W, 3) linear_points = torch.linspace(-1, 1, W) if W > 1 else torch.Tensor([-1]) base_grid[:, :, :, 0] = torch.ger(torch.ones(H), linear_points).expand_as(base_grid[:, :, :, 0]) linear_points = torch.linspace(-1, 1, H) if H > 1 else torch.Tensor([-1]) base_grid[:, :, :, 1] = torch.ger(linear_points, torch.ones(W)).expand_as(base_grid[:, :, :, 1]) base_grid[:, :, :, 2] = 1 ctx.base_grid = base_grid grid = torch.bmm(base_grid.view(N, H * W, 3), theta.transpose(1, 2)) grid = grid.view(N, H, W, 2) return grid
def test_ger(self): types = { 'torch.DoubleTensor': 1e-8, 'torch.FloatTensor': 1e-4, } for tname, _prec in types.items(): v1 = torch.randn(100).type(tname) v2 = torch.randn(100).type(tname) res1 = torch.ger(v1, v2) res2 = torch.zeros(100, 100).type(tname) for i in range(100): for j in range(100): res2[i, j] = v1[i] * v2[j] self.assertEqual(res1, res2) # Test 0-strided for tname, _prec in types.items(): v1 = torch.randn(1).type(tname).expand(100) v2 = torch.randn(100).type(tname) res1 = torch.ger(v1, v2) res2 = torch.zeros(100, 100).type(tname) for i in range(100): for j in range(100): res2[i, j] = v1[i] * v2[j] self.assertEqual(res1, res2)
def updateGradInput(self, input, gradOutput): M, v = input self.gradInput[0].resize_as_(M) self.gradInput[1].resize_as_(v) assert gradOutput.ndimension() == 1 or gradOutput.ndimension() == 2 if gradOutput.ndimension() == 2: assert M.ndimension() == 3 assert v.ndimension() == 2 bdim = M.size(0) odim = M.size(1) idim = M.size(2) if self.trans: torch.bmm(self.gradInput[0], v.view(bdim, odim, 1), gradOutput.view(bdim, 1, idim)) torch.bmm(self.gradInput[1].view(bdim, odim, 1), M, gradOutput.view(bdim, idim, 1)) else: torch.bmm(self.gradInput[0], gradOutput.view(bdim, odim, 1), v.view(bdim, 1, idim)) torch.bmm(self.gradInput[1].view(bdim, idim, 1), M.transpose(1, 2), gradOutput.view(bdim, odim, 1)) else: assert M.ndimension() == 2 assert v.ndimension() == 1 if self.trans: torch.ger(self.gradInput[0], v, gradOutput) self.gradInput[1] = M * gradOutput else: torch.ger(self.gradInput[0], gradOutput, v) self.gradInput[1] = M.t() * gradOutput return self.gradInput
def _hess_j(C_j, I_j, b_j, b_j_norm, a_1_j, a_2_j): """Compute the Hessian with respect to one of the coefficients.""" D_j = torch.ger(b_j, b_j) return C_j + (a_1_j/b_j_norm)*(I_j - D_j/(b_j_norm**2)) + a_2_j*I_j
def updateGradInput(self, input, gradOutput): M, v = input self.gradInput[0].resize_as_(M) self.gradInput[1].resize_as_(v) gradOutput = gradOutput.contiguous() assert gradOutput.ndimension() == 1 or gradOutput.ndimension() == 2 if gradOutput.ndimension() == 2: assert M.ndimension() == 3 assert v.ndimension() == 2 bdim = M.size(0) odim = M.size(1) idim = M.size(2) if self.trans: torch.bmm(v.view(bdim, odim, 1), gradOutput.view(bdim, 1, idim), out=self.gradInput[0]) torch.bmm(M, gradOutput.view(bdim, idim, 1), out=self.gradInput[1].view(bdim, odim, 1)) else: torch.bmm(gradOutput.view(bdim, odim, 1), v.view(bdim, 1, idim), out=self.gradInput[0]) torch.bmm(M.transpose(1, 2), gradOutput.view(bdim, odim, 1), out=self.gradInput[1].view(bdim, idim, 1)) else: assert M.ndimension() == 2 assert v.ndimension() == 1 if self.trans: torch.ger(v, gradOutput, out=self.gradInput[0]) self.gradInput[1] = M * gradOutput else: torch.ger(gradOutput, v, out=self.gradInput[0]) self.gradInput[1] = M.t() * gradOutput return self.gradInput
def test_functional_blas(self): def compare(fn, *args): unpacked_args = tuple(arg.data if isinstance(arg, Variable) else arg for arg in args) self.assertEqual(fn(*args).data, fn(*unpacked_args)) def test_blas_add(fn, x, y, z): # Checks all signatures compare(fn, x, y, z) compare(fn, 0.5, x, y, z) compare(fn, 0.5, x, 0.25, y, z) def test_blas(fn, x, y): compare(fn, x, y) test_blas(torch.mm, Variable(torch.randn(2, 10)), Variable(torch.randn(10, 4))) test_blas_add(torch.addmm, Variable(torch.randn(2, 4)), Variable(torch.randn(2, 10)), Variable(torch.randn(10, 4))) test_blas(torch.bmm, Variable(torch.randn(4, 2, 10)), Variable(torch.randn(4, 10, 4))) test_blas_add(torch.addbmm, Variable(torch.randn(2, 4)), Variable(torch.randn(4, 2, 10)), Variable(torch.randn(4, 10, 4))) test_blas_add(torch.baddbmm, Variable(torch.randn(4, 2, 4)), Variable(torch.randn(4, 2, 10)), Variable(torch.randn(4, 10, 4))) test_blas(torch.mv, Variable(torch.randn(2, 10)), Variable(torch.randn(10))) test_blas_add(torch.addmv, Variable(torch.randn(2)), Variable(torch.randn(2, 10)), Variable(torch.randn(10))) test_blas(torch.ger, Variable(torch.randn(5)), Variable(torch.randn(6))) test_blas_add(torch.addr, Variable(torch.randn(5, 6)), Variable(torch.randn(5)), Variable(torch.randn(6)))
def test_normal_gp_mll_backward(): covar = torch.Tensor([ [5, -3, 0], [-3, 5, 0], [0, 0, 2], ]) y = torch.randn(3) covarvar = Variable(covar, requires_grad=True) yvar = Variable(y, requires_grad=True) actual_mat_grad = torch.ger(covar.inverse().mv(y), covar.inverse().mv(y)) actual_mat_grad -= covar.inverse() actual_mat_grad *= 0.5 actual_mat_grad *= 3 # For grad output actual_y_grad = -covar.inverse().mv(y) actual_y_grad *= 3 # For grad output covarvar = Variable(covar, requires_grad=True) yvar = Variable(y, requires_grad=True) gpytorch.functions.num_trace_samples = 1000 output = gpytorch.exact_gp_marginal_log_likelihood(covarvar, yvar) * 3 output.backward() assert(torch.norm(actual_mat_grad - covarvar.grad.data) < 1e-1) assert(torch.norm(actual_y_grad - yvar.grad.data) < 1e-4) gpytorch.functions.fastest = False covarvar = Variable(covar, requires_grad=True) yvar = Variable(y, requires_grad=True) output = gpytorch.exact_gp_marginal_log_likelihood(covarvar, yvar) * 3 output.backward() assert(torch.norm(actual_mat_grad - covarvar.grad.data) < 1e-1) assert(torch.norm(actual_y_grad - yvar.grad.data) < 1e-4)
def outer(x: T.FloatTensor, y: T.FloatTensor) -> T.FloatTensor: """ Compute the outer product of vectors x and y. mat_{ij} = x_i * y_j Args: x: A vector (i.e., a 1D tensor). y: A vector (i.e., a 1D tensor). Returns: tensor: Outer product of vectors x and y. """ return torch.ger(x, y)
def test_functional_blas(self): def compare(fn, *args): unpacked_args = tuple(arg.data if isinstance(arg, Variable) else arg for arg in args) unpacked_result = fn(*unpacked_args) packed_result = fn(*args).data # if non-Variable torch function returns a scalar, compare to scalar if not torch.is_tensor(unpacked_result): assert packed_result.dim() == 1 assert packed_result.nelement() == 1 packed_result = packed_result[0] self.assertEqual(packed_result, unpacked_result) def test_blas_add(fn, x, y, z): # Checks all signatures compare(fn, x, y, z) compare(fn, 0.5, x, y, z) compare(fn, 0.5, x, 0.25, y, z) def test_blas(fn, x, y): compare(fn, x, y) test_blas(torch.mm, Variable(torch.randn(2, 10)), Variable(torch.randn(10, 4))) test_blas_add(torch.addmm, Variable(torch.randn(2, 4)), Variable(torch.randn(2, 10)), Variable(torch.randn(10, 4))) test_blas(torch.bmm, Variable(torch.randn(4, 2, 10)), Variable(torch.randn(4, 10, 4))) test_blas_add(torch.addbmm, Variable(torch.randn(2, 4)), Variable(torch.randn(4, 2, 10)), Variable(torch.randn(4, 10, 4))) test_blas_add(torch.baddbmm, Variable(torch.randn(4, 2, 4)), Variable(torch.randn(4, 2, 10)), Variable(torch.randn(4, 10, 4))) test_blas(torch.mv, Variable(torch.randn(2, 10)), Variable(torch.randn(10))) test_blas_add(torch.addmv, Variable(torch.randn(2)), Variable(torch.randn(2, 10)), Variable(torch.randn(10))) test_blas(torch.ger, Variable(torch.randn(5)), Variable(torch.randn(6))) test_blas_add(torch.addr, Variable(torch.randn(5, 6)), Variable(torch.randn(5)), Variable(torch.randn(6))) test_blas(torch.matmul, Variable(torch.randn(6)), Variable(torch.randn(6))) test_blas(torch.matmul, Variable(torch.randn(10, 4)), Variable(torch.randn(4))) test_blas(torch.matmul, Variable(torch.randn(5)), Variable(torch.randn(5, 6))) test_blas(torch.matmul, Variable(torch.randn(2, 10)), Variable(torch.randn(10, 4))) test_blas(torch.matmul, Variable(torch.randn(5, 2, 10)), Variable(torch.randn(5, 10, 4))) test_blas(torch.matmul, Variable(torch.randn(3, 5, 2, 10)), Variable(torch.randn(3, 5, 10, 4))) test_blas(torch.matmul, Variable(torch.randn(3, 5, 2, 10)), Variable(torch.randn(10))) test_blas(torch.matmul, Variable(torch.randn(10)), Variable(torch.randn(3, 5, 10, 4)))
def dap_deploy(m, x, labels, data, att_crit=None): """ Deploy DAP :param m: :param x: :param labels: :param data: :param att_crit: :return: Pandas series """ res = m(x) if res.embed_pred is not None: embed_logits = res.embed_pred @ data.attributes.embeds.t() att_probs = [torch.sigmoid(embed_logits)] else: att_probs = [] # Start off with the embedding probabilities if res.att_pred is None: domains = [] else: domains = att_crit.domains_per_att start_col = 0 for gt_col, d_size in enumerate(domains): # Get the attributes per verb atts_by_verb = data.attributes.atts_matrix[:, gt_col] if d_size == 1: # Get the right indexing by taking the outer product between the # [batch_size] attributes \in {+1, -1} and the logits # This gives us a [batch_size x num_labels] matrix. raw_ap = torch.ger( res.att_pred[:, start_col], 2*(atts_by_verb.float() - 0.5), ) att_probs.append(torch.sigmoid(raw_ap)) else: # [batch_size x attribute domain_size] matrix ap = F.softmax(res.att_pred[:, start_col:(start_col+d_size)]) #[batch_size x num_labels] prob_contrib_by_label = torch.index_select(ap, 1, atts_by_verb) att_probs.append(prob_contrib_by_label) start_col += d_size #[batch_size x num labels x num attributes] probs_by_att = torch.stack(att_probs, 2) # [batch_size, range size] probs_prod = torch.prod(probs_by_att + 1e-12, 2).squeeze(2) denom = probs_prod.sum(1) # [batch_size, 1] probs = probs_prod / denom.expand_as(probs_prod) return probs ###
