add cyclic groups; fix random seeds (should use self.np_rng, otherwise the seed is not fixed)

automata.py

@@ -103,60 +103,69 @@ class SyntheticAutomataDataset(datasets.GeneratorBasedBuilder):
 
 
 class AutomatonSampler:
-    def __init__(self, data_config):
-        self.data_config = data_config
+  """
+  This is a parent class that must be inherited.
+  """
+  def __init__(self, data_config):
+      self.data_config = data_config
 
-        if 'seed' in self.data_config:
-            self.np_rng = np.random.default_rng(self.data_config['seed'])
-        else:
-            self.np_rng = np.random.default_rng()
+      if 'seed' in self.data_config:
+          self.np_rng = np.random.default_rng(self.data_config['seed'])
+      else:
+          self.np_rng = np.random.default_rng()
 
-        if 'length' not in data_config: # sequence length
-            data_config['length'] = 20
-        self.T = self.data_config['length']
+      if 'length' not in data_config: # sequence length
+          data_config['length'] = 20
+      self.T = self.data_config['length']
 
-        if 'random_length' not in data_config:
-            data_config['random_length'] = 0
-        self.random_length = data_config['random_length']
+      if 'random_length' not in data_config:
+          data_config['random_length'] = 0
+      self.random_length = data_config['random_length']
 
-        self.__info__ = "  - T (int): sequence length.\n" \
-            + "  - random_length (int in {0, 1}): whether to randomly sample a length per sample.\n"
+      self.__info__ = "  - T (int): sequence length.\n" \
+          + "  - random_length (int in {0, 1}): whether to randomly sample a length per sample.\n"
 
-    def f(self, x):
-        """
-        Get output sequence given an input seq
-        """
-        raise NotImplementedError()
+  def f(self, x):
+      """
+      Get output sequence given an input seq
+      """
+      raise NotImplementedError()
 
-    def sample(self):
-        raise NotImplementedError()
+  def sample(self):
+      raise NotImplementedError()
 
-    def sample_length(self):
-        if self.random_length:
-          return self.np_rng.choice(range(1, self.T+1))
-        return self.T
+  def sample_length(self):
+      if self.random_length:
+        return self.np_rng.choice(range(1, self.T+1))
+      return self.T
 
-    def help(self):
+  def help(self):
         print(self.__info__)
 
 
+
+
 class BinaryInputSampler(AutomatonSampler):
-    def __init__(self, data_config):
-        super().__init__(data_config)
+  """
+  This is a parent class that must be inherited.
+  Subclasses: ParitySampler, GridworldSampler, ABABSampler
+  """
+  def __init__(self, data_config):
+    super().__init__(data_config)
 
-        if 'prob1' not in data_config:
-          data_config['prob1'] = 0.5
-        self.prob1 = data_config['prob1']
-        self.__info__ = "  - prob1 (float in [0,1]): probability of token 1\n" \
-             + self.__info__
+    if 'prob1' not in data_config:
+      data_config['prob1'] = 0.5
+    self.prob1 = data_config['prob1']
+    self.__info__ = "  - prob1 (float in [0,1]): probability of token 1\n" \
+         + self.__info__
 
-    def f(self, x):
-        raise NotImplementedError()
+  def f(self, x):
+    raise NotImplementedError()
 
-    def sample(self):
-        T = self.sample_length()
-        x = self.np_rng.binomial(1, self.prob1, size=T)
-        return x, self.f(x)
+  def sample(self):
+    T = self.sample_length()
+    x = self.np_rng.binomial(1, self.prob1, size=T)
+    return x, self.f(x)
 
 class ParitySampler(BinaryInputSampler):
   def __init__(self, data_config):
@@ -220,6 +229,7 @@ class GridworldSampler(BinaryInputSampler):
       states = states[1:] # remove the 1st entry with is the (meaningless) initial value 0
     return np.array(states).astype(np.int64)
 
+
 class ABABSampler(BinaryInputSampler):
   def __init__(self, data_config):
     super().__init__(data_config)
