Upload processor

processing_action_tokenizer.py

@@ -1,8 +1,9 @@
 import logging
-from typing import ClassVar, Iterator
+from typing import ClassVar
 
 import numpy as np
-from scipy.fft import dct, idct
+from scipy.fft import dct
+from scipy.fft import idct
 from tokenizers import ByteLevelBPETokenizer
 from tokenizers.trainers import BpeTrainer
 from transformers import PreTrainedTokenizerFast
@@ -40,9 +41,7 @@ class UniversalActionProcessor(ProcessorMixin):
         super().__init__(bpe_tokenizer)
 
     def __call__(self, action_chunk: np.array) -> np.array:
-        assert action_chunk.ndim <= 3, (
-            "Only 3 dimensions supported: [batch, timesteps, action_dim]"
-        )
+        assert action_chunk.ndim <= 3, "Only 3 dimensions supported: [batch, timesteps, action_dim]"
         if action_chunk.ndim == 2:
             action_chunk = action_chunk[None, ...]
 
@@ -54,9 +53,7 @@ class UniversalActionProcessor(ProcessorMixin):
         dct_coeff = np.around(dct_coeff * self.scale)
         tokens = []
         for elem in dct_coeff:
-            token_str = "".join(
-                map(chr, np.maximum(elem.flatten() - self.min_token, 0).astype(int))
-            )
+            token_str = "".join(map(chr, np.maximum(elem.flatten() - self.min_token, 0).astype(int)))
             tokens.append(self.bpe_tokenizer(token_str)["input_ids"])
         return tokens
 
@@ -67,46 +64,41 @@ class UniversalActionProcessor(ProcessorMixin):
         time_horizon: int | None = None,
         action_dim: int | None = None,
     ) -> np.array:
-        self.time_horizon = (
-            time_horizon or self.time_horizon or self.called_time_horizon
-        )
+        self.time_horizon = time_horizon or self.time_horizon or self.called_time_horizon
         self.action_dim = action_dim or self.action_dim or self.called_action_dim
 
         # Cache the time horizon and action dimension for the next call
         self.called_time_horizon = self.time_horizon
         self.called_action_dim = self.action_dim
 
-        assert self.time_horizon is not None and self.action_dim is not None, (
-            "Tokenizer not initialized, call encode() once or pass in time_horizon and action_dim."
-        )
+        assert (
+            self.time_horizon is not None and self.action_dim is not None
+        ), "Tokenizer not initialized, call encode() once or pass in time_horizon and action_dim."
 
         decoded_actions = []
         for token in tokens:
             try:
                 decoded_tokens = self.bpe_tokenizer.decode(token)
-                decoded_dct_coeff = (
-                    np.array(list(map(ord, decoded_tokens))) + self.min_token
-                )
+                decoded_dct_coeff = np.array(list(map(ord, decoded_tokens))) + self.min_token
                 decoded_dct_coeff = decoded_dct_coeff.reshape(-1, self.action_dim)
-                assert decoded_dct_coeff.shape == (
-                    self.time_horizon,
-                    self.action_dim,
-                ), (
-                    f"Decoded DCT coefficients have shape {decoded_dct_coeff.shape}, expected ({self.time_horizon}, {self.action_dim})"
-                )
+                assert (
+                    decoded_dct_coeff.shape
+                    == (
+                        self.time_horizon,
+                        self.action_dim,
+                    )
+                ), f"Decoded DCT coefficients have shape {decoded_dct_coeff.shape}, expected ({self.time_horizon}, {self.action_dim})"
             except Exception as e:
                 print(f"Error decoding tokens: {e}")
                 print(f"Tokens: {token}")
                 decoded_dct_coeff = np.zeros((self.time_horizon, self.action_dim))
-            decoded_actions.append(
-                idct(decoded_dct_coeff / self.scale, axis=0, norm="ortho")
-            )
+            decoded_actions.append(idct(decoded_dct_coeff / self.scale, axis=0, norm="ortho"))
         return np.stack(decoded_actions)
 
     @classmethod
     def fit(
         cls,
-        action_data: Iterator[np.array],
+        action_data: list[np.array],
         scale: float = 10,
         vocab_size: int = 1024,
         *,
@@ -114,27 +106,16 @@ class UniversalActionProcessor(ProcessorMixin):
         action_dim: int | None = None,
     ) -> "UniversalActionProcessor":
         # Run DCT over all inputs
