automata.py

# Copyright 2020 The HuggingFace Datasets Authors.
# Copyright 2023 Bingbin Liu, Jordan Ash, Surbhi Goel, Akshay Krishnamurthy, and Cyril Zhang.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


import csv
import json
import os
import itertools

import datasets
import numpy as np

# Local imports
# from symmetric import SymmetricSampler

_CITATION = """\
"""

_DESCRIPTION = """\
Online dataset mockup.
"""

_HOMEPAGE = ""

_LICENSE = ""

_URLS = {}

class SyntheticAutomataDataset(datasets.GeneratorBasedBuilder):
    """TODO: Short description of my dataset."""

    VERSION = datasets.Version("0.0.0")
    BUILDER_CONFIGS = []
    
    def __init__(self, config={}, **kwargs):
        super().__init__(**kwargs)
        
        """
        Set default configs
        """
        if 'name' not in config:
            config['name'] = 'parity'
        if 'length' not in config:
            config['length'] = 20
        if 'size' not in config:
            config['size'] = -1

        self.data_config = config
        self.sampler = dataset_map[config['name']](config)

    def _info(self):
        features = datasets.Features(
            {
                "input_ids": datasets.Sequence(datasets.Value("int32"), length=-1),
                "label_ids": datasets.Sequence(datasets.Value("int32"), length=-1)
            }
        )

        return datasets.DatasetInfo(
            description=_DESCRIPTION,
            features=features,
            homepage=_HOMEPAGE,
            license=_LICENSE,
            citation=_CITATION,
        )

    def _split_generators(self, dl_manager):
        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "split": "train",
                },
            )
        ]

    def _generate_examples(self, split):
        for i in itertools.count(start=0):
            if i == self.data_config['size']:
                break
            x, y = self.sampler.sample()
            yield i, {
                "input_ids": x,
                "label_ids": y
            }


class AutomatonSampler:
    def __init__(self, data_config):
        # self.name = name
        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()

        self.T = self.data_config['length']

    def f(self, x):
        """
        Get output sequence given an input seq
        """
        raise NotImplementedError()

    def sample(self):
        raise NotImplementedError()


class ParitySampler(AutomatonSampler):
    def __init__(self, data_config):
        super().__init__(data_config)
        self.name = 'parity'
        self.data_config = data_config

    def f(self, x):
        return np.cumsum(x) % 2

    def sample(self):
        x = self.np_rng.binomial(1,0.5,size=self.T)
        return x, self.f(x)


class FlipFlopSampler(AutomatonSampler):
    def __init__(self, data_config):
        super().__init__(data_config)
        self.name = 'flipflop'
        self.data_config = data_config

        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)

    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):
  """
  TODO: add options for labels as functions of states
  - parity (whether a state is even): this may need packages (e.g. Permutation from sympy)
  - position / toggle: for S3 ~ D6, we can add labels for substructures as in Dihedral groups.
  """
  def __init__(self, data_config):
    super().__init__(data_config)
    self.name = 'symmetric'
    self.data_config = data_config

    if 'n' not in data_config:
      data_config['n'] = 5 # Default to S5
    if 'n_actions' not in data_config:
      data_config['n_actions'] = 3
    if 'label_type' not in data_config:
      # Options: 'state', 'first_chair'
      data_config['label_type'] = 'state'
    
    self.n = data_config['n']
    self.label_type = data_config['label_type']

    """
    Get states
    """
    self.state_encode = lambda state: ''.join([str(int(each)) for each in state])
    self.state_label_map = {}
    for si, state in enumerate(itertools.permutations(range(self.n))):
      enc = self.state_encode(state)
      self.state_label_map[enc] = si

    """
    Get actions (3 defaults: id, shift-by-1, swap-first-two)
    """
    self.n_actions = data_config['n_actions']
    self.actions = {0: np.eye(self.n)}
    # shift all elements to the right by 1
    shift_idx = list(range(1, self.n)) + [0]
    self.actions[1] = np.eye(self.n)[shift_idx]
    # swap the first 2 elements
    shift_idx = [1, 0] + list(range(2, self.n))
    self.actions[2] = np.eye(self.n)[shift_idx]

    if self.n_actions > 3:
      # add permutations in the order given by itertools.permutations
      self.all_permutations = list(itertools.permutations(range(self.n)))[1:]
      cnt = 2
      for each in self.all_permutations:
        action = np.eye(self.n)[list(each)]
        if np.linalg.norm(action - self.actions[0]) == 0:
          continue
        elif np.linalg.norm(action - self.actions[1]) == 0:
          continue
        self.actions[cnt] = action
        cnt += 1
        if cnt == self.n_actions: break

  def get_state_label(self, state):
    enc = self.state_encode(state)
    return self.state_label_map[enc]

  def f(self, x):
    curr_state = np.arange(self.n)
    labels = []
    for action in x:
      curr_state = self.actions[action].dot(curr_state)

      if self.label_type == 'state':
        labels += self.get_state_label(curr_state),
      elif self.label_type == 'first_chair':
        labels += curr_state[0],

    return np.array(labels)

  def sample(self):
    x = np.random.choice(range(self.n_actions), replace=True, size=self.T)

    return x, self.f(x)


dataset_map = {
  'parity': ParitySampler,
  'flipflop': FlipFlopSampler,
  'symmetric': SymmetricSampler,
  # TODO: more datasets
  }