我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用torch.IntTensor()。
def transpose_packed_sequence(ps): """ Goes from a TxB packed sequence to a BxT or vice versa. Assumes that nothing is a variable :param ps: PackedSequence :return: """ data, batch_sizes = ps seq_lens = transpose_batch_sizes(batch_sizes) # Put things in the permutation matrix one way, take out another way perm_mat = torch.IntTensor(batch_sizes[0], len(batch_sizes)).long().zero_() cur = 0 for i, sl in enumerate(seq_lens): for col_ind in range(sl): perm_mat[i, col_ind] = cur + col_ind cur += sl perm = pack_padded_sequence(perm_mat, seq_lens, batch_first=True).data return PackedSequence(data[perm], seq_lens)
def trainBatch(net, criterion, optimizer): data = train_iter.next() cpu_images, cpu_texts = data batch_size = cpu_images.size(0) utils.loadData(image, cpu_images) t, l = converter.encode(cpu_texts) utils.loadData(text, t) utils.loadData(length, l) preds = crnn(image) preds_size = Variable(torch.IntTensor([preds.size(0)] * batch_size)) cost = criterion(preds, text, preds_size, length) / batch_size crnn.zero_grad() cost.backward() optimizer.step() return cost
def encode(self, text): """Support batch or single str. Args: text (str or list of str): texts to convert. Returns: torch.IntTensor [length_0 + length_1 + ... length_{n - 1}]: encoded texts. torch.IntTensor [n]: length of each text. """ length = [] result = [] for item in text: if self.is_chinese(item): item = unicode(item,'utf-8') length.append(len(item)) for char in item: index = self.dict[char] result.append(index) text = result return (torch.IntTensor(text), torch.IntTensor(length))
def __init__(self, nIndex, nOutput, paddingValue=-1, maxNorm=None, normType=None): super(LookupTable, self).__init__() self.weight = torch.Tensor(nIndex, nOutput) self.gradWeight = torch.Tensor(nIndex, nOutput).zero_() self.paddingValue = paddingValue self.maxNorm = maxNorm self.normType = normType self.shouldScaleGradByFreq = False self._gradOutput = None self._sorted = None self._indices = None self._count = torch.IntTensor() self._input = torch.LongTensor() self.reset()
def type(self, type=None, tensorCache=None): if not type: return self._type super(LookupTable, self).type(type, tensorCache) if type == 'torch.cuda.FloatTensor': # CUDA uses _sorted and _indices temporary tensors self._sorted = torch.cuda.LongTensor() self._indices = torch.cuda.LongTensor() self._count = torch.cuda.LongTensor() self._input = torch.cuda.LongTensor() else: # self._count and self._input should only be converted if using Cuda self._count = torch.IntTensor() self._input = torch.LongTensor() return self
def test_serialization(self): x = torch.randn(5, 5).cuda() y = torch.IntTensor(2, 5).fill_(0).cuda() q = [x, y, x, y.storage()] with tempfile.NamedTemporaryFile() as f: torch.save(q, f) f.seek(0) q_copy = torch.load(f) self.assertEqual(q_copy, q, 0) q_copy[0].fill_(5) self.assertEqual(q_copy[0], q_copy[2], 0) self.assertTrue(isinstance(q_copy[0], torch.cuda.DoubleTensor)) self.assertTrue(isinstance(q_copy[1], torch.cuda.IntTensor)) self.assertTrue(isinstance(q_copy[2], torch.cuda.DoubleTensor)) self.assertTrue(isinstance(q_copy[3], torch.cuda.IntStorage)) q_copy[1].fill_(10) self.assertTrue(q_copy[3], torch.cuda.IntStorage(10).fill_(10))
def test_abs(self): size = 1000 max_val = 1000 original = torch.rand(size).mul(max_val) # Tensor filled with values from {-1, 1} switch = torch.rand(size).mul(2).floor().mul(2).add(-1) types = ['torch.DoubleTensor', 'torch.FloatTensor', 'torch.LongTensor', 'torch.IntTensor'] for t in types: data = original.type(t) switch = switch.type(t) res = torch.mul(data, switch) self.assertEqual(res.abs(), data, 1e-16) # Checking that the right abs function is called for LongTensor bignumber = 2^31 + 1 res = torch.LongTensor((-bignumber,)) self.assertGreater(res.abs()[0], 0)
def test_last_dim_softmax_handles_mask_correctly(self): batch_size = 1 length_1 = 4 length_2 = 3 num_options = 5 options_array = numpy.zeros((batch_size, length_1, length_2, num_options)) for i in range(length_1): for j in range(length_2): options_array[0, i, j] = [2, 4, 0, 1, 6] mask = Variable(torch.IntTensor([[1, 1, 1, 1, 0]])) options_tensor = Variable(torch.from_numpy(options_array).float()) softmax_tensor = util.last_dim_softmax(options_tensor, mask).data.numpy() assert softmax_tensor.shape == (batch_size, length_1, length_2, num_options) for i in range(length_1): for j in range(length_2): assert_almost_equal(softmax_tensor[0, i, j], [0.112457, 0.830953, 0.015219, 0.041371, 0.0], decimal=5)
def _prune_and_sort_spans(mention_scores: torch.FloatTensor, num_spans_to_keep: int) -> torch.IntTensor: """ The indices of the top-k scoring spans according to span_scores. We return the indices in their original order, not ordered by score, so that we can rely on the ordering to consider the previous k spans as antecedents for each span later. Parameters ---------- mention_scores : ``torch.FloatTensor``, required. The mention score for every candidate, with shape (batch_size, num_spans, 1). num_spans_to_keep : ``int``, required. The number of spans to keep when pruning. Returns ------- top_span_indices : ``torch.IntTensor``, required. The indices of the top-k scoring spans. Has shape (batch_size, num_spans_to_keep). """ # Shape: (batch_size, num_spans_to_keep, 1) _, top_span_indices = mention_scores.topk(num_spans_to_keep, 1) top_span_indices, _ = torch.sort(top_span_indices, 1) # Shape: (batch_size, num_spans_to_keep) top_span_indices = top_span_indices.squeeze(-1) return top_span_indices
def add(self, ref, pred): if not isinstance(ref, torch.IntTensor): raise TypeError('ref must be a torch.IntTensor (got {})' .format(type(ref))) if not isinstance(pred, torch.IntTensor): raise TypeError('pred must be a torch.IntTensor(got {})' .format(type(pred))) assert self.unk > 0, 'unknown token index must be >0' rref = ref.clone() rref.apply_(lambda x: x if x != self.unk else -x) rref = rref.contiguous().view(-1) pred = pred.contiguous().view(-1) C.bleu_add( ctypes.byref(self.stat), ctypes.c_size_t(rref.size(0)), ctypes.c_void_p(rref.data_ptr()), ctypes.c_size_t(pred.size(0)), ctypes.c_void_p(pred.data_ptr()), ctypes.c_int(self.pad), ctypes.c_int(self.eos))
def decode(self, t, length, raw=False): if length.numel() == 1: length = length[0] t = t[:length] if raw: return ''.join([self.alphabet[i - 1] for i in t]) else: char_list = [] for i in range(length): if t[i] != 0 and (not (i > 0 and t[i - 1] == t[i])): char_list.append(self.alphabet[t[i] - 1]) return ''.join(char_list) else: texts = [] index = 0 for i in range(length.numel()): l = length[i] texts.append(self.decode( t[index:index + l], torch.IntTensor([l]), raw=raw)) index += l return texts
def __init__(self, cfgfile): super(Darknet, self).__init__() self.blocks = parse_cfg(cfgfile) self.models = self.create_network(self.blocks) # merge conv, bn,leaky self.loss = self.models[len(self.models)-1] self.width = int(self.blocks[0]['width']) self.height = int(self.blocks[0]['height']) if self.blocks[(len(self.blocks)-1)]['type'] == 'region': region_block = self.blocks[(len(self.blocks)-1)] anchors = region_block['anchors'].split(',') self.anchors = [float(i) for i in anchors] self.num_anchors = int(region_block['num']) self.anchor_step = len(self.anchors)/self.num_anchors self.num_classes = int(region_block['classes']) self.header = torch.IntTensor([0,0,0,0]) self.seen = 0 self.has_mean = False
def forward(self, features, rois): batch_size, num_channels, data_height, data_width = features.size() num_rois = rois.size()[0] output = torch.zeros(num_rois, num_channels, self.pooled_height, self.pooled_width) argmax = torch.IntTensor(num_rois, num_channels, self.pooled_height, self.pooled_width).zero_() if not features.is_cuda: _features = features.permute(0, 2, 3, 1) roi_pooling.roi_pooling_forward(self.pooled_height, self.pooled_width, self.spatial_scale, _features, rois, output) # output = output.cuda() else: output = output.cuda() argmax = argmax.cuda() roi_pooling.roi_pooling_forward_cuda(self.pooled_height, self.pooled_width, self.spatial_scale, features, rois, output, argmax) self.output = output self.argmax = argmax self.rois = rois self.feature_size = features.size() return output
def __getitem__(self, index): support_set_x = torch.FloatTensor(self.n_samples, 3, 84, 84) support_set_y = np.zeros((self.n_samples), dtype=np.int) target_x = torch.FloatTensor(self.n_samples_eval, 3, 84, 84) target_y = np.zeros((self.n_samples_eval), dtype=np.int) flatten_support_set_x_batch = [os.path.join(self.miniImagenetImagesDir,item) for sublist in self.support_set_x_batch[index] for item in sublist] support_set_y = np.array([self.classes_dict[item[:9]] for sublist in self.support_set_x_batch[index] for item in sublist]) flatten_target_x = [os.path.join(self.miniImagenetImagesDir,item) for sublist in self.target_x_batch[index] for item in sublist] target_y = np.array([self.classes_dict[item[:9]] for sublist in self.target_x_batch[index] for item in sublist]) for i,path in enumerate(flatten_support_set_x_batch): if self.transform is not None: support_set_x[i] = self.transform(path) for i,path in enumerate(flatten_target_x): if self.transform is not None: target_x[i] = self.transform(path) return support_set_x, torch.IntTensor(support_set_y), target_x, torch.IntTensor(target_y)
def forward(self, features, rois): batch_size, num_channels, data_height, data_width = features.size() num_rois = rois.size()[0] output = torch.zeros(num_rois, num_channels, self.pooled_height, self.pooled_width) argmax = torch.IntTensor(num_rois, num_channels, self.pooled_height, self.pooled_width).zero_() if not features.is_cuda: assert False, 'feature not in CUDA' _features = features.permute(0, 2, 3, 1) roi_pooling.roi_pooling_forward(self.pooled_height, self.pooled_width, self.spatial_scale, _features, rois, output) # output = output.cuda() else: output = output.cuda() argmax = argmax.cuda() roi_pooling.roi_pooling_forward_cuda(self.pooled_height, self.pooled_width, self.spatial_scale, features, rois, output, argmax) self.output = output self.argmax = argmax self.rois = rois self.feature_size = features.size() return output
def type(self, type=None, tensorCache=None): if type is None: return self._type super(LookupTable, self).type(type, tensorCache) if type == 'torch.cuda.FloatTensor': # CUDA uses _sorted and _indices temporary tensors self._sorted = torch.cuda.LongTensor() self._indices = torch.cuda.LongTensor() self._count = torch.cuda.LongTensor() self._input = torch.cuda.LongTensor() else: # self._count and self._input should only be converted if using Cuda self._count = torch.IntTensor() self._input = torch.LongTensor() return self
def test_type_conversions(self): x = Variable(torch.randn(5, 5)) self.assertIs(type(x.float().data), torch.FloatTensor) self.assertIs(type(x.int().data), torch.IntTensor) if torch.cuda.is_available(): self.assertIs(type(x.float().cuda().data), torch.cuda.FloatTensor) self.assertIs(type(x.int().cuda().data), torch.cuda.IntTensor) self.assertIs(type(x.int().cuda().cpu().data), torch.IntTensor) if torch.cuda.device_count() > 2: x2 = x.float().cuda(1) self.assertIs(type(x2.data), torch.cuda.FloatTensor) self.assertIs(x2.get_device(), 1) x2 = x.float().cuda() self.assertIs(type(x2.data), torch.cuda.FloatTensor) self.assertIs(x2.get_device(), 0) x2 = x2.cuda(1) self.assertIs(type(x2.data), torch.cuda.FloatTensor) self.assertIs(x2.get_device(), 1) for t in [torch.DoubleTensor, torch.FloatTensor, torch.IntTensor, torch.ByteTensor]: y = Variable(torch.randn(5, 5).type(t)) self.assertIs(type(x.type_as(y).data), t)
def _test_btrisolve(self, cast): a = torch.FloatTensor((((1.3722, -0.9020), (1.8849, 1.9169)), ((0.7187, -1.1695), (-0.0139, 1.3572)), ((-1.6181, 0.7148), (1.3728, 0.1319)))) b = torch.FloatTensor(((4.02, 6.19), (-1.56, 4.00), (9.81, -4.09))) a, b = cast(a), cast(b) info = cast(torch.IntTensor()) LU_data, pivots = a.btrifact(info=info) self.assertEqual(info.abs().sum(), 0) x = torch.btrisolve(b, LU_data, pivots) b_ = torch.bmm(a, x.unsqueeze(2)).squeeze() self.assertEqual(b_, b)
def test_abs(self): size = 1000 max_val = 1000 original = torch.rand(size).mul(max_val) # Tensor filled with values from {-1, 1} switch = torch.rand(size).mul(2).floor().mul(2).add(-1) types = ['torch.DoubleTensor', 'torch.FloatTensor', 'torch.LongTensor', 'torch.IntTensor'] for t in types: data = original.type(t) switch = switch.type(t) res = torch.mul(data, switch) # abs is used in assertEqual so we use the slow version instead self.assertTensorsSlowEqual(res.abs(), data, 1e-16) # Checking that the right abs function is called for LongTensor bignumber = 2 ^ 31 + 1 res = torch.LongTensor((-bignumber,)) self.assertGreater(res.abs()[0], 0)
def encode(self, text): """Support batch or single str. Args: text (str or list of str): texts to convert. Returns: torch.IntTensor [length_0 + length_1 + ... length_{n - 1}]: encoded texts. torch.IntTensor [n]: length of each text. """ if isinstance(text, str): text = [ self.dict[char.lower() if self._ignore_case else char] for char in text ] length = [len(text)] elif isinstance(text, collections.Iterable): length = [len(s) for s in text] text = ''.join(text) text, _ = self.encode(text) return (torch.IntTensor(text), torch.IntTensor(length))
def test_type_conversions(self): x = Variable(torch.randn(5, 5)) self.assertIs(type(x.float().data), torch.FloatTensor) self.assertIs(type(x.int().data), torch.IntTensor) if torch.cuda.is_available(): self.assertIs(type(x.float().cuda().data), torch.cuda.FloatTensor) self.assertIs(type(x.int().cuda().data), torch.cuda.IntTensor) self.assertIs(type(x.int().cuda().cpu().data), torch.IntTensor) if torch.cuda.device_count() > 2: x2 = x.float().cuda(1) self.assertIs(type(x2.data), torch.cuda.FloatTensor) self.assertIs(x2.get_device(), 1) x2 = x.float().cuda() self.assertIs(type(x2.data), torch.cuda.FloatTensor) self.assertIs(x2.get_device(), 0) x2 = x2.cuda(1) self.assertIs(type(x2.data), torch.cuda.FloatTensor) self.assertIs(x2.get_device(), 1) for t in [torch.DoubleTensor, torch.FloatTensor, torch.IntTensor, torch.ByteTensor]: for var in (True, False): y = torch.randn(5, 5).type(t) if var: y = Variable(y) self.assertIs(type(x.type_as(y).data), t)
def _sample(self, state, context, mask, max_len=20): """ Performs sampling """ batch_size = state.size(0) toks = [const_row(self.bos_token, batch_size, volatile=True)] lens = torch.IntTensor(batch_size) if torch.cuda.is_available(): lens = lens.cuda() for l in range(max_len + 1): # +1 because of EOS out, state, alpha = self._lstm_loop(state, self.embedding(toks[-1]), context, mask) # Do argmax (since we're doing greedy decoding) toks.append(out.max(1)[1].squeeze(1)) lens[(toks[-1].data == self.eos_token) & (lens == 0)] = l+1 if all(lens): break lens[lens == 0] = max_len+1 return torch.stack(toks, 0), lens
def test_serialization_array_with_storage(self): x = torch.randn(5, 5).cuda() y = torch.IntTensor(2, 5).fill_(0).cuda() q = [x, y, x, y.storage()] with tempfile.NamedTemporaryFile() as f: torch.save(q, f) f.seek(0) q_copy = torch.load(f) self.assertEqual(q_copy, q, 0) q_copy[0].fill_(5) self.assertEqual(q_copy[0], q_copy[2], 0) self.assertTrue(isinstance(q_copy[0], torch.cuda.DoubleTensor)) self.assertTrue(isinstance(q_copy[1], torch.cuda.IntTensor)) self.assertTrue(isinstance(q_copy[2], torch.cuda.DoubleTensor)) self.assertTrue(isinstance(q_copy[3], torch.cuda.IntStorage)) q_copy[1].fill_(10) self.assertTrue(q_copy[3], torch.cuda.IntStorage(10).fill_(10))
def _test_neg(self, cast): float_types = ['torch.DoubleTensor', 'torch.FloatTensor', 'torch.LongTensor'] int_types = ['torch.IntTensor', 'torch.ShortTensor'] for t in float_types + int_types: if t in float_types: a = cast(torch.randn(100, 90).type(t)) else: a = cast(torch.Tensor(100, 90).type(t).random_()) zeros = cast(torch.Tensor().type(t)).resize_as_(a).zero_() res_add = torch.add(zeros, -1, a) res_neg = a.clone() res_neg.neg_() self.assertEqual(res_neg, res_add) # test out of place as well res_neg_out_place = a.clone().neg() self.assertEqual(res_neg_out_place, res_add) # test via __neg__ operator res_neg_op = -a.clone() self.assertEqual(res_neg_op, res_add)
def __call__(self, img): assert isinstance(img, np.ndarray) # handle numpy array if img.dtype == np.uint16: img = img.astype(np.int32) div = 2**16 elif img.dtype == np.uint32: img = img.astype(np.int32) div = 2**32 elif img.dtype == np.int32: div = 2**32 else: div = 1. img = torch.from_numpy(img.transpose((2, 0, 1))) if isinstance(img, torch.ByteTensor): return img.float().div(255) elif isinstance(img, torch.IntTensor): return img.float().div(div) else: return img
def __init__(self, cfgfile): super(Darknet, self).__init__() self.blocks = parse_cfg(cfgfile) self.models = self.create_network(self.blocks) # merge conv, bn,leaky self.loss = self.models[len(self.models)-1] self.width = int(self.blocks[0]['width']) self.height = int(self.blocks[0]['height']) if self.blocks[(len(self.blocks)-1)]['type'] == 'region': self.anchors = self.loss.anchors self.num_anchors = self.loss.num_anchors self.anchor_step = self.loss.anchor_step self.num_classes = self.loss.num_classes self.header = torch.IntTensor([0,0,0,0]) self.seen = 0
def process_string(self, sequence, size, remove_repetitions=False): string = '' offsets = [] for i in range(size): char = self.int_to_char[sequence[i]] if char != self.int_to_char[self.blank_index]: # if this char is a repetition and remove_repetitions=true, then skip if remove_repetitions and i != 0 and char == self.int_to_char[sequence[i - 1]]: pass elif char == self.labels[self.space_index]: string += ' ' offsets.append(i) else: string = string + char offsets.append(i) return string, torch.IntTensor(offsets)
def iteration(input_data): target = torch.IntTensor(int(batch_size * ((seconds * 100) / 2))).fill_(1) # targets, align half of the audio target_size = torch.IntTensor(batch_size).fill_(int((seconds * 100) / 2)) input_percentages = torch.IntTensor(batch_size).fill_(1) inputs = Variable(input_data, requires_grad=False) target_sizes = Variable(target_size, requires_grad=False) targets = Variable(target, requires_grad=False) start = time.time() out = model(inputs) out = out.transpose(0, 1) # TxNxH seq_length = out.size(0) sizes = Variable(input_percentages.mul_(int(seq_length)).int(), requires_grad=False) loss = criterion(out, targets, sizes, target_sizes) loss = loss / inputs.size(0) # average the loss by minibatch # compute gradient optimizer.zero_grad() loss.backward() optimizer.step() torch.cuda.synchronize() end = time.time() del loss del out return start, end
def _collate_fn(batch): def func(p): return p[0].size(1) longest_sample = max(batch, key=func)[0] freq_size = longest_sample.size(0) minibatch_size = len(batch) max_seqlength = longest_sample.size(1) inputs = torch.zeros(minibatch_size, 1, freq_size, max_seqlength) input_percentages = torch.FloatTensor(minibatch_size) target_sizes = torch.IntTensor(minibatch_size) targets = [] for x in range(minibatch_size): sample = batch[x] tensor = sample[0] target = sample[1] seq_length = tensor.size(1) inputs[x][0].narrow(1, 0, seq_length).copy_(tensor) input_percentages[x] = seq_length / float(max_seqlength) target_sizes[x] = len(target) targets.extend(target) targets = torch.IntTensor(targets) return inputs, targets, input_percentages, target_sizes
def _test_neg(self, cast): float_types = ['torch.DoubleTensor', 'torch.FloatTensor', 'torch.LongTensor'] int_types = ['torch.IntTensor', 'torch.ShortTensor', 'torch.ByteTensor', 'torch.CharTensor'] for t in float_types + int_types: if t in float_types: a = cast(torch.randn(100, 90).type(t)) else: a = cast(torch.Tensor(100, 90).type(t).random_()) zeros = cast(torch.Tensor().type(t)).resize_as_(a).zero_() res_add = torch.add(zeros, -1, a) res_neg = a.clone() res_neg.neg_() self.assertEqual(res_neg, res_add) # test out of place as well res_neg_out_place = a.clone().neg() self.assertEqual(res_neg_out_place, res_add) # test via __neg__ operator res_neg_op = -a.clone() self.assertEqual(res_neg_op, res_add)
def test_new(self): x = torch.autograd.Variable(torch.Tensor()) y = torch.autograd.Variable(torch.randn(4, 4)) z = torch.autograd.Variable(torch.IntTensor([1, 2, 3])) self.assertEqual(x.new().shape, [0]) self.assertEqual(x.new(), x) self.assertEqual(x.new(1, 2).shape, [1, 2]) self.assertEqual(x.new(torch.Size([3, 4])).shape, [3, 4]) self.assertEqual(x.new([3, 4]).shape, [2]) self.assertEqual(x.new([3, 4]).tolist(), [3, 4]) self.assertEqual(x.new((3, 4)).tolist(), [3, 4]) self.assertEqual(x.new(size=(3, 4)).shape, [3, 4]) self.assertEqual(x.new(tuple()).shape, [0]) self.assertEqual(x.new(y.storage()).data_ptr(), y.data_ptr()) self.assertEqual(x.new(y).data_ptr(), y.data_ptr()) self.assertIsNot(x.new(y), y) self.assertRaises(TypeError, lambda: x.new(z)) # TypeError would be better self.assertRaises(RuntimeError, lambda: x.new(z.storage()))
