add ABAB; add __info__ string & help()

automata.py

@@ -59,8 +59,8 @@ class SyntheticAutomataDataset(datasets.GeneratorBasedBuilder):
         """
         if 'name' not in config:
             config['name'] = 'parity'
-        if 'length' not in config: # sequence length
-            config['length'] = 20
+        # if 'length' not in config: # sequence length
+        #     config['length'] = 20
         if 'size' not in config: # number of sequences
             config['size'] = -1
 
@@ -113,8 +113,12 @@ class AutomatonSampler:
         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']
 
+        self.__info__ = "  - T (int): sequence length"
+
     def f(self, x):
         """
         Get output sequence given an input seq
@@ -124,6 +128,9 @@ class AutomatonSampler:
     def sample(self):
         raise NotImplementedError()
 
+    def help(self):
+        print(self.__info__)
+
 
 class BinaryInputSampler(AutomatonSampler):
     def __init__(self, data_config):
@@ -132,6 +139,8 @@ class BinaryInputSampler(AutomatonSampler):
         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()
@@ -145,6 +154,12 @@ class ParitySampler(BinaryInputSampler):
     super().__init__(data_config)
     self.name = 'parity'
 
+    self.__info__ = "Parity machine with 2 states: \n" \
+        + "- Inputs: binary strings\n" \
+        + "- Labels: binary strings of the partial parity\n" \
+        + "- Config: \n" \
+        + self.__info__
+
   def f(self, x):
     return np.cumsum(x) % 2
 
@@ -164,8 +179,25 @@ class GridworldSampler(BinaryInputSampler):
     self.n = data_config['n'] 
     self.S = self.n - 1
 
+    if 'label_type' not in data_config:
+      # Options: state, parity, boundary
+      data_config['label_type'] = 'state'
+    self.label_type = data_config['label_type']
+
     self.name = f'Grid{self.n}'
 
+    self.__info__ = f"1d Gridworld of n={self.n} states:\n" \
+        + "- Inputs: binary strings, i.e. move left(0) or right(1)\n" \
+        + "- Labels: depending on 'label_type'. \n" \
+        + "- Config: \n" \
+        + "  - n (int): number of states; i.e. the states are 0,1,2,...,n-1.\n" \
+        + "  - label_type (str): choosing from the following options:\n" \
+        + "    - 'state' (default): the state id, i.e. 0 to n-1.\n" \
+        + "    - 'parity': the state id mod 2.\n" \
+        + "    - 'boundary': whether the current state is in {0, n-1} or not.\n" \
+        + self.__info__
+
+
   def f(self, x):
     x = copy(x)
     x[x == 0] = -1