@@ -265,7 +275,7 @@ class ABABSampler(BinaryInputSampler):
     return labels
 
   def sample(self):
-    pos_sample = np.random.random() < self.prob_abab_pos_sample
+    pos_sample = self.np_rng.random() < self.prob_abab_pos_sample
     if pos_sample:
       T = self.sample_length()
       x = [0,1,0,1] * (T//4)
@@ -299,23 +309,25 @@ class FlipFlopSampler(AutomatonSampler):
 
   def f(self, x):
     state, states = 0, []
-    for action in x:
-        state = self.transition[state, action]
+    for action_id in x:
+        state = self.transition[state, action_id]
         states += state,
     return np.array(states)
 
   def sample(self):
     T = self.sample_length()
-    rand = np.random.uniform(size=T)
+    rand = self.np_rng.uniform(size=T)
     nonzero_pos = (rand < 0.5).astype(np.int64)
-    writes = np.random.choice(range(1, self.n_states+1), size=T)
+    writes = self.np_rng.choice(range(1, self.n_states+1), size=T)
     x = writes * nonzero_pos
     return x, self.f(x)
 
 
 
+
 class PermutationSampler(AutomatonSampler):
   """
+  This is a parent class that must be inherited.
   Subclasses: SymmetricSampler, AlternatingSampler
   """
   def __init__(self, data_config):
@@ -344,8 +356,8 @@ class PermutationSampler(AutomatonSampler):
   def f(self, x):
     curr_state = np.arange(self.n)
     labels = []
-    for action in x:
-      curr_state = self.actions[action].dot(curr_state)
+    for action_id in x:
+      curr_state = self.actions[action_id].dot(curr_state)
 
       if self.label_type == 'state':
         labels += self.get_state_label(curr_state),
@@ -356,7 +368,7 @@ class PermutationSampler(AutomatonSampler):
 
   def sample(self):
     T = self.sample_length()
-    x = np.random.choice(range(self.n_actions), replace=True, size=T)
+    x = self.np_rng.choice(range(self.n_actions), replace=True, size=T)
 
     return x, self.f(x)
 
@@ -462,13 +474,55 @@ class AlternatingSampler(PermutationSampler):
 
 
 
+class CyclicSampler(AutomatonSampler):
+  def __init__(self, data_config):
+    super().__init__(data_config)
+
+    if 'n' not in data_config:
+      data_config['n'] = 5
+    self.n = data_config['n']
+
+    """
+    Get actions: shift by i positions, for i = 0 to n_actions-1
+    """
+    if 'n_actions' not in data_config:
+      data_config['n_actions'] = 2
+    self.n_actions = data_config['n_actions']
+    shift_idx = list(range(1, self.n)) + [0]
+    self.actions = {}
+    for i in range(self.n_actions):
+      shift_idx = list(range(i, self.n)) + list(range(0, i))
+      self.actions[i] = np.eye(self.n)[shift_idx]
+
+
+  def f(self, x):
+    if OLD_PY_VERSION:
+      # NOTE: for Python 3.7 or below, accumulate doesn't have the 'initial' argument.
+      x_padded = np.concatenate([np.array([0]), x]).astype(np.int64)
+      states = list(itertools.accumulate(x_padded, lambda a,b: (a+b)%self.n ))
+      states = states[1:]
+    else:
+      states = list(itertools.accumulate(x, lambda a,b: (a+b)%self.n, initial=0))
+      states = states[1:] # remove the 1st entry with is the (meaningless) initial value 0
+
+    return np.array(states).astype(np.int64)
+
+  def sample(self):
+    T = self.sample_length()
+    x = self.np_rng.choice(range(self.n_actions), replace=True, size=T)
+
+    return x, self.f(x)
+
+
 
 dataset_map = {
   'abab': ABABSampler,
   'alternating': AlternatingSampler,
-  'gridworld': GridworldSampler,
+  'cyclic': CyclicSampler,
   'flipflop': FlipFlopSampler,
+  'gridworld': GridworldSampler,
   'parity': ParitySampler,
   'symmetric': SymmetricSampler,
   # TODO: more datasets
   }
+