# 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 }