@@ -179,33 +211,95 @@ 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)
+    self.name = 'abab'
+
+    if 'prob_abab_pos_sample' not in data_config:
+      # The probability of having a positive sequence, i.e. 010101010101...
+      data_config['prob_abab_pos_sample'] = 0.25
+    if 'label_type' not in data_config:
+      # Options: 'state', 'boundary'
+      data_config['label_type'] = 'state'
+
+    self.prob_abab_pos_sample = data_config['prob_abab_pos_sample']
+    self.label_type = data_config['label_type']
+
+    self.transition = np.array(
+      [[4, 1], # state 0
+       [2, 4], # state 1
+       [4, 3], # state 2
+       [0, 4], # state 3
+       [4, 4], # state 4
+       ])
+
+    self.__info__ = "abab: an automaton with 4 states + 1 absorbing state:\n" \
+        + "- Inputs: binary strings\n" \
+        + "- Labels: depending on 'label_type'.\n" \
+        + "- Config:\n" \
+        + "  - prob_abab_pos_sample (float in [0,1]): probability of having a 'positive' sequence, i.e. 01010101010...\n" \
+        + "  - label_type (str): choosing from the following options:\n" \
+        + "    - 'state' (default): the state id.\n" \
+        + "    - 'boundary': whether the state is in state 3 (the states are 0,1,2,3).\n" \
+        + self.__info__ 
+
+  def f(self, x):
+    labels = []
+    curr_state = 3
+    for each in x:
+      curr_state = self.transition[curr_state, each]
+      labels += curr_state,
+    labels = np.array(labels).astype(np.int64)
+    if self.label_type == 'boundary':
+      labels = (labels == 3).astype(np.int64)
+    return labels
+
+  def sample(self):
+    pos_sample = np.random.random() < self.prob_abab_pos_sample
+    if pos_sample:
+      x = [0,1,0,1] * (self.T//4)
+      x += [0,1,0,1][:(self.T%4)]
+      x = np.array(x)
+      return x, self.f(x)
+    else:
+      return super().sample()
+
+
 
 
 class FlipFlopSampler(AutomatonSampler):
-    def __init__(self, data_config):
-        super().__init__(data_config)
-        self.name = 'flipflop'
+  def __init__(self, data_config):
+    super().__init__(data_config)
+    self.name = 'flipflop'
 
-        if 'n' not in data_config:
-            data_config['n'] = 2
-        
-        self.n_states = data_config['n'] 
-        self.n_actions = self.n_states + 1
-        self.transition = np.array([list(range(self.n_actions))] + [[i+1]*self.n_actions for i in range(self.n_states)]).T
+    if 'n' not in data_config:
+        data_config['n'] = 2
+    
+    self.n_states = data_config['n'] 
+    self.n_actions = self.n_states + 1
+    self.transition = np.array([list(range(self.n_actions))] + [[i+1]*self.n_actions for i in range(self.n_states)]).T
 
-    def f(self, x):
-        state, states = 0, []
-        for action in x:
-            state = self.transition[state, action]
-            states += state,
-        return np.array(states)
+    self.__info__ = f"Flipflop with n={self.n_states} states:\n" \
+        +f"- Inputs: tokens are either 0 (read) or 1:{self.n} (write).\n" \
+        + "- Labels: depending on 'label_type'.\n" \
+        + "- Config:\n" \
+        + "  - n (int): number of write states; i.e. the states are 1,2,...,n, plus a default start state 0.\n" \
+        + self.__info__ 
 
-    def sample(self):
-        rand = np.random.uniform(size=self.T)
-        nonzero_pos = (rand < 0.5).astype(np.int64)
-        writes = np.random.choice(range(1, self.n_states+1), size=self.T)
-        x = writes * nonzero_pos
-        return x, self.f(x)
+  def f(self, x):
+    state, states = 0, []
+    for action in x:
+        state = self.transition[state, action]
+        states += state,
+    return np.array(states)
+
+  def sample(self):
+    rand = np.random.uniform(size=self.T)
+    nonzero_pos = (rand < 0.5).astype(np.int64)
+    writes = np.random.choice(range(1, self.n_states+1), size=self.T)
+    x = writes * nonzero_pos
+    return x, self.f(x)
 
 
 class SymmetricSampler(AutomatonSampler):
@@ -265,6 +359,18 @@ class SymmetricSampler(AutomatonSampler):
         cnt += 1
         if cnt == self.n_actions: break
 
+    self.__info__ = f"Symmetric group on n={self.n} objects:\n" \
+        +f"- Inputs: tokens are either 0 (no-op), or 1:{self.n_actions} (corresponding to {self.n_actions} permutations).\n" \
+        + "- Labels: depending on 'label_type'.\n" \
+        + "- Config:\n" \
+        + "  - n (int): number of objects, i.e. there are n! states.\n" \
+        + "  - label_type (str): choosing from the following options:\n" \
+        + "    - 'state' (default): the state id.\n" \
+        + "    - 'first_chair': the element in the first position of the permutation.\n" \
+        + "          e.g. if the current permutation is [2,3,1,4], then 'first_chair' is 2.\n" \
+        + self.__info__ 
+
+
   def get_state_label(self, state):
     enc = self.state_encode(state)
     return self.state_label_map[enc]
@@ -289,6 +395,7 @@ class SymmetricSampler(AutomatonSampler):
 
 
 dataset_map = {
+  'abab': ABABSampler,
   'gridworld': GridworldSampler,
   'flipflop': FlipFlopSampler,
   'parity': ParitySampler,