Clean re-commit using proper Git LFS

classification/config.json

@@ -0,0 +1,19 @@
+{
+  "architectures": [
+    "BBBModelForSequenceClassification"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration_bbb.BBBConfig",
+    "AutoModelForSequenceClassification": "modeling_bbb.BBBModelForSequenceClassification"
+  },
+  "d_img": 2048,
+  "d_tab": 384,
+  "d_txt": 768,
+  "dropout": 0.1,
+  "dtype": "float32",
+  "model_type": "bbb-model",
+  "problem_type": "single_label_classification",
+  "proj_dim": 2048,
+  "task": "classification",
+  "transformers_version": "4.57.3"
+}

classification/configuration_bbb.py

@@ -0,0 +1,22 @@
+from transformers import PretrainedConfig
+
+class BBBConfig(PretrainedConfig):
+  model_type = "bbb-model"
+
+  def __init__(
+    self,
+    d_tab : int = 384, 
+    d_img: int = 2048, 
+    d_txt: int = 768, 
+    proj_dim: int = 2048, 
+    dropout: float = 0.1, 
+    task: str = 'classification',
+    **kwargs):
+
+    self.d_tab = d_tab
+    self.d_img = d_img
+    self.d_txt = d_txt
+    self.proj_dim = proj_dim
+    self.dropout = dropout
+    self.task = task
+    super().__init__(**kwargs)

classification/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa5ab19333e753976e402ac0c8c70615fa65065ca2ed3f5e5b6fcb5f54564c58
+size 59853476

classification/model_classification.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:580e8747c45b9db60ff2b9b38384a0089a29d3066d02a50a09c7ab3fab3d3253
+size 59859439

classification/modeling_bbb.py

@@ -0,0 +1,99 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from transformers import PreTrainedModel
+from transformers.modeling_outputs import BaseModelOutputWithPooling, SequenceClassifierOutput
+
+from .configuration_bbb import BBBConfig
+
+class BBBModelForSequenceClassification(PreTrainedModel):
+  config_class = BBBConfig
+
+  def __init__(self, config: BBBConfig):
+    super().__init__(config)
+
+    self.config = config
+
+    self.proj_tab = nn.Sequential(
+      nn.LayerNorm(config.d_tab),
+      nn.Linear(config.d_tab, config.proj_dim),
+      nn.ReLU(),
+      nn.Dropout(config.dropout)
+    )
+
+    self.proj_img = nn.Sequential(
+      nn.LayerNorm(config.d_img),
+      nn.Linear(config.d_img, config.proj_dim),
+      nn.ReLU(),
+      nn.Dropout(config.dropout)
+    )
+
+    self.proj_txt = nn.Sequential(
+      nn.LayerNorm(config.d_txt),
+      nn.Linear(config.d_txt, config.proj_dim),
+      nn.ReLU(),
+      nn.Dropout(config.dropout)
+    )
+
+    self.attention_pooling = nn.Sequential(
+      nn.Linear(config.proj_dim, config.proj_dim),
+      nn.Tanh(),
+      nn.Linear(config.proj_dim, 1, bias=False)
+    )
+
+    self.classifier = nn.Sequential(
+      nn.Linear(config.proj_dim, config.proj_dim), 
+      nn.ReLU(),
+      nn.Dropout(config.dropout),
+      nn.Linear(config.proj_dim, 1)
+    )
+
+  def _init_weights(self, module):
+    if isinstance(module, nn.Linear):
+      module.weight.data.normal_(mean=0.0, std=1.0)
+      if module.bias is not None:
+        module.bias.data.zero_()
+    elif isinstance(module, nn.Embedding):
+      module.weight.data.normal_(mean=0.0, std=1.0)
+      if module.padding_idx is not None:
+        module.weight.data[module.padding_idx].zero_()
+    elif isinstance(module, nn.LayerNorm):
+      module.bias.data.zero_()
+      module.weight.data.fill_(1.0)
+
+  def forward(self,
+              tab: torch.Tensor = None,
+              img: torch.Tensor = None,
+              txt: torch.Tensor = None,
+              labels: torch.Tensor = None):
+
+    if tab is None or img is None or txt is None:
+      raise ValueError('You have to specify tabular, image, and text features')
+
+    h_tab = self.proj_tab(tab)
+    h_img = self.proj_img(img)
+    h_txt = self.proj_txt(txt)
+
+    embeddings = torch.stack([h_tab, h_img, h_txt], dim=1)
+    scores = self.attention_pooling(embeddings)
+    weights = F.softmax(scores, dim=1)
+    weighted_embeddings = embeddings * weights
+    pooled_embeddings = torch.sum(weighted_embeddings, dim=1)
+    logits = self.classifier(pooled_embeddings).squeeze(-1)
+
+    loss = None
+    if labels is not None:
+      if self.config.task == "regression":
+        loss_fct = nn.MSELoss()
+        loss = loss_fct(logits.squeeze(-1), labels.squeeze(-1))
+      elif self.config.task == "classification":
+        loss_fct = nn.BCEWithLogitsLoss()
+        loss = loss_fct(logits, labels.float().unsqueeze(-1))
+
+    return SequenceClassifierOutput(
+      loss=loss,
+      logits=logits,
+      hidden_states=pooled_embeddings,
+      attentions=weights.squeeze(-1)
+    )