-        print("Running DCT over all inputs")
-
-        def _convert_dct(tokens: np.array) -> np.array:
-            tokens = dct(tokens, axis=0, norm="ortho").flatten()
-            tokens = np.around(tokens * scale)
-            return tokens
-        dct_tokens = [_convert_dct(a) for a in action_data]
-        # dct_tokens = [dct(a, axis=0, norm="ortho").flatten() for a in action_data]
-        # # dct_tokens_rounded = np.around(np.concatenate(dct_tokens) * scale)
-        # dct_tokens_rounded = [np.around(tokens * scale) for tokens in dct_tokens]
-        print("Converted actions to DCT tokens")
+        dct_tokens = [dct(a, axis=0, norm="ortho").flatten() for a in action_data]
 
         # Quantize and find min token
-        max_token = int(max([tokens.max() for tokens in dct_tokens]))
-        min_token = int(min([tokens.min() for tokens in dct_tokens]))
+        max_token = int(np.around(np.concatenate(dct_tokens) * scale).max())
+        min_token = int(np.around(np.concatenate(dct_tokens) * scale).min())
         min_vocab_size = max_token - min_token
-        print("Found min and max tokens: ", min_token, max_token)
 
-        assert min_vocab_size <= vocab_size, (
-            f"Vocab size {vocab_size} is too small for the range of tokens {min_vocab_size}"
-        )
+        assert (
+            min_vocab_size <= vocab_size
+        ), f"Vocab size {vocab_size} is too small for the range of tokens {min_vocab_size}"
         if min_vocab_size + 100 > vocab_size:
             logging.warning(
                 f"Initial alphabet size {min_vocab_size} is almost as large as the vocab"
@@ -142,17 +123,16 @@ class UniversalActionProcessor(ProcessorMixin):
             )
 
         # Make token iterator for BPE training
-        comp_tokens = []
-        while dct_tokens:
-            tokens = dct_tokens.pop()
-            rounded_tokens = tokens - min_token
-            rounded_tokens = rounded_tokens.astype(int)
-            string = "".join(map(chr, rounded_tokens))
-            comp_tokens.append(string)
-        print("Stringified DCT tokens")
+        def _token_iter():
+            for tokens in dct_tokens:
+                rounded_tokens = np.around(tokens * scale) - min_token
+                rounded_tokens = rounded_tokens.astype(int)
+                string = "".join(map(chr, rounded_tokens))
+                yield string
 
         # Train BPE tokenizer
         bpe = ByteLevelBPETokenizer()
+
         # Set up the entire range of possible tokens as the initial alphabet
         alphabet = [chr(i) for i in range(max_token - min_token + 1)]
         trainer = BpeTrainer(
@@ -163,21 +143,13 @@ class UniversalActionProcessor(ProcessorMixin):
             initial_alphabet=alphabet,
             max_token_length=10000,
         )
-        print("Started training BPE tokenizer")
-
-        def _token_iter():
-            while comp_tokens:
-                yield comp_tokens.pop()
 
         # Train the inner tokenizer (don't use ByteLevelBPETokenizer.train_from_iterator()
         # because it doesn't support custom alphabets)
-        bpe._tokenizer.train_from_iterator(_token_iter(), trainer=trainer, length=len(dct_tokens))
-        print("Trained BPE tokenizer")
+        bpe._tokenizer.train_from_iterator(_token_iter(), trainer=trainer)
 
         return cls(
-            PreTrainedTokenizerFast(
-                tokenizer_object=bpe, clean_up_tokenization_spaces=False
-            ),
+            PreTrainedTokenizerFast(tokenizer_object=bpe, clean_up_tokenization_spaces=False),
             scale=scale,
             vocab_size=vocab_size,
             min_token=min_token,

processor_config.json

@@ -3,7 +3,7 @@
   "auto_map": {
     "AutoProcessor": "processing_action_tokenizer.UniversalActionProcessor"
   },
-  "min_token": -27,
+  "min_token": -519,
   "processor_class": "UniversalActionProcessor",
   "scale": 10,
   "time_horizon": null,