我们从Python开源项目中，提取了以下21个代码示例，用于说明如何使用torch.type()。
def __tostring__(self): tab = ' ' line = '\n' next = ' |`-> ' ext = ' | ' extlast = ' ' last = ' +. -> ' res = torch.type(self) res += ' {' + line + tab + 'input' for i in range(len(self.modules)): if i == len(self.modules)-1: res += line + tab + next + '(' + i + '): ' + str(self.modules[i]).replace(line, line + tab + extlast) else: res += line + tab + next + '(' + i + '): ' + str(self.modules[i]).replace(line, line + tab + ext) res += line + tab + last + 'output' res += line + '}' return res
def type(self, type=None, tensorCache=None): if type: # prevent premature memory allocations self._input = None self._output = None self._gradOutput = None self._weight = None self._div = None self._sum = None self._expand = None self._expand2 = None self._expand3 = None self._expand4 = None self._repeat = None self._repeat2 = None self._repeat3 = None return super(WeightedEuclidean, self).type(type, tensorCache)
def __tostring__(self): tab = ' ' line = '\n' next = ' |`-> ' ext = ' | ' extlast = ' ' last = ' +. -> ' res = torch.type(self) res += ' {' + line + tab + 'input' for i in range(len(self.modules)): if i == len(self.modules) - 1: res += line + tab + next + '(' + i + '): ' + str(self.modules[i]).replace(line, line + tab + extlast) else: res += line + tab + next + '(' + i + '): ' + str(self.modules[i]).replace(line, line + tab + ext) res += line + tab + last + 'output' res += line + '}' return res
def updateOutput(self, input): # lazy-initialize self._diagCov = self._diagCov or self.output.new() self._input = self._input or input.new() self._weight = self._weight or self.weight.new() self._expand = self._expand or self.output.new() self._expand2 = self._expand or self.output.new() self._expand3 = self._expand3 or self.output.new() self._repeat = self._repeat or self.output.new() self._repeat2 = self._repeat2 or self.output.new() self._repeat3 = self._repeat3 or self.output.new() inputSize, outputSize = self.weight.size(0), self.weight.size(1) # y_j = || c_j * (w_j - x) || if input.dim() == 1: self._view(self._input, input, inputSize, 1) self._expand.expand_as(self._input, self.weight) self._repeat.resize_as_(self._expand).copy_(self._expand) self._repeat.add_(-1, self.weight) self._repeat.mul_(self.diagCov) torch.norm(self.output, self._repeat, 2, 0) self.output.resize_(outputSize) elif input.dim() == 2: batchSize = input.size(0) self._view(self._input, input, batchSize, inputSize, 1) self._expand = self._input.expand(batchSize, inputSize, outputSize) # make the expanded tensor contiguous (requires lots of memory) self._repeat.resize_as_(self._expand).copy_(self._expand) self._weight = self.weight.view(1, inputSize, outputSize) self._expand2 = self._weight.expand_as(self._repeat) self._diagCov = self.diagCov.view(1, inputSize, outputSize) self._expand3 = self._diagCov.expand_as(self._repeat) if input.type() == 'torch.cuda.FloatTensor': # TODO: this can be fixed with a custom allocator # requires lots of memory, but minimizes cudaMallocs and loops self._repeat2.resize_as_(self._expand2).copy_(self._expand2) self._repeat.add_(-1, self._repeat2) self._repeat3.resize_as_(self._expand3).copy_(self._expand3) self._repeat.mul_(self._repeat3) else: self._repeat.add_(-1, self._expand2) self._repeat.mul_(self._expand3) torch.norm(self.output, self._repeat, 2, 1) self.output.resize_(batchSize, outputSize) else: raise RuntimeError("1D or 2D input expected") return self.output
def updateGradInput(self, input, gradOutput): if not self.gradInput: return self._div = self._div or input.new() self._output = self._output or self.output.new() self._expand4 = self._expand4 or input.new() self._gradOutput = self._gradOutput or input.new() if not self.fastBackward: self.updateOutput(input) inputSize, outputSize = self.weight.size(0), self.weight.size(1) """ dy_j -2 * c_j * c_j * (w_j - x) c_j * c_j * (x - w_j) ---- = -------------------------- = --------------------- dx 2 || c_j * (w_j - x) || y_j """ # to prevent div by zero (NaN) bugs self._output.resize_as_(self.output).copy_(self.output).add_(1e-7) self._view(self._gradOutput, gradOutput, gradOutput.size()) torch.div(self._div, gradOutput, self._output) if input.dim() == 1: self._div.resize_(1, outputSize) self._expand4 = self._div.expand_as(self.weight) if torch.type(input) == 'torch.cuda.FloatTensor': self._repeat2.resize_as_(self._expand4).copy_(self._expand4) self._repeat2.mul_(self._repeat) else: self._repeat2.mul_(self._repeat, self._expand4) self._repeat2.mul_(self.diagCov) torch.sum(self.gradInput, self._repeat2, 1) self.gradInput.resize_as_(input) elif input.dim() == 2: batchSize = input.size(0) self._div.resize_(batchSize, 1, outputSize) self._expand4 = self._div.expand(batchSize, inputSize, outputSize) if input.type() == 'torch.cuda.FloatTensor': self._repeat2.resize_as_(self._expand4).copy_(self._expand4) self._repeat2.mul_(self._repeat) self._repeat2.mul_(self._repeat3) else: torch.mul(self._repeat2, self._repeat, self._expand4) self._repeat2.mul_(self._expand3) torch.sum(self.gradInput, self._repeat2, 2) self.gradInput.resize_as_(input) else: raise RuntimeError("1D or 2D input expected") return self.gradInput
def accGradParameters(self, input, gradOutput, scale=1): inputSize, outputSize = self.weight.size(0), self.weight.size(1) """ dy_j 2 * c_j * c_j * (w_j - x) c_j * c_j * (w_j - x) ---- = -------------------------- = --------------------- dw_j 2 || c_j * (w_j - x) || y_j dy_j 2 * c_j * (w_j - x)^2 c_j * (w_j - x)^2 ---- = ----------------------- = ----------------- dc_j 2 || c_j * (w_j - x) || y_j #""" # assumes a preceding call to updateGradInput if input.dim() == 1: self.gradWeight.add_(-scale, self._repeat2) self._repeat.div_(self.diagCov) self._repeat.mul_(self._repeat) self._repeat.mul_(self.diagCov) if torch.type(input) == 'torch.cuda.FloatTensor': self._repeat2.resize_as_(self._expand4).copy_(self._expand4) self._repeat2.mul_(self._repeat) else: torch.mul(self._repeat2, self._repeat, self._expand4) self.gradDiagCov.add_(self._repeat2) elif input.dim() == 2: self._sum = self._sum or input.new() torch.sum(self._sum, self._repeat2, 0) self._sum.resize_(inputSize, outputSize) self.gradWeight.add_(-scale, self._sum) if input.type() == 'torch.cuda.FloatTensor': # requires lots of memory, but minimizes cudaMallocs and loops self._repeat.div_(self._repeat3) self._repeat.mul_(self._repeat) self._repeat.mul_(self._repeat3) self._repeat2.resize_as_(self._expand4).copy_(self._expand4) self._repeat.mul_(self._repeat2) else: self._repeat.div_(self._expand3) self._repeat.mul_(self._repeat) self._repeat.mul_(self._expand3) self._repeat.mul_(self._expand4) torch.sum(self._sum, self._repeat, 0) self._sum.resize_(inputSize, outputSize) self.gradDiagCov.add_(scale, self._sum) else: raise RuntimeError("1D or 2D input expected")
def updateGradInput(self, input, gradOutput): if self.gradInput is None: return if self._div is None: self._div = input.new() if self._output is None: self._output = self.output.new() if self._expand4 is None: self._expand4 = input.new() if self._gradOutput is None: self._gradOutput = input.new() if not self.fastBackward: self.updateOutput(input) inputSize, outputSize = self.weight.size(0), self.weight.size(1) """ dy_j -2 * c_j * c_j * (w_j - x) c_j * c_j * (x - w_j) ---- = -------------------------- = --------------------- dx 2 || c_j * (w_j - x) || y_j """ # to prevent div by zero (NaN) bugs self._output.resize_as_(self.output).copy_(self.output).add_(1e-7) self._view(self._gradOutput, gradOutput, gradOutput.size()) torch.div(gradOutput, self._output, out=self._div) if input.dim() == 1: self._div.resize_(1, outputSize) self._expand4 = self._div.expand_as(self.weight) if torch.type(input) == 'torch.cuda.FloatTensor': self._repeat2.resize_as_(self._expand4).copy_(self._expand4) self._repeat2.mul_(self._repeat) else: self._repeat2.mul_(self._repeat, self._expand4) self._repeat2.mul_(self.diagCov) torch.sum(self._repeat2, 1, out=self.gradInput) self.gradInput.resize_as_(input) elif input.dim() == 2: batchSize = input.size(0) self._div.resize_(batchSize, 1, outputSize) self._expand4 = self._div.expand(batchSize, inputSize, outputSize) if input.type() == 'torch.cuda.FloatTensor': self._repeat2.resize_as_(self._expand4).copy_(self._expand4) self._repeat2.mul_(self._repeat) self._repeat2.mul_(self._repeat3) else: torch.mul(self._repeat, self._expand4, out=self._repeat2) self._repeat2.mul_(self._expand3) torch.sum(self._repeat2, 2, out=self.gradInput) self.gradInput.resize_as_(input) else: raise RuntimeError("1D or 2D input expected") return self.gradInput
def accGradParameters(self, input, gradOutput, scale=1): inputSize, outputSize = self.weight.size(0), self.weight.size(1) """ dy_j 2 * c_j * c_j * (w_j - x) c_j * c_j * (w_j - x) ---- = -------------------------- = --------------------- dw_j 2 || c_j * (w_j - x) || y_j dy_j 2 * c_j * (w_j - x)^2 c_j * (w_j - x)^2 ---- = ----------------------- = ----------------- dc_j 2 || c_j * (w_j - x) || y_j #""" # assumes a preceding call to updateGradInput if input.dim() == 1: self.gradWeight.add_(-scale, self._repeat2) self._repeat.div_(self.diagCov) self._repeat.mul_(self._repeat) self._repeat.mul_(self.diagCov) if torch.type(input) == 'torch.cuda.FloatTensor': self._repeat2.resize_as_(self._expand4).copy_(self._expand4) self._repeat2.mul_(self._repeat) else: torch.mul(self._repeat, self._expand4, out=self._repeat2) self.gradDiagCov.add_(self._repeat2) elif input.dim() == 2: if self._sum is None: self._sum = input.new() torch.sum(self._repeat2, 0, out=self._sum) self._sum.resize_(inputSize, outputSize) self.gradWeight.add_(-scale, self._sum) if input.type() == 'torch.cuda.FloatTensor': # requires lots of memory, but minimizes cudaMallocs and loops self._repeat.div_(self._repeat3) self._repeat.mul_(self._repeat) self._repeat.mul_(self._repeat3) self._repeat2.resize_as_(self._expand4).copy_(self._expand4) self._repeat.mul_(self._repeat2) else: self._repeat.div_(self._expand3) self._repeat.mul_(self._repeat) self._repeat.mul_(self._expand3) self._repeat.mul_(self._expand4) torch.sum(self._repeat, 0, out=self._sum) self._sum.resize_(inputSize, outputSize) self.gradDiagCov.add_(scale, self._sum) else: raise RuntimeError("1D or 2D input expected")
def updateGradInput(self, input, gradOutput): if self.gradInput is None: return if self._div is None: self._div = input.new() if self._output is None: self._output = self.output.new() if self._expand4 is None: self._expand4 = input.new() if self._gradOutput is None: self._gradOutput = input.new() if not self.fastBackward: self.updateOutput(input) inputSize, outputSize = self.weight.size(0), self.weight.size(1) """ dy_j -2 * c_j * c_j * (w_j - x) c_j * c_j * (x - w_j) ---- = -------------------------- = --------------------- dx 2 || c_j * (w_j - x) || y_j """ # to prevent div by zero (NaN) bugs self._output.resize_as_(self.output).copy_(self.output).add_(1e-7) self._view(self._gradOutput, gradOutput, gradOutput.size()) torch.div(gradOutput, self._output, out=self._div) if input.dim() == 1: self._div.resize_(1, outputSize) self._expand4 = self._div.expand_as(self.weight) if torch.type(input) == 'torch.cuda.FloatTensor': self._repeat2.resize_as_(self._expand4).copy_(self._expand4) self._repeat2.mul_(self._repeat) else: self._repeat2.mul_(self._repeat, self._expand4) self._repeat2.mul_(self.diagCov) torch.sum(self._repeat2, 1, True, out=self.gradInput) self.gradInput.resize_as_(input) elif input.dim() == 2: batchSize = input.size(0) self._div.resize_(batchSize, 1, outputSize) self._expand4 = self._div.expand(batchSize, inputSize, outputSize) if input.type() == 'torch.cuda.FloatTensor': self._repeat2.resize_as_(self._expand4).copy_(self._expand4) self._repeat2.mul_(self._repeat) self._repeat2.mul_(self._repeat3) else: torch.mul(self._repeat, self._expand4, out=self._repeat2) self._repeat2.mul_(self._expand3) torch.sum(self._repeat2, 2, True, out=self.gradInput) self.gradInput.resize_as_(input) else: raise RuntimeError("1D or 2D input expected") return self.gradInput
def accGradParameters(self, input, gradOutput, scale=1): inputSize, outputSize = self.weight.size(0), self.weight.size(1) """ dy_j 2 * c_j * c_j * (w_j - x) c_j * c_j * (w_j - x) ---- = -------------------------- = --------------------- dw_j 2 || c_j * (w_j - x) || y_j dy_j 2 * c_j * (w_j - x)^2 c_j * (w_j - x)^2 ---- = ----------------------- = ----------------- dc_j 2 || c_j * (w_j - x) || y_j #""" # assumes a preceding call to updateGradInput if input.dim() == 1: self.gradWeight.add_(-scale, self._repeat2) self._repeat.div_(self.diagCov) self._repeat.mul_(self._repeat) self._repeat.mul_(self.diagCov) if torch.type(input) == 'torch.cuda.FloatTensor': self._repeat2.resize_as_(self._expand4).copy_(self._expand4) self._repeat2.mul_(self._repeat) else: torch.mul(self._repeat, self._expand4, out=self._repeat2) self.gradDiagCov.add_(self._repeat2) elif input.dim() == 2: if self._sum is None: self._sum = input.new() torch.sum(self._repeat2, 0, True, out=self._sum) self._sum.resize_(inputSize, outputSize) self.gradWeight.add_(-scale, self._sum) if input.type() == 'torch.cuda.FloatTensor': # requires lots of memory, but minimizes cudaMallocs and loops self._repeat.div_(self._repeat3) self._repeat.mul_(self._repeat) self._repeat.mul_(self._repeat3) self._repeat2.resize_as_(self._expand4).copy_(self._expand4) self._repeat.mul_(self._repeat2) else: self._repeat.div_(self._expand3) self._repeat.mul_(self._repeat) self._repeat.mul_(self._expand3) self._repeat.mul_(self._expand4) torch.sum(self._repeat, 0, True, out=self._sum) self._sum.resize_(inputSize, outputSize) self.gradDiagCov.add_(scale, self._sum) else: raise RuntimeError("1D or 2D input expected")