classification/tokenizer_bbb.py

@@ -0,0 +1,133 @@
+import torch
+import torch.nn as nn
+from transformers import PreTrainedTokenizer
+from transformers.tokenization_utils_base import BatchEncoding
+from transformers import AutoTokenizer, AutoModel
+from rdkit import Chem
+from rdkit.Chem import Descriptors, AllChem, MACCSkeys
+from rdkit.ML.Descriptors import MoleculeDescriptors
+from rdkit import RDLogger
+from rdkit.Chem import Draw
+import joblib
+import numpy as np
+import os
+from huggingface_hub import snapshot_download
+import warnings
+from sklearn.exceptions import InconsistentVersionWarning
+from torchvision import models, transforms
+from PIL import Image
+warnings.filterwarnings("ignore", category=InconsistentVersionWarning)
+RDLogger.DisableLog('rdApp.*')
+
+class BBBTokenizer(PreTrainedTokenizer):
+  def __init__(self, **kwargs):
+    super().__init__(**kwargs)
+    
+    self.calc = MoleculeDescriptors.MolecularDescriptorCalculator([i[0] for i in Descriptors.descList])
+
+    self.tokenizer = AutoTokenizer.from_pretrained('DeepChem/ChemBERTa-100M-MLM')
+    self.chemberta = AutoModel.from_pretrained('DeepChem/ChemBERTa-100M-MLM').eval()
+
+    self.resnet50_backbone = models.resnet50(weights="IMAGENET1K_V1")
+    self.resnet = nn.Sequential(*list(self.resnet50_backbone.children())[:-1]).eval()
+    self.img_preprocess = transforms.Compose([
+      transforms.Resize((224, 224)),
+      transforms.ToTensor(),
+      transforms.Normalize(
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225],
+      )
+    ])
+
+    model_dir = snapshot_download("SaeedLab/TITAN-BBB/classification", allow_patterns=["normalize"])
+    transformer_tab_path = os.path.join(model_dir, "normalize_tabular.joblib")
+    transformer_img_path = os.path.join(model_dir, "normalize_image.joblib")
+    transformer_txt_path = os.path.join(model_dir, "normalize_text.joblib")
+
+    self.feature_transformer_tab = joblib.load(transformer_tab_path)
+    self.feature_transformer_img = joblib.load(transformer_img_path)
+    self.feature_transformer_txt = joblib.load(transformer_txt_path)
+
+  def generate_tab_features(self, smiles):
+    mol = Chem.MolFromSmiles(smiles)
+    
+    if mol is None:
+      return torch.tensor(self.feature_transformer_tab.n_features_in_, dtype=torch.float32)
+    
+    rdkit_2d = np.array(self.calc.CalcDescriptors(mol))
+    rdkit_2d[np.isinf(rdkit_2d)] = np.nan
+    rdkit_2d = np.nan_to_num(rdkit_2d, nan=0.0, posinf=0.0, neginf=0.0)
+    maccs = np.array(list(MACCSkeys.GenMACCSKeys(mol).ToBitString()), dtype=int)
+    tab_input = np.concatenate([rdkit_2d, maccs])
+    tab_input = self.feature_transformer_tab.transform(tab_input.reshape(1, -1))[0]
+    return torch.tensor(tab_input, dtype=torch.float32)
+
+  def generate_img_features(self, smiles):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+      img = Image.new("RGB", (300,300), color=(0,0,0))
+    else:
+      img = Draw.MolToImage(mol, size=(300, 300))
+    img = self.img_preprocess(img)
+    with torch.no_grad():
+      img_input = self.resnet(img.unsqueeze(0)).squeeze(-1).squeeze(-1)
+    img_input = self.feature_transformer_img.transform(img_input.reshape(1, -1))[0]
+    return torch.tensor(img_input, dtype=torch.float32)
+
+  def generate_txt_features(self, smiles):
+    encoded = self.tokenizer(smiles, return_tensors="pt")
+    with torch.no_grad():
+      outputs = self.chemberta(**encoded)
+      hidden_states = outputs.last_hidden_state[0].mean(axis=0).numpy()
+    txt_input = self.feature_transformer_txt.transform(hidden_states.reshape(1, -1))[0]
+    return torch.tensor(txt_input, dtype=torch.float32)
+
+  def _batch_encode_plus(
+    self,
+    batch_smiles: list[str],
+    return_tensors: str = "pt",
+    **kwargs
+  ):
+    data_list = []
+    tab, img, txt = [], [], []
+
+    for smiles in batch_smiles:
+      tab.append(self.generate_tab_features(smiles))
+      img.append(self.generate_img_features(smiles))
+      txt.append(self.generate_txt_features(smiles))
+
+    tab = torch.stack(tab)
+    img = torch.stack(img)
+    txt = torch.stack(txt)
+
+    output = {}
+    output["tab"] = tab
+    output["img"] = img
+    output["txt"] = txt
+ 
+    return BatchEncoding(output, tensor_type=return_tensors)
+
+  def encode(self, 
+             batch_smiles: list[str],
+             return_tensors: str = "pt",
+             **kwargs):
+    return self._batch_encode_plus(batch_smiles, return_tensors, **kwargs)
+
+  def __call__(self, 
+               batch_smiles: list[str], 
+               return_tensors: str = "pt", 
+               **kwargs):
+    return self._batch_encode_plus(batch_smiles, return_tensors, **kwargs)
+  
+  def _tokenize(self, text, **kwargs):
+    return []
+
+  def save_vocabulary(self, save_directory, filename_prefix=None):
+    return ()
+    
+  def get_vocab(self):
+    return {"<pad>":0, "<bos>":1, "<eos>":2, "<unk>":3, "<mask>":4}
+
+  @property
+  def vocab_size(self):
+    return len(self.get_vocab())

classification/tokenizer_config.json

@@ -0,0 +1,13 @@
+{
+  "auto_map": {
+    "AutoTokenizer": ["tokenizer_bbb.BBBTokenizer", "tokenizer_bbb.BBBTokenizer"]
+  },
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "<bos>",
+  "mask_token": "<mask>",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "<pad>",
+  "sep_token": "<eos>",
+  "tokenizer_class": "BBBTokenizer",
+  "unk_token": "<unk>"
+}

convert_weights.py

@@ -0,0 +1,63 @@
+import torch
+from configuration_bbb import BBBConfig
+from modeling_bbb import BBBModelForSequenceClassification
+import os
+
+BASE_ARCH_PARAMS = {
+  "d_tab": 384,
+  "d_img": 2048,
+  "d_txt": 768,
+  "proj_dim": 2048
+}
+
+def convert_model(checkpoint_path: str, task_name: str, problem_type: str, dropout: float, save_directory: str):  
+  config_params = BASE_ARCH_PARAMS.copy()
+  config_params["task"] = task_name
+  config_params["problem_type"] = problem_type
+  config_params["dropout"] = dropout
+
+  config = BBBConfig(**config_params)
+  
+  hf_model = BBBModelForSequenceClassification(config)
+  hf_model.eval()
+
+  if not os.path.exists(checkpoint_path):
+    return
+    
+  old_state_dict = torch.load(checkpoint_path, map_location="cpu")
+
+  new_state_dict = {}
+  for key, value in old_state_dict.items():
+    if key.startswith("proj") or key.startswith("attention_pooling"):
+      new_state_dict[key] = value
+      
+    elif key.startswith("classifier."):
+      # The 'fc' layer is already in the correct place
+      new_state_dict[key] = value
+      
+    else:
+      print(f"[Warning] Unmapped key found: {key}")
+      new_state_dict[key] = value
+
+  print("State dict key names adjusted.")
+
+  try:
+    hf_model.load_state_dict(new_state_dict, strict=True)
+    print("State dict loaded successfully into HF")
+  except RuntimeError as e:
+    print("\n--- ERROR LOADING STATE DICT ---")
+    print("Verify that the parameters in BASE_ARCH_PARAMS are correct.")
+    print(e)
+    return
+
+  print(f"Saving HF-formatted model to {save_directory}")
+  hf_model.save_pretrained(save_directory)
+
+if __name__ == "__main__":
+  convert_model(
+    checkpoint_path="model_classification.pth",
+    task_name="classification",
+    dropout=0.1,
+    problem_type="single_label_classification",
+    save_directory="./classification"
+  )

