Lines Matching full:names
22 x = torch.empty(2, names=(name,))
34 # 'N:3,C:2' -> size = [3, 2], names: ['N', 'C']
35 # 'None:3,None:2' -> size = [3, 2], names: ['None', 'None']
36 # '3,2' -> size = [3, 2], names=None passed to ctor.
45 # '' -> size: [], names:None
49 # '3, 2' -> size = [3, 2], None names.
60 names, shape = parse_compressed_namedshape(namedshape)
61 return factory(shape, names=names)
78 x = torch.randn(3, 3, names=('N', 'C'))
95 self.assertEqual(result.names, expected_names,
101 self.assertEqual(x.names, y.names)
108 self.assertEqual(x.names, ())
111 self.assertEqual(x.names, (None, None, None))
113 x = factory(1, 2, 3, names=None, device=device)
114 self.assertEqual(x.names, (None, None, None))
116 x = factory(1, 2, 3, names=('N', 'T', 'D'), device=device)
117 self.assertEqual(x.names, ('N', 'T', 'D'))
119 x = factory(1, 2, 3, names=('N', None, 'D'), device=device)
120 self.assertEqual(x.names, ('N', None, 'D'))
122 x = factory(1, 2, 3, names=('_1', 'batch9', 'BATCH_5'), device=device)
123 self.assertEqual(x.names, ('_1', 'batch9', 'BATCH_5'))
127 x = factory(2, names=('1',), device=device)
131 x = factory(2, names=('?',), device=device)
133 with self.assertRaisesRegex(RuntimeError, 'Number of names'):
134 x = factory(2, 1, names=('N',), device=device)
137 x = factory(2, 1, names='N', device=device)
139 with self.assertRaisesRegex(RuntimeError, 'construct a tensor with duplicate names'):
140 x = factory(2, 1, 1, names=('N', 'C', 'N'), device=device)
143 x = factory([1] * 64, names=names64, device=device)
144 self.assertEqual(x.names, names64)
150 x = factory([1] * 65, names=names64, device=device)
156 unnamed.names # materialize [None, None]
163 msg='Using tensor.names should not change '
168 none_named = torch.empty(2, 3, names=(None, None))
169 partially_named = torch.empty(2, 3, names=('N', None))
170 fully_named = torch.empty(2, 3, names=('N', 'C'))
180 self.assertEqual(output.names, ['N', None, None, 'C'])
198 # Too few names
219 names = ['N']
222 [torch.randn(3, requires_grad=True, names=names)],
223 names)
226 [torch.randn(3, requires_grad=True, names=names)],
227 names)
232 x = torch.randn(3, 5, device=device, names=expected_names)
235 self.assertEqual(output.names, expected_names)
238 self.assertEqual(output.names, expected_names)
241 self.assertEqual(output.names, expected_names)
244 self.assertEqual(output.names, expected_names)
258 self.assertEqual(output.names, ['N', 'H', 'W'])
261 self.assertEqual(output.names, ['N'])
265 expected = "tensor([[0., 0., 0.],\n [0., 0., 0.]], names=('N', 'C'))"
276 named_tensor = torch.zeros(2, 3, 5, 7, names=list('ABCD'))
277 self.assertEqual(named_tensor.diagonal().names, ['C', 'D', None])
278 self.assertEqual(named_tensor.diagonal(1, 3).names, ['A', 'C', None])
280 self.assertEqual(named_tensor.diagonal(outdim='E', dim1='B', dim2='D').names,
286 self.assertEqual(values.names, expected_names)
287 self.assertEqual(indices.names, expected_names)
291 named_tensor_1d = torch.zeros(2, 3, 5, device=device, names=list('ABC'))
292 named_tensor_2d = torch.zeros(2, 3, 5, 7, device=device, names=list('ABCD'))
293 named_tensor_3d = torch.zeros(2, 3, 5, 7, 9, device=device, names=list('ABCDE'))
295 self.assertEqual(F.max_pool1d(named_tensor_1d, 2).names, named_tensor_1d.names)
296 self.assertEqual(F.max_pool2d(named_tensor_2d, [2, 2]).names, named_tensor_2d.names)
297 self.assertEqual(F.max_pool3d(named_tensor_3d, [2, 2, 2]).names, named_tensor_3d.names)
299 … check_tuple_return(F.max_pool1d_with_indices, [named_tensor_1d, 2], named_tensor_1d.names)
300 … check_tuple_return(F.max_pool2d_with_indices, [named_tensor_2d, [2, 2]], named_tensor_2d.names)
301 … check_tuple_return(F.max_pool3d_with_indices, [named_tensor_3d, [2, 2, 2]], named_tensor_3d.names)
313 named_tensor = torch.zeros(2, 3, names=('N', 'C'))
319 named_tensor = torch.zeros(2, 3, names=('N', 'C'))
324 named_tensor = torch.zeros(2, 3, names=('N', 'C'))
332 names_tag = f'names={named_tensor.names}'
335 check_repr(torch.randn(128, 3, 64, 64, names=('N', 'C', 'H', 'W')))
341 self.assertEqual(x.contiguous().names, ('N', 'C'))
346 x = torch.empty(2, 5, names=self_names)
349 self.assertEqual(x.names, expected_names)
355 tensor = torch.empty(1, 1, names=('N', 'C'))
356 self.assertEqual(tensor.rename_(None).names, (None, None))
357 self.assertEqual(tensor.rename_('H', 'W').names, ('H', 'W'))
358 with self.assertRaisesRegex(RuntimeError, 'Number of names'):
360 with self.assertRaisesRegex(RuntimeError, 'duplicate names'):
364 tensor = torch.empty(1, 1, names=('N', 'C'))
366 self.assertEqual(tensor.rename(None).names, (None, None))
367 self.assertEqual(tensor.rename('H', 'W').names, ('H', 'W'))
369 # Check that we didn't modify tensor.names
370 self.assertEqual(tensor.names, ('N', 'C'))
372 with self.assertRaisesRegex(RuntimeError, 'Number of names'):
374 with self.assertRaisesRegex(RuntimeError, 'duplicate names'):
387 named_tensor = torch.empty(1, 1, 1, 1, names=('N', 'C', 'H', 'W'))
389 self.assertEqual(scalar.rename(None).names, [])
390 self.assertEqual(scalar.rename('...').names, [])
393 self.assertEqual(unnamed_tensor.rename('...').names, unnamed_tensor.names)
394 self.assertEqual(unnamed_tensor.rename('...', 'H', 'W').names,
396 self.assertEqual(unnamed_tensor.rename('N', '...', 'W').names,
398 self.assertEqual(unnamed_tensor.rename('N', 'C', '...').names,
402 self.assertEqual(named_tensor.rename('...').names, named_tensor.names)
403 self.assertEqual(named_tensor.rename('...', 'width').names,
405 self.assertEqual(named_tensor.rename('batch', 'channels', '...', 'width').names,
407 self.assertEqual(named_tensor.rename('batch', '...').names,
411 self.assertEqual(unnamed_tensor.rename('...', None, None, None, None).names,
413 self.assertEqual(named_tensor.rename('N', 'C', 'H', '...', 'W').names,
423 named_tensor = torch.empty(1, 1, 1, 1, names=('N', 'C', 'H', 'W'))
436 self.assertEqual(named_tensor.rename(N='batch').names,
438 self.assertEqual(named_tensor.rename(N='batch', H='height').names,
442 tensor = torch.empty(1, 1, names=('N', 'C'))
444 tensor.names = None
445 self.assertEqual(tensor.names, (None, None))
447 tensor.names = ('N', 'W')
448 self.assertEqual(tensor.names, ('N', 'W'))
450 with self.assertRaisesRegex(RuntimeError, 'Number of names'):
451 tensor.names = ['N', 'C', 'W']
452 with self.assertRaisesRegex(RuntimeError, 'duplicate names'):
453 tensor.names = ['N', 'N']
461 names = ('N', 'T', 'D')
464 result = factory(1, 2, 3, names=names, device=device)
467 expected = factory(1, 2, 3, device=device).rename_(*names)
483 names = ('N', 'T', 'D')
484 result = torch.full([1, 2, 3], 2., names=names, device=device)
485 expected = torch.full([1, 2, 3], 2., device=device).rename_(*names)
489 names = ('N', 'C')
490 tensor = torch.tensor([[1]], names=names)
491 self.assertEqual(tensor.names, names)
493 names = ('N',)
494 tensor = torch.tensor([1], names=names)
495 self.assertEqual(tensor.names, names)
497 with self.assertRaisesRegex(RuntimeError, 'Number of names'):
498 names = ('N', 'C')
499 tensor = torch.tensor([1], names=names)
505 names = ('N', 'C')
506 tensor = torch.tensor([[1]], names=names)
507 self.assertEqual(tensor.names, names)
511 names = ('N', 'C')
512 tensor = torch.tensor(x, names=names)
513 self.assertEqual(tensor.names, names)
516 x = torch.randn(1, 1, names=('N', 'D'))
518 self.assertEqual(tensor.names, ('N', 'D'))
520 # there's no way to distinguish between names=None and not passing in names.
521 # If the user passes in names=None they are asking for trouble.
522 x = torch.randn(1, 1, names=('N', 'D'))
523 tensor = torch.tensor(x, names=None)
524 self.assertEqual(tensor.names, ('N', 'D'))
526 x = torch.randn(1, 1, names=('N', 'D'))
528 tensor = torch.tensor(x, names=('N', 'C'))
531 t = torch.empty(2, 3, 5, names=('N', None, 'C'))
540 t = torch.empty(2, 3, 5, names=('N', None, 'C'))
549 t = torch.randn(2, 3, 5, 7, names=('N', 'C', 'H', 'W'))
550 self.assertEqual(t.transpose('N', 'C').names, ['C', 'N', 'H', 'W'])
551 self.assertEqual(t.transpose(1, 3).names, ['N', 'W', 'H', 'C'])
553 t = torch.randn(2, 3, names=('N', 'C'))
554 self.assertEqual(t.t().names, ['C', 'N'])
558 named = torch.randn(2, names=('N',), device=device)
560 self.assertEqual(named.names, ['N'])
565 other_named = torch.randn(2, names=('N',), device=device)
567 self.assertEqual(other_named.names, ['N'])
571 RuntimeError, r'names .* are not the same as the computed output names'):
576 self.assertEqual(unnamed.names, ['N'])
580 tensor = torch.randn(3, 1, 2, 7, names=('M', 'N', 'first_group', 'features'),
582 other = torch.randn(5, 11, 7, names=('N', 'second_group', 'features'),
585 self.assertEqual(result.names, ['M', 'N', 'first_group', 'second_group'])
589 tensor = torch.empty(1, 1, names=('N', 'D'))
628 x = torch.randn(3, 3, names=('N', 'D'), requires_grad=True)
637 tensor = torch.empty(1, 1, names=('N', 'D'), requires_grad=True)
651 orig_tensor = torch.empty(2, 2, names=('N', 'D'), device=device)
655 self.assertEqual(split.names, orig_tensor.names)
659 x = torch.zeros(3, dtype=torch.bool, device=device, names=('C',))
660 self.assertEqual(x.any().names, [])
661 self.assertEqual(x.all().names, [])
665 names = ['N']
666 a = torch.rand(3, device=device, names=names)
667 b = torch.rand(3, device=device, names=names)
669 c = torch.rand(3, device=device, names=names).clamp_min_(0.1)
670 out = torch.randn(3, device=device, names=names)
672 self.assertEqual(torch.addcmul(a, b, c).names, names)
673 self.assertEqual(torch.addcmul(a, b, c, out=out).names, names)
674 self.assertEqual(a.addcmul_(b, c).names, names)
676 self.assertEqual(torch.addcdiv(a, b, c).names, names)
677 self.assertEqual(torch.addcdiv(a, b, c, out=out).names, names)
678 self.assertEqual(a.addcdiv_(b, c).names, names)
682 a = torch.empty(2, 3, names=('N', 'C'))
683 b = torch.empty(3, 2, names=('C', 'N'))
684 c = torch.empty(3, names=('C',))
685 d = torch.empty(5, names=('W',))
687 self.assertEqual(op(a, a).names, ('N', 'C'))
688 self.assertEqual(op(a, c).names, ('N', 'C'))
698 a = torch.empty(2, 3, names=('N', 'C'))
699 c = torch.empty(2, 3, names=(None, 'C'))
700 self.assertEqual(op(a, c).names, ('N', 'C'))
703 self.assertEqual(op(a, b).names, ('N', 'C'))
705 d = torch.empty(2, 3, names=('C', None))
710 named2 = torch.randn(1, 1, names=('N', 'C'))
721 return [None] * (unnamed_dim - named.dim()) + list(named.names)
723 return named.names
735 self.assertEqual(op(tensor, other).names, expected_names)
780 # (out-of-place, inplace, out=) propagates names.
804 named = torch.randn(2, 3, names=('N', 'C'), device=device)
808 self.assertEqual(result.names, named.names)
811 self.assertEqual(result.names, named.names)
814 self.assertEqual(result.names, named.names)
819 none_named_tensor = torch.randn(3, 2, names=(None, None))
820 named_tensor = torch.randn(3, 2, names=('N', 'C'))
821 partially_named_tensor = torch.randn(3, 2, names=('N', None))
836 output = torch.randn(3, 2, names=(None, None))
838 self.assertEqual(output.names, named_tensor.names)
842 self.assertEqual(output.names, named_tensor.names)
844 output = torch.randn(3, 2, names=(None, None))
849 def _test(testcase, names=('N', 'D'), device='cpu'): argument
850 sizes = [2] * len(names)
851 tensor = torch.empty(sizes, names=names, device=device)
857 self.assertEqual(out.names, tensor.names,
999 names = ('N', 'D')
1000 tensor = torch.rand(2, 3, names=names)
1002 self.assertEqual(result[0].names, names)
1003 self.assertEqual(result[1].names, names)
1009 names = ('N', 'D')
1010 tensor = torch.rand(2, 3, names=names)
1012 self.assertEqual(result.names, names)
1016 names = ('N', 'D')
1017 tensor = torch.zeros(2, 3, names=names, dtype=torch.bool)
1020 self.assertEqual(tensor.bitwise_not().names, names)
1021 self.assertEqual(torch.bitwise_not(tensor, out=result).names, names)
1022 self.assertEqual(tensor.bitwise_not_().names, names)
1026 names = ('N', 'D')
1027 tensor = torch.zeros(2, 3, names=names, dtype=torch.bool)
1030 self.assertEqual(tensor.logical_not().names, names)
1031 self.assertEqual(torch.logical_not(tensor, out=result).names, names)
1032 self.assertEqual(tensor.logical_not_().names, names)
1036 names = ('N', 'D')
1037 tensor = torch.rand(2, 3, names=names)
1039 self.assertEqual(tensor.bernoulli().names, names)
1042 self.assertEqual(result.names, names)
1045 tensor = torch.randn(2, 3, 5, 7, 11, names=('N', 'C', 'D', 'H', 'W'))
1049 self.assertEqual(out.names, ['N', 'C', 'features'])
1054 self.assertEqual(out.names, ['N', 'C', 'features'])
1059 self.assertEqual(out.names, ['N', 'C', 'features'])
1063 sentences = torch.randn(2, 3, 5, 7, names=('N', 'T', 'H', 'D'))
1066 self.assertEqual(out.names, ['N_H', 'T', 'D'])
1100 torch.ones(4, names=('A',)).unflatten('A', (('A', 2), ('B', 2))),
1101 torch.ones(2, 2, names=('A', 'B'))))
1103 torch.ones(4, names=('A',)).unflatten('A', [('A', 2), ('B', 2)]),
1104 torch.ones(2, 2, names=('A', 'B'))))
1106 torch.ones(4, names=('A',)).unflatten('A', (['A', 2], ['B', 2])),
1107 torch.ones(2, 2, names=('A', 'B'))))
1109 torch.ones(2, 10, names=('A', 'B')).unflatten('B', (['B1', -1],)),
1110 torch.ones(2, 10, names=('A', 'B1'))))
1112 torch.ones(2, 3 * 4 * 5 * 6, names=('A', 'B'))
1114 torch.ones(2, 3, 4, 5, 6, names=('A', 'B1', 'B2', 'B3', 'B4'))))
1116 torch.ones(2, 0, names=('A', 'B'))
1118 torch.ones(2, 3, 0, 4, names=('A', 'B1', 'B2', 'B3'))))
1122 torch.ones(2, 4, names=('A', 'B')).unflatten('B', (('B1', 2), ('B2', 2))),
1123 torch.ones(2, 2, 2, names=('A', 'B1', 'B2'))))
1127 torch.tensor([1], names=('A',)).unflatten('A', (1, 1))
1130 …with self.assertRaisesRegex(RuntimeError, r"input is a named tensor but no names were given for un…
1131 torch.tensor([1], names=("A",)).unflatten(0, (1, 1))
1136 torch.ones(2, 4, names=('A', 'B')).unflatten('B', (('B1', 3), ('B2', -1)))
1140 torch.ones(2, 0, names=('A', 'B')).unflatten('B', (('B1', 0), ('B2', -1)))
1142 tensor = torch.randn(7, 2 * 3 * 5, 11, names=('N', 'D', 'K'))
1146 self.assertEqual(out.names, ('N', 'C', 'H', 'W', 'K'))
1151 self.assertEqual(out.names, ('N', 'H', 'D', 'K'))
1156 self.assertEqual(out.names, ('N', 'D', 'K', 'H'))
1169 named = torch.randn(3, 3, names=('N', 'C'))
1180 self.assertEqual(output.names, expected_names)
1183 self.assertEqual(out.names, expected_names)
1194 t = torch.empty(2, 3, 5, names=('N', 'C', 'L'), device=device)
1217 t = torch.empty(2, 3, 5, names=('N', 'C', 'L'), device=device, requires_grad=True)
1222 t = torch.empty(2, 3, 5, names=('N', 'C', 'L'), device=device)
1226 t = torch.empty(2, 3, 5, names=('N', 'C', 'L'), device=device)
1235 t = torch.empty(2, 3, 5, names=('N', 'C', 'L'), device=device)
1244 t = torch.empty(2, 3, 5, names=('N', 'C', 'L'), device=device)
1340 # error: names don't match
1389 # inplace, computed names don't match output tensor names
1393 maybe_raises_regex="not the same as the computed output names")
1446 x = torch.empty(2, 3, 4, 5, names=('N', 'C', 'H', 'W'), device=device)
1448 self.assertEqual(y.names, ('N', 'H', 'W'))
1451 self.assertEqual(y.names, ('N', 'H', 'W'))
1465 x = torch.empty(2, 3, 4, 5, names=('N', 'C', 'H', 'W'), device=device)
1467 self.assertEqual(y.names, (None,))
1478 return torch.full(x.shape, 2., names=('N',))
1497 foo(torch.randn(2, 3, names=('N', 'C')))
1501 x.names = ('N', 'C')
1515 self.assertEqual(output.names, ['N'])
1521 self.assertEqual(output.names, ['N', 'D'])
1527 self.assertEqual(output.names, ['C', 'N'])
1533 self.assertEqual(output.names, ['N', 'H', 'W', 'C'])
1540 # not enough names
1544 # names not found
1553 self.assertEqual(output.names, ['N', 'H', 'W', 'C'])
1558 self.assertEqual(output.names, ['H', 'C', 'W', 'N'])
1563 self.assertEqual(output.names, ['H', 'C', 'N', 'W'])
1568 self.assertEqual(output.names, ['W', 'H', 'C', 'N'])
1573 self.assertEqual(output.names, ['N', 'C', 'D', 'H', 'W'])
1579 self.assertEqual(output.names, ['C', None, None, None])
1589 # Input order duplicate names
1590 with self.assertRaisesRegex(RuntimeError, "duplicate names"):
1599 self.assertEqual(output.names, ['N', 'H', 'W', 'C'])
1606 tensor = torch.empty(*tensor_sizes, names=tensor_names)
1607 other = torch.empty([1] * len(align_names), names=align_names)
1615 self.assertEqual(output.names, align_names)
1716 longest_names = tensors[0].names
1718 if len(tensor.names) > len(longest_names):
1719 longest_names = tensor.names
1722 x = torch.empty(1, 1, names=('N', 'H'))
1723 y = torch.empty(2, 3, 5, names=('N', 'C', 'H'))
1724 z = torch.empty(2, names=('N',))
1758 maybe_raises_regex='with duplicate names')
1778 # full names
1811 maybe_raises_regex='with duplicate names')
1815 # full names
1839 # duplicate names after mm
1843 maybe_raises_regex='with duplicate names')
1903 maybe_raises_regex='with duplicate names')
1925 # duplicate names after mm
1929 maybe_raises_regex='with duplicate names')
1964 # full names
1990 # is not (see native_functions.yaml). Test that autograd ignores names
1992 x = torch.randn(3, 3, names=('N', 'C'), requires_grad=True)
1996 x = torch.randn(3, 3, names=(None, None), requires_grad=True)
1997 y = torch.randn(3, 3, names=('N', 'C'), requires_grad=True)
2000 # Check that names weren't propagated
2001 self.assertEqual(y.grad.names, [None, None])
2002 self.assertEqual(x.grad.names, [None, None])
2005 base = torch.randn(3, 3, names=('N', 'C'))
2024 # torch.dot ignores the names of both tensors
2032 a = torch.randn(3, 3, names=('N', 'C'), device=device)
2033 b = torch.randn(3, 3, names=('N', 'C'), device=device)
2036 self.assertEqual((a == b).names, ['N', 'C'])
2037 self.assertEqual((a != b).names, ['N', 'C'])
2038 self.assertEqual((a > b).names, ['N', 'C'])
2039 self.assertEqual((a < b).names, ['N', 'C'])
2040 self.assertEqual((a >= b).names, ['N', 'C'])
2041 self.assertEqual((a <= b).names, ['N', 'C'])
2043 self.assertEqual((a == 1).names, ['N', 'C'])
2044 self.assertEqual((a != 1).names, ['N', 'C'])
2045 self.assertEqual((a > 1).names, ['N', 'C'])
2046 self.assertEqual((a < 1).names, ['N', 'C'])
2047 self.assertEqual((a >= 1).names, ['N', 'C'])
2048 self.assertEqual((a <= 1).names, ['N', 'C'])
2050 self.assertEqual((a == scalar).names, ['N', 'C'])
2051 self.assertEqual((a != scalar).names, ['N', 'C'])
2052 self.assertEqual((a > scalar).names, ['N', 'C'])
2053 self.assertEqual((a < scalar).names, ['N', 'C'])
2054 self.assertEqual((a >= scalar).names, ['N', 'C'])
2055 self.assertEqual((a <= scalar).names, ['N', 'C'])
2059 self.assertEqual(res.names, ['N', 'C'])
2061 self.assertEqual(res.names, ['N', 'C'])
2063 self.assertEqual(res.names, ['N', 'C'])
2065 self.assertEqual(res.names, ['N', 'C'])
2067 self.assertEqual(res.names, ['N', 'C'])
2069 self.assertEqual(res.names, ['N', 'C'])
2072 self.assertEqual(res.names, ['N', 'C'])
2075 self.assertEqual(res.names, ['N', 'C'])
2081 named_tensor.names = ['N', 'C']
2082 named_tensor = torch.randn(3, 3, device='meta', names=['N', 'C'])