add AdderSampler

automata.py

@@ -150,6 +150,8 @@ class BinaryInputSampler(AutomatonSampler):
   """
   This is a parent class that must be inherited.
   Subclasses: ParitySampler, GridworldSampler, ABABSampler
+
+  TODO: sample sequences with a given number of 1s
   """
   def __init__(self, data_config):
     super().__init__(data_config)
@@ -287,6 +289,65 @@ class ABABSampler(BinaryInputSampler):
       return super().sample()
 
 
+class AdderSampler(BinaryInputSampler):
+  def __init__(self, data_config):
+    super().__init__(data_config)
+    self.name = 'addition'
+
+    if 'n_addends' not in data_config:
+      data_config['n_addends'] = 2
+    self.n_addends = data_config['n_addends']
+    self.addend_scales = np.array([2**i for i in range(self.n_addends)]).reshape(-1, 1)
+
+    if 'label_type' not in data_config:
+      data_config['label_type'] = 'state'
+    self.label_type = data_config['label_type']
+
+    self.__info__ = f'Adder of n={self.n_addends} binary numbers:\n' \
+        +f"- Inputs: {self.n_addends} binary numbers, encoded as the int for the {self.n_addends}-bit binary number.\n" \
+        + "- Labels: depending on the label_type.\n" \
+        + "- Config:\n" \
+        + "  - n_addends (int): number of binary numbers to be added; default as 2.\n" \
+        + "  - label_type (str): choosing from the following options: \n" \
+        +f"    - 'state': the state id, i.e. the int for the base-{self.n_addends} int corresponding to the number (carry, digit). \n" \
+        +f"    - 'digit': the current output base-{self.n_addends} digit, without the carry. \n" \
+        + "    - 'position': the current carry bit.\n" \
+        + self.__info__
+
+
+  def f(self, x):
+    outputs, carries = [], []
+    carry = 0
+    T = x.shape[-1]
+    for i in range(T):
+      curr_sum = x[:, i].sum() + carry
+      # NOTE: 'mod n_addends' makes sure the carry is binary
+      output, carry = curr_sum % self.n_addends, curr_sum // self.n_addends
+      outputs += output,
+      carries += carry,
+    outputs = np.array(outputs).astype(np.int64)
+    carries = np.array(carries).astype(np.int64)
+
+    if self.label_type == 'state':
+      return outputs + self.n_addends*carries
+    elif self.label_type ==  'digit':
+      return outputs
+    elif self.label_type == 'carry':
+      return carries
+
+  def sample_addend(self, T):
+    a = self.np_rng.binomial(1, self.prob1, size=T)
+    return a
+
+  def sample(self):
+    T = self.sample_length()
+    x = np.stack([self.sample_addend(T) for _ in range(self.n_addends)])
+    # Pad the most significant bit (rightmost position, i.e. we're reversing the number) with 0 to handle the potential carry
+    pad = np.zeros((self.n_addends, 1))
+    x = np.concatenate([x, pad], 1)
+
+    x_encode = (self.addend_scales * x).sum(0)
+    return x_encode, self.f(x)
 
 
 class FlipFlopSampler(AutomatonSampler):
@@ -303,7 +364,7 @@ class FlipFlopSampler(AutomatonSampler):
 
     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" \
+        + "- Labels: the state id.\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__ 
@@ -638,8 +699,13 @@ class QuaternionSampler(AutomatonSampler):
     return x, self.f(x)
 
 
+
+
+
+
 dataset_map = {
   'abab': ABABSampler,
+  'add': AdderSampler,
   'alternating': AlternatingSampler,
   'cyclic': CyclicSampler,
   'dihedral': DihedralSampler,
@@ -648,6 +714,6 @@ dataset_map = {
   'parity': ParitySampler,
   'quaternion': QuaternionSampler,
   'symmetric': SymmetricSampler,
-  # TODO: more datasets
+  # TODO: add Dyck
   }