regression/config.json

@@ -0,0 +1,19 @@
+{
+  "architectures": [
+    "BBBModelForSequenceClassification"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration_bbb.BBBConfig",
+    "AutoModelForSequenceClassification": "modeling_bbb.BBBModelForSequenceClassification"
+  },
+  "d_img": 2048,
+  "d_tab": 384,
+  "d_txt": 768,
+  "dropout": 0.3,
+  "dtype": "float32",
+  "model_type": "bbb-model",
+  "problem_type": "regression",
+  "proj_dim": 2048,
+  "task": "regression",
+  "transformers_version": "4.57.3"
+}

regression/configuration_bbb.py

@@ -0,0 +1,22 @@
+from transformers import PretrainedConfig
+
+class BBBConfig(PretrainedConfig):
+  model_type = "bbb-model"
+
+  def __init__(
+    self,
+    d_tab : int = 384, 
+    d_img: int = 2048, 
+    d_txt: int = 768, 
+    proj_dim: int = 2048, 
+    dropout: float = 0.1, 
+    task: str = 'classification',
+    **kwargs):
+
+    self.d_tab = d_tab
+    self.d_img = d_img
+    self.d_txt = d_txt
+    self.proj_dim = proj_dim
+    self.dropout = dropout
+    self.task = task
+    super().__init__(**kwargs)

regression/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d281e439bcf72bcccf563020f14589d8388c5ae6c1cfd1ec03610458e8bef64
+size 59853476

regression/model_regression.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:093e549d68ce6137dd0ca89a4742f6717e9a628b97a0835210402d60b2a1266c
+size 59859339

regression/modeling_bbb.py

@@ -0,0 +1,99 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from transformers import PreTrainedModel
+from transformers.modeling_outputs import BaseModelOutputWithPooling, SequenceClassifierOutput
+
+from .configuration_bbb import BBBConfig
+
+class BBBModelForSequenceClassification(PreTrainedModel):
+  config_class = BBBConfig
+
+  def __init__(self, config: BBBConfig):
+    super().__init__(config)
+
+    self.config = config
+
+    self.proj_tab = nn.Sequential(
+      nn.LayerNorm(config.d_tab),
+      nn.Linear(config.d_tab, config.proj_dim),
+      nn.ReLU(),
+      nn.Dropout(config.dropout)
+    )
+
+    self.proj_img = nn.Sequential(
+      nn.LayerNorm(config.d_img),
+      nn.Linear(config.d_img, config.proj_dim),
+      nn.ReLU(),
+      nn.Dropout(config.dropout)
+    )
+
+    self.proj_txt = nn.Sequential(
+      nn.LayerNorm(config.d_txt),
+      nn.Linear(config.d_txt, config.proj_dim),
+      nn.ReLU(),
+      nn.Dropout(config.dropout)
+    )
+
+    self.attention_pooling = nn.Sequential(
+      nn.Linear(config.proj_dim, config.proj_dim),
+      nn.Tanh(),
+      nn.Linear(config.proj_dim, 1, bias=False)
+    )
+
+    self.classifier = nn.Sequential(
+      nn.Linear(config.proj_dim, config.proj_dim), 
+      nn.ReLU(),
+      nn.Dropout(config.dropout),
+      nn.Linear(config.proj_dim, 1)
+    )
+
+  def _init_weights(self, module):
+    if isinstance(module, nn.Linear):
+      module.weight.data.normal_(mean=0.0, std=1.0)
+      if module.bias is not None:
+        module.bias.data.zero_()
+    elif isinstance(module, nn.Embedding):
+      module.weight.data.normal_(mean=0.0, std=1.0)
+      if module.padding_idx is not None:
+        module.weight.data[module.padding_idx].zero_()
+    elif isinstance(module, nn.LayerNorm):
+      module.bias.data.zero_()
+      module.weight.data.fill_(1.0)
+
+  def forward(self,
+              tab: torch.Tensor = None,
+              img: torch.Tensor = None,
+              txt: torch.Tensor = None,
+              labels: torch.Tensor = None):
+
+    if tab is None or img is None or txt is None:
+      raise ValueError('You have to specify tabular, image, and text features')
+
+    h_tab = self.proj_tab(tab)
+    h_img = self.proj_img(img)
+    h_txt = self.proj_txt(txt)
+
+    embeddings = torch.stack([h_tab, h_img, h_txt], dim=1)
+    scores = self.attention_pooling(embeddings)
+    weights = F.softmax(scores, dim=1)
+    weighted_embeddings = embeddings * weights
+    pooled_embeddings = torch.sum(weighted_embeddings, dim=1)
+    logits = self.classifier(pooled_embeddings).squeeze(-1)
+
+    loss = None
+    if labels is not None:
+      if self.config.task == "regression":
+        loss_fct = nn.MSELoss()
+        loss = loss_fct(logits.squeeze(-1), labels.squeeze(-1))
+      elif self.config.task == "classification":
+        loss_fct = nn.BCEWithLogitsLoss()
+        loss = loss_fct(logits, labels.float().unsqueeze(-1))
+
+    return SequenceClassifierOutput(
+      loss=loss,
+      logits=logits,
+      hidden_states=pooled_embeddings,
+      attentions=weights.squeeze(-1)
+    )

regression/tokenizer_bbb.py

@@ -0,0 +1,131 @@
+import torch
+import torch.nn as nn
+from transformers import PreTrainedTokenizer
+from transformers.tokenization_utils_base import BatchEncoding
+from transformers import AutoTokenizer, AutoModel
+from rdkit import Chem
+from rdkit.Chem import Descriptors, AllChem, MACCSkeys
+from rdkit.ML.Descriptors import MoleculeDescriptors
+from rdkit import RDLogger
+from rdkit.Chem import Draw
+import joblib
+import numpy as np
+import os
+from huggingface_hub import snapshot_download
+import warnings
+from sklearn.exceptions import InconsistentVersionWarning
+from torchvision import models, transforms
+from PIL import Image
+warnings.filterwarnings("ignore", category=InconsistentVersionWarning)
+RDLogger.DisableLog('rdApp.*')
+
+class BBBTokenizer(PreTrainedTokenizer):
+  def __init__(self, **kwargs):
+    super().__init__(**kwargs)
+    
+    self.calc = MoleculeDescriptors.MolecularDescriptorCalculator([i[0] for i in Descriptors.descList])
+
+    self.tokenizer = AutoTokenizer.from_pretrained('DeepChem/ChemBERTa-100M-MLM')
+    self.chemberta = AutoModel.from_pretrained('DeepChem/ChemBERTa-100M-MLM').eval()
+
+    self.resnet50_backbone = models.resnet50(weights="IMAGENET1K_V1")
+    self.resnet = nn.Sequential(*list(self.resnet50_backbone.children())[:-1]).eval()
+    self.img_preprocess = transforms.Compose([
+      transforms.Resize((224, 224)),
+      transforms.ToTensor(),
+      transforms.Normalize(
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225],
+      )
+    ])
+
+    #model_dir = snapshot_download("SaeedLab/BBBP-Classification", allow_patterns=["transformer.pkl"])
+    #transformer_path = os.path.join(model_dir, "transformer.pkl")
+
+    self.feature_transformer_tab = joblib.load('classification/normalize_tabular.joblib')
+    self.feature_transformer_img = joblib.load('classification/normalize_image.joblib')
+    self.feature_transformer_txt = joblib.load('classification/normalize_text.joblib')
+
+  def generate_tab_features(self, smiles):
+    mol = Chem.MolFromSmiles(smiles)
+    
+    if mol is None:
+      return torch.tensor(self.feature_transformer_tab.n_features_in_, dtype=torch.float32)
+    
+    rdkit_2d = np.array(self.calc.CalcDescriptors(mol))
+    rdkit_2d[np.isinf(rdkit_2d)] = np.nan
+    rdkit_2d = np.nan_to_num(rdkit_2d, nan=0.0, posinf=0.0, neginf=0.0)
+    maccs = np.array(list(MACCSkeys.GenMACCSKeys(mol).ToBitString()), dtype=int)
+    tab_input = np.concatenate([rdkit_2d, maccs])
+    tab_input = self.feature_transformer_tab.transform(tab_input.reshape(1, -1))[0]
+    return torch.tensor(tab_input, dtype=torch.float32)
+
+  def generate_img_features(self, smiles):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+      img = Image.new("RGB", (300,300), color=(0,0,0))
+    else:
+      img = Draw.MolToImage(mol, size=(300, 300))
+    img = self.img_preprocess(img)
+    with torch.no_grad():
+      img_input = self.resnet(img.unsqueeze(0)).squeeze(-1).squeeze(-1)
+    img_input = self.feature_transformer_img.transform(img_input.reshape(1, -1))[0]
+    return torch.tensor(img_input, dtype=torch.float32)
+
+  def generate_txt_features(self, smiles):
+    encoded = self.tokenizer(smiles, return_tensors="pt")
+    with torch.no_grad():
+      outputs = self.chemberta(**encoded)
+      hidden_states = outputs.last_hidden_state[0].mean(axis=0).numpy()
+    txt_input = self.feature_transformer_txt.transform(hidden_states.reshape(1, -1))[0]
+    return torch.tensor(txt_input, dtype=torch.float32)
+
+  def _batch_encode_plus(
+    self,
+    batch_smiles: list[str],
+    return_tensors: str = "pt",
+    **kwargs
+  ):
+    data_list = []
+    tab, img, txt = [], [], []
+
+    for smiles in batch_smiles:
+      tab.append(self.generate_tab_features(smiles))
+      img.append(self.generate_img_features(smiles))
+      txt.append(self.generate_txt_features(smiles))
+
+    tab = torch.stack(tab)
+    img = torch.stack(img)
+    txt = torch.stack(txt)
+
+    output = {}
+    output["tab"] = tab
+    output["img"] = img
+    output["txt"] = txt
+ 
+    return BatchEncoding(output, tensor_type=return_tensors)
+
+  def encode(self, 
+             batch_smiles: list[str],
+             return_tensors: str = "pt",
+             **kwargs):
+    return self._batch_encode_plus(batch_smiles, return_tensors, **kwargs)
+
+  def __call__(self, 
+               batch_smiles: list[str], 
+               return_tensors: str = "pt", 
+               **kwargs):
+    return self._batch_encode_plus(batch_smiles, return_tensors, **kwargs)
+  
+  def _tokenize(self, text, **kwargs):
+    return []
+
+  def save_vocabulary(self, save_directory, filename_prefix=None):
+    return ()
+    
+  def get_vocab(self):
+    return {"<pad>":0, "<bos>":1, "<eos>":2, "<unk>":3, "<mask>":4}
+
+  @property
+  def vocab_size(self):
+    return len(self.get_vocab())

regression/tokenizer_config.json

@@ -0,0 +1,13 @@
+{
+  "auto_map": {
+    "AutoTokenizer": ["tokenizer_bbb.BBBTokenizer", "tokenizer_bbb.BBBTokenizer"]
+  },
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "<bos>",
+  "mask_token": "<mask>",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "<pad>",
+  "sep_token": "<eos>",
+  "tokenizer_class": "BBBTokenizer",
+  "unk_token": "<unk>"
+}