1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
|
def forward(self, input):
return None
def eqBool(self, input: bool) -> bool:
return input
def eqInt(self, input: int) -> int:
return input
def eqFloat(self, input: float) -> float:
return input
def eqStr(self, input: str) -> str:
return input
def eqTensor(self, input: Tensor) -> Tensor:
return input
def eqDictStrKeyIntValue(self, input: Dict[str, int]) -> Dict[str, int]:
return input
def eqDictIntKeyIntValue(self, input: Dict[int, int]) -> Dict[int, int]:
return input
def eqDictFloatKeyIntValue(self, input: Dict[float, int]) -> Dict[float, int]:
return input
def listIntSumReturnTuple(self, input: List[int]) -> Tuple[List[int], int]:
sum = 0
for x in input:
sum += x
return (input, sum)
def listBoolConjunction(self, input: List[bool]) -> bool:
res = True
for x in input:
res = res and x
return res
def listBoolDisjunction(self, input: List[bool]) -> bool:
res = False
for x in input:
res = res or x
return res
def tupleIntSumReturnTuple(self, input: Tuple[int, int, int]) -> Tuple[Tuple[int, int, int], int]:
sum = 0
for x in input:
sum += x
return (input, sum)
def optionalIntIsNone(self, input: Optional[int]) -> bool:
return input is None
def intEq0None(self, input: int) -> Optional[int]:
if input == 0:
return None
return input
def str3Concat(self, input: str) -> str:
return input + input + input
def newEmptyShapeWithItem(self, input):
return torch.tensor([int(input.item())])[0]
def testAliasWithOffset(self) -> List[Tensor]:
x = torch.tensor([100, 200])
a = [x[0], x[1]]
return a
def testNonContiguous(self):
x = torch.tensor([100, 200, 300])[::2]
assert not x.is_contiguous()
assert x[0] == 100
assert x[1] == 300
return x
def conv2d(self, x: Tensor, w: Tensor, toChannelsLast: bool) -> Tensor:
r = torch.conv2d(x, w)
if (toChannelsLast):
# memory_format=torch.channels_last
r = r.contiguous(memory_format=2)
else:
r = r.contiguous()
return r
def contiguous(self, x: Tensor) -> Tensor:
return x.contiguous()
def contiguousChannelsLast(self, x: Tensor) -> Tensor:
# memory_format=torch.channels_last
return x.contiguous(memory_format=2)
def contiguousChannelsLast3d(self, x: Tensor) -> Tensor:
# memory_format=torch.channels_last_3d
return x.contiguous(memory_format=3)
|
