Tokenizer.md

SELFIES Tokenizer Documentation

Overview

This tokenizer is designed specifically for SELFIES (Self-Referencing Embedded Strings) chemical structure notation. It provides a simple mapping between SELFIES tokens and their corresponding IDs for machine learning applications.

File Format

The tokenizer configuration is stored in a JSON file with the following structure:

{
  "vocab": {
    "[UNK]": 0,
    "[CLS]": 1,
    "[SEP]": 2,
    "[PAD]": 3,
    "[MASK]": 4,
    // ... chemical tokens ...
  },
  "special_tokens": {
    "unk_token": "[UNK]",
    "cls_token": "[CLS]",
    "sep_token": "[SEP]",
    "pad_token": "[PAD]",
    "mask_token": "[MASK]"
  },
  "model_max_length": 512
}

Special Tokens

• [UNK]: Used for unknown tokens (ID: 0)
• [CLS]: Classification token, added at start of sequence (ID: 1)
• [SEP]: Separator token, added at end of sequence (ID: 2)
• [PAD]: Padding token (ID: 3)
• [MASK]: Masking token for masked language modeling (ID: 4)

Tokenization Process

Since SELFIES strings are already tokenized by design, the process is straightforward:

1. Split the SELFIES string into tokens (they are naturally delimited by [])
2. Convert each token to its corresponding ID using the vocab mapping
3. Add special tokens as needed ([CLS] at start, [SEP] at end)
4. Pad/truncate to model_max_length if necessary

Example implementation:

import re

class SelfiesTokenizer:
    def __init__(self, tokenizer_path):
        with open(tokenizer_path, 'r') as f:
            config = json.load(f)
        self.vocab = config['vocab']
        self.special_tokens = config['special_tokens']
        self.max_length = config['model_max_length']
        # Create reverse mapping (id -> token) for decoding
        self.id2token = {v: k for k, v in self.vocab.items()}
    
    def tokenize(self, selfies_string):
        """Split SELFIES string into tokens"""
        return re.findall(r'\[.*?\]', selfies_string)
    
    def convert_tokens_to_ids(self, tokens):
        """Convert tokens to their IDs"""
        return [self.vocab.get(token, self.vocab['[UNK]']) for token in tokens]
    
    def encode(self, selfies_string, add_special_tokens=True):
        """Full encoding process"""
        tokens = self.tokenize(selfies_string)
        ids = self.convert_tokens_to_ids(tokens)
        
        if add_special_tokens:
            ids = [self.vocab['[CLS]']] + ids + [self.vocab['[SEP]']]
        
        # Truncate or pad as needed
        if len(ids) > self.max_length:
            ids = ids[:self.max_length]
        else:
            ids.extend([self.vocab['[PAD]']] * (self.max_length - len(ids)))
            
        return ids
    
    def decode(self, ids):
        """Convert IDs back to SELFIES string"""
        tokens = [self.id2token[id] for id in ids]
        # Remove special tokens
        tokens = [t for t in tokens if t not in self.special_tokens.values()]
        return ''.join(tokens)

Usage Example

# Initialize tokenizer
tokenizer = SelfiesTokenizer('tokenizer.json')

# Encode a SELFIES string
selfies = '[C][=C][C][=C][O][H]'
ids = tokenizer.encode(selfies)

# Decode back to SELFIES
decoded = tokenizer.decode(ids)

Notes

• The tokenizer assumes well-formed SELFIES strings as input
• No additional preprocessing is needed since SELFIES tokens are already well-defined
• The vocab mapping preserves IDs from the original tokenizer where possible
• Maximum sequence length is set to 512 tokens by default