InputGen: introduce variable types (#2)

Summary:
Pull Request resolved: #2

This is the first in a stack of diffs aimed at landing InputGen, a test generation engine for pytorch ops

This diff introduces the most basic variable types that are generated. These are the building blocks for generating more complex structures. These variable types are:
- Bool (True or False)
- Int (any integral value)
- Float (any floating point value)
- String (any string)
- ScalarDtype (currently this can take only 3 values: bool, int or float)
- TensorDtype
- Tuple (any tuple of values)

Reviewed By: digantdesai

Differential Revision: D52047188

fbshipit-source-id: c8b06f71037433f89148fa70d95fa0c769c186ae

Author: manuelcandales

inputgen/variable/__init__.py

@@ -0,0 +1,89 @@
+import math
+from enum import Enum
+from typing import Any
+
+import torch
+
+
+class ScalarDtype(Enum):
+    bool = bool
+    int = int
+    float = float
+
+    def __lt__(self, other):
+        if self.__class__ is other.__class__:
+            order = [bool, int, float]
+            return order.index(self.value) < order.index(other.value)
+        return NotImplemented
+
+    def __str__(self):
+        return self.value.__name__
+
+
+SUPPORTED_TENSOR_DTYPES = [
+    torch.bool,
+    torch.uint8,
+    torch.int8,
+    torch.int16,
+    torch.int32,
+    torch.int64,
+    torch.float32,
+    torch.float64,
+    # The following types are not supported yet, but we should support them soon:
+    # torch.float16,
+    # torch.complex32,
+    # torch.complex64,
+    # torch.complex128,
+    # torch.bfloat16,
+]
+
+
+class VariableType(Enum):
+    """
+    These are the most basic variable types generated by Inputgen.
+    More complex structures can be created using these as building blocks.
+    """
+
+    Bool = bool
+    Int = int
+    Float = float
+    String = str
+    ScalarDtype = ScalarDtype
+    TensorDtype = torch.dtype
+    Tuple = tuple
+
+    @staticmethod
+    def contains(v: Any) -> bool:
+        return v in [member.value for member in VariableType]
+
+
+def invalid_vtype(vtype: type, v: Any) -> bool:
+    if v is None:
+        return False
+    if vtype in [bool, int, float]:
+        if type(v) not in [bool, int, float]:
+            return True
+    else:
+        if not isinstance(v, vtype):
+            return True
+    return False
+
+
+def is_integer(v: Any) -> bool:
+    if type(v) not in [bool, int, float]:
+        return False
+    if math.isnan(v) or not math.isfinite(v):
+        return False
+    return bool(int(v) == v)
+
+
+def convert_to_vtype(vtype: type, v: Any) -> Any:
+    if vtype == bool:
+        return bool(v)
+    if vtype == int:
+        if not is_integer(v):
+            return v
+        return int(v)
+    if vtype == float:
+        return float(v)
+    return v

inputgen/variable/type.py

@@ -0,0 +1,65 @@
+import unittest
+
+import torch
+from inputgen.variable.type import (
+    convert_to_vtype,
+    invalid_vtype,
+    is_integer,
+    ScalarDtype,
+    VariableType,
+)
+
+
+class TestVariableType(unittest.TestCase):
+    def test_variable_type(self):
+        self.assertEqual(VariableType.Bool.value, bool)
+        self.assertEqual(VariableType.Int.value, int)
+        self.assertEqual(VariableType.Float.value, float)
+        self.assertEqual(VariableType.String.value, str)
+        self.assertEqual(VariableType.Tuple.value, tuple)
+        self.assertEqual(VariableType.ScalarDtype.value, ScalarDtype)
+        self.assertEqual(VariableType.TensorDtype.value, torch.dtype)
+
+    def test_is_integer(self):
+        self.assertTrue(is_integer(1))
+        self.assertTrue(is_integer(5))
+        self.assertTrue(is_integer(-5))
+        self.assertTrue(is_integer(1.0))
+        self.assertTrue(is_integer(0.0))
+        self.assertTrue(is_integer(-3.0))
+        self.assertTrue(is_integer(True))
+        self.assertTrue(is_integer(False))
+        self.assertFalse(is_integer(3.5))
+        self.assertFalse(is_integer(float("inf")))
+        self.assertFalse(is_integer(float("-inf")))
+        self.assertFalse(is_integer(float("nan")))
+
+    def test_convert(self):
+        self.assertEqual(convert_to_vtype(VariableType.Bool.value, 1.0), True)
+        self.assertEqual(convert_to_vtype(VariableType.Int.value, False), 0)
+        self.assertEqual(convert_to_vtype(VariableType.Float.value, 3), 3.0)
+        self.assertEqual(
+            convert_to_vtype(VariableType.Int.value, float("inf")), float("inf")
+        )
+
+    def test_invalid_vtype(self):
+        self.assertFalse(invalid_vtype(VariableType.Bool.value, 1.0))
+        self.assertFalse(invalid_vtype(VariableType.Int.value, 1.0))
+        self.assertFalse(invalid_vtype(VariableType.Float.value, 1.0))
+        self.assertFalse(invalid_vtype(VariableType.String.value, "hello"))
+        self.assertFalse(invalid_vtype(VariableType.Tuple.value, (1, 2)))
+        self.assertFalse(
+            invalid_vtype(VariableType.ScalarDtype.value, ScalarDtype.bool)
+        )
+        self.assertFalse(invalid_vtype(VariableType.ScalarDtype.value, ScalarDtype.int))
+        self.assertFalse(
+            invalid_vtype(VariableType.ScalarDtype.value, ScalarDtype.float)
+        )
+        self.assertFalse(invalid_vtype(VariableType.TensorDtype.value, torch.bool))
+        self.assertTrue(invalid_vtype(VariableType.Float.value, "1.0"))
+        self.assertTrue(invalid_vtype(VariableType.String.value, 1))
+        self.assertTrue(invalid_vtype(VariableType.ScalarDtype.value, torch.int8))
+
+
+if __name__ == "__main__":
+    unittest.main()