Upload P3GPT handler and TCM database modules

demo/P3LIB/endpoints.py

@@ -0,0 +1,565 @@
+from typing import Dict, List, Any
+import os
+import torch
+from transformers import AutoTokenizer, AutoModel
+import pandas as pd
+import time
+import numpy as np
+from transformers import GenerationConfig
+from P3LIB.precious3_gpt_multi_modal import Custom_MPTForCausalLM
+
+
+class EndpointHandler:
+    def __init__(self, path="insilicomedicine/precious3-gpt", device='cuda:1'):
+
+        self.device = device
+        self.model = AutoModel.from_pretrained(path, trust_remote_code=True).to(self.device)
+        self.tokenizer = AutoTokenizer.from_pretrained(path, trust_remote_code=True)
+        self.model.config.pad_token_id = self.tokenizer.pad_token_id
+        self.model.config.bos_token_id = self.tokenizer.bos_token_id
+        self.model.config.eos_token_id = self.tokenizer.eos_token_id
+
+        unique_entities_p3 = pd.read_csv(
+            'https://huggingface.co/insilicomedicine/precious3-gpt/raw/main/all_entities_with_type.csv')
+        self.unique_compounds_p3 = [i.strip() for i in
+                                    unique_entities_p3[unique_entities_p3.type == 'compound'].entity.to_list()]
+        self.unique_genes_p3 = [i.strip() for i in
+                                unique_entities_p3[unique_entities_p3.type == 'gene'].entity.to_list()]
+
+    def create_prompt(self, prompt_config):
+
+        prompt = "[BOS]"
+
+        multi_modal_prefix = ''
+
+        for k, v in prompt_config.items():
+            if k == 'instruction':
+                prompt += f'<{v}>' if isinstance(v, str) else "".join([f'<{v_i}>' for v_i in v])
+            elif k == 'up':
+                if v:
+                    prompt += f'{multi_modal_prefix}<{k}>{v} </{k}>' if isinstance(v,
+                                                                                   str) else f'{multi_modal_prefix}<{k}>{" ".join(v)} </{k}>'
+            elif k == 'down':
+                if v:
+                    prompt += f'{multi_modal_prefix}<{k}>{v} </{k}>' if isinstance(v,
+                                                                                   str) else f'{multi_modal_prefix}<{k}>{" ".join(v)} </{k}>'
+            elif k == 'age':
+                if isinstance(v, int):
+                    if prompt_config['species'].strip() == 'human':
+                        prompt += f'<{k}_individ>{v} </{k}_individ>'
+                    elif prompt_config['species'].strip() == 'macaque':
+                        prompt += f'<{k}_individ>Macaca-{int(v / 20)} </{k}_individ>'
+            else:
+                if v:
+                    prompt += f'<{k}>{v.strip()} </{k}>' if isinstance(v, str) else f'<{k}>{" ".join(v)} </{k}>'
+                else:
+                    prompt += f'<{k}></{k}>'
+        return prompt
+
+    def generate_with_generation_config(self, input_ids, generation_config, max_new_tokens, random_seed=138):
+        torch.manual_seed(random_seed)
+
+        with torch.no_grad():
+            generation_output = self.model.generate(
+                input_ids=input_ids,
+                generation_config=generation_config,
+                return_dict_in_generate=True,
+                output_scores=True,
+                max_new_tokens=max_new_tokens
+            )
+        return generation_output
+
+    def get_gene_probabilities(self, prompt_config, top_k=300, list_type='up', random_seed=138):
+        """
+        Args:
+            top_k: how many top probable tokens to take
+            list_type: "up" / "down"
+        """
+        prompt = self.create_prompt(prompt_config)
+        assert list_type in ["up", "down"]
+
+        if list_type == 'up':
+            prompt += "<up>"
+
+        print(prompt)
+        ### Generation config  https://huggingface.co/blog/how-to-generate
+        generation_config = GenerationConfig(temperature=0.8, num_beams=1, do_sample=True, top_p=None, top_k=3550,
+                                             pad_token_id=self.tokenizer.pad_token_id, num_return_sequences=1)
+        inputs = self.tokenizer(prompt, return_tensors="pt")
+        input_ids = inputs["input_ids"].to(self.device)
+        assert 3 not in input_ids[0]
+        max_new_tokens = self.model.config.max_seq_len - len(input_ids[0])
+
+        generation_output = self.generate_with_generation_config(input_ids=input_ids,
+                                                                 generation_config=generation_config,
+                                                                 max_new_tokens=max_new_tokens,
+                                                                 random_seed=random_seed)
+        #  print(generation_output)
+        id_4_gene_token = list(generation_output.sequences[0][len(input_ids[0]) - 1:]).index(
+            self.tokenizer.convert_tokens_to_ids([f'<{list_type}>'])[0])
+        id_4_gene_token += 1
+        print('This is token index where gene should be predicted: ', id_4_gene_token)
+
+        values, indices = torch.topk(generation_output["scores"][id_4_gene_token - 1].view(-1), k=top_k)
+        indices_decoded = self.tokenizer.decode(indices, skip_special_tokens=True)
+        indices_decoded_list = indices_decoded.split('  ')
+
+        generated_genes = sorted(set(indices_decoded_list) & set(self.unique_genes_p3), key=indices_decoded_list.index)
+        return generated_genes
+
+
+class HFEndpointHandler:
+    def __init__(self, path="insilicomedicine/precious3-gpt", device='cuda:1'):
+    
+        self.device = device
+        self.model = AutoModel.from_pretrained(path, trust_remote_code=True).to(self.device)
+        self.tokenizer = AutoTokenizer.from_pretrained(path, trust_remote_code=True)
+        self.model.config.pad_token_id = self.tokenizer.pad_token_id
+        self.model.config.bos_token_id = self.tokenizer.bos_token_id
+        self.model.config.eos_token_id = self.tokenizer.eos_token_id
+        
+        unique_entities_p3 = pd.read_csv('https://huggingface.co/insilicomedicine/precious3-gpt/raw/main/all_entities_with_type.csv')
+        self.unique_compounds_p3 = [i.strip() for i in unique_entities_p3[unique_entities_p3.type=='compound'].entity.to_list()]
+        self.unique_genes_p3 = [i.strip() for i in unique_entities_p3[unique_entities_p3.type=='gene'].entity.to_list()]
+
+
+    def create_prompt(self, prompt_config):
+
+        prompt = "[BOS]"
+
+        multi_modal_prefix = ''
+
+        for k, v in prompt_config.items():
+            if k=='instruction':
+                prompt+=f'<{v}>' if isinstance(v, str) else "".join([f'<{v_i}>' for v_i in v])
+            elif k=='up':
+                if v:
+                    prompt+=f'{multi_modal_prefix}<{k}>{v} </{k}>' if isinstance(v, str) else f'{multi_modal_prefix}<{k}>{" ".join(v)} </{k}>'
+            elif k=='down':
+                if v:
+                    prompt+=f'{multi_modal_prefix}<{k}>{v} </{k}>' if isinstance(v, str) else f'{multi_modal_prefix}<{k}>{" ".join(v)} </{k}>'
+            elif k=='age':
+                if isinstance(v, int):
+                    if prompt_config['species'].strip() == 'human':
+                        prompt+=f'<{k}_individ>{v} </{k}_individ>'
+                    elif prompt_config['species'].strip() == 'macaque':
+                        prompt+=f'<{k}_individ>Macaca-{int(v/20)} </{k}_individ>'
+            else:
+                if v:
+                    prompt+=f'<{k}>{v.strip()} </{k}>' if isinstance(v, str) else f'<{k}>{" ".join(v)} </{k}>'
+                else:
+                    prompt+=f'<{k}></{k}>'
+        return prompt
+
+    def custom_generate(self,
+                        input_ids, 
+                        device, 
+                        max_new_tokens,
+                        mode, 
+                        temperature=0.8, 
+                        top_p=0.2, top_k=3550, 
+                        n_next_tokens=30, num_return_sequences=1, random_seed=138):
+
+        torch.manual_seed(random_seed)
+
+        # Set parameters
+        # temperature - Higher value for more randomness, lower for more control
+        # top_p - Probability threshold for nucleus sampling (aka top-p sampling)
+        # top_k - Ignore logits below the top-k value to reduce randomness (if non-zero)
+        # n_next_tokens - Number of top next tokens when predicting compounds
+
+        # Generate sequences
+        outputs = []
+        next_token_compounds = []
+        next_token_up_genes = [] 
+        next_token_down_genes = [] 
+    
+        for _ in range(num_return_sequences):
+            start_time = time.time()
+            generated_sequence = []
+            current_token = input_ids.clone()
+
+            for _ in range(max_new_tokens):  # Maximum length of generated sequence
+                # Forward pass through the model
+                logits = self.model.forward(
+                    input_ids=current_token
+                )[0]
+
+                # Apply temperature to logits
+                if temperature != 1.0:
+                    logits = logits / temperature
+
+                # Apply top-p sampling (nucleus sampling)
+                sorted_logits, sorted_indices = torch.sort(logits, descending=True)
+                cumulative_probs = torch.cumsum(torch.softmax(sorted_logits, dim=-1), dim=-1)
+                sorted_indices_to_remove = cumulative_probs > top_p
+
+                if top_k > 0:
+                    sorted_indices_to_remove[..., top_k:] = 1
+
+                # Set the logit values of the removed indices to a very small negative value
+                inf_tensor = torch.tensor(float("-inf")).type(torch.bfloat16).to(logits.device)
+
+                logits = logits.where(sorted_indices_to_remove, inf_tensor)
+                
+                # Sample the next token
+                if current_token[0][-1] == self.tokenizer.encode('<drug>')[0] and len(next_token_compounds)==0:
+                    next_token_compounds.append(torch.topk(torch.softmax(logits, dim=-1)[0][len(current_token[0])-1, :].flatten(), n_next_tokens).indices)
+
+                # Sample the next token for UP genes
+                if current_token[0][-1] == self.tokenizer.encode('<up>')[0] and len(next_token_up_genes)==0:
+                    next_token_up_genes.append(torch.topk(torch.softmax(logits, dim=-1)[0][len(current_token[0])-1, :].flatten(), n_next_tokens).indices)
+                    
+                # Sample the next token for DOWN genes
+                if current_token[0][-1] == self.tokenizer.encode('<down>')[0] and len(next_token_down_genes)==0:
+                    next_token_down_genes.append(torch.topk(torch.softmax(logits, dim=-1)[0][len(current_token[0])-1, :].flatten(), n_next_tokens).indices)
+
+                next_token = torch.multinomial(torch.softmax(logits, dim=-1)[0], num_samples=1)[len(current_token[0])-1, :].unsqueeze(0)
+
+
+                # Append the sampled token to the generated sequence
+                generated_sequence.append(next_token.item())
+
+                # Stop generation if an end token is generated
+                if next_token == self.tokenizer.eos_token_id:
+                    break
+
+                # Prepare input for the next iteration
+                current_token = torch.cat((current_token, next_token), dim=-1)
+            print(time.time()-start_time)
+            outputs.append(generated_sequence)
+        
+        # Process generated up/down lists
+        processed_outputs = {"up": [], "down": []}
+        if mode in ['meta2diff', 'meta2diff2compound']:
+            
+            
+            predicted_up_genes_tokens = [self.tokenizer.convert_ids_to_tokens(j) for j in next_token_up_genes]
+            predicted_up_genes = []
+            for j in predicted_up_genes_tokens:
+                generated_up_sample = [i.strip() for i in j]
+                predicted_up_genes.append(sorted(set(generated_up_sample) & set(self.unique_genes_p3), key = generated_up_sample.index))
+            processed_outputs['up'] = predicted_up_genes
+
+            predicted_down_genes_tokens = [self.tokenizer.convert_ids_to_tokens(j) for j in next_token_down_genes]
+            predicted_down_genes = []
+            for j in predicted_down_genes_tokens:
+                generated_down_sample = [i.strip() for i in j]
+                predicted_down_genes.append(sorted(set(generated_down_sample) & set(self.unique_genes_p3), key = generated_down_sample.index))
+            processed_outputs['down'] = predicted_down_genes
+                
+        else:
+            processed_outputs = outputs
+        
+        predicted_compounds_ids = [self.tokenizer.convert_ids_to_tokens(j) for j in next_token_compounds]
+        predicted_compounds = []
+        for j in predicted_compounds_ids:
+            predicted_compounds.append([i.strip() for i in j])
+            
+        return processed_outputs, predicted_compounds, random_seed
+
+
+    def __call__(self, data: Dict[str, Any]) -> Dict[str, str]:
+        """
+        Args:
+            data (:dict:):
+                The payload with the text prompt and generation parameters.
+        """
+        
+        data = data.copy()
+        
+        parameters = data.pop("parameters", None)
+        config_data = data.pop("inputs", None)
+        mode = data.pop('mode', 'Not specified')
+        
+        prompt = self.create_prompt(config_data)
+        if mode != "diff2compound":
+            prompt+="<up>"
+        
+        inputs = self.tokenizer(prompt, return_tensors="pt")
+        input_ids = inputs["input_ids"].to(self.device)
+
+        max_new_tokens = self.model.config.max_seq_len - len(input_ids[0]) 
+        try:
+        
+            generated_sequence, raw_next_token_generation, out_seed = self.custom_generate(input_ids = input_ids, 
+                                                                                           max_new_tokens=max_new_tokens, mode=mode,
+                                                                                           device=self.device, **parameters)
+            next_token_generation = [sorted(set(i) & set(self.unique_compounds_p3), key = i.index) for i in raw_next_token_generation]
+
+            if mode == "meta2diff":
+                outputs = {"up": generated_sequence['up'], "down": generated_sequence['down']}
+                out = {"output": outputs, "mode": mode, "message": "Done!", "input": prompt, 'random_seed': out_seed}
+            elif mode == "meta2diff2compound":
+                outputs = {"up": generated_sequence['up'], "down": generated_sequence['down']}
+                out = {
+                "output": outputs, "compounds": next_token_generation, "raw_output": raw_next_token_generation, "mode": mode, 
+                    "message": "Done!", "input": prompt, 'random_seed': out_seed}
+            elif mode == "diff2compound":
+                outputs = generated_sequence
+                out = {
+                "output": outputs, "compounds": next_token_generation, "raw_output": raw_next_token_generation, "mode": mode, 
+                    "message": "Done!", "input": prompt, 'random_seed': out_seed}
+            else:
+                out = {"message": f"Specify one of the following modes: meta2diff, meta2diff2compound, diff2compound. Your mode is: {mode}"}
+
+        except Exception as e:
+            print(e)
+            outputs, next_token_generation = [None], [None]
+            out = {"output": outputs, "mode": mode, 'message': f"{e}", "input": prompt, 'random_seed': 138}
+
+        return out
+
+class MMEndpointHandler:
+    def __init__(self, path="insilicomedicine/precious3-gpt-multi-modal", device='cuda:3'):
+
+        self.device = device
+        self.path = path
+        # load model and processor from path
+        self.model = Custom_MPTForCausalLM.from_pretrained(path, torch_dtype=torch.bfloat16).to(self.device)
+        self.tokenizer = AutoTokenizer.from_pretrained(path, trust_remote_code=True)
+        self.model.config.pad_token_id = self.tokenizer.pad_token_id
+        self.model.config.bos_token_id = self.tokenizer.bos_token_id
+        self.model.config.eos_token_id = self.tokenizer.eos_token_id
+        unique_entities_p3 = pd.read_csv('https://huggingface.co/insilicomedicine/precious3-gpt/raw/main/all_entities_with_type.csv')
+        self.unique_compounds_p3 = [i.strip() for i in unique_entities_p3[unique_entities_p3.type=='compound'].entity.to_list()]
+        self.unique_genes_p3 = [i.strip() for i in unique_entities_p3[unique_entities_p3.type=='gene'].entity.to_list()]
+        
+        self.emb_gpt_genes = pd.read_pickle('https://huggingface.co/insilicomedicine/precious3-gpt-multi-modal/resolve/main/multi-modal-data/emb_gpt_genes.pickle')
+        self.emb_hgt_genes = pd.read_pickle('https://huggingface.co/insilicomedicine/precious3-gpt-multi-modal/resolve/main/multi-modal-data/emb_hgt_genes.pickle')
+
+
+    def create_prompt(self, prompt_config):
+
+        prompt = "[BOS]"
+
+        multi_modal_prefix = '<modality0><modality1><modality2><modality3>'*3
+
+        for k, v in prompt_config.items():
+            if k=='instruction':
+                prompt+=f'<{v}>' if isinstance(v, str) else "".join([f'<{v_i}>' for v_i in v])
+            elif k=='up':
+                if v:
+                    prompt+=f'{multi_modal_prefix}<{k}>{v} </{k}>' if isinstance(v, str) else f'{multi_modal_prefix}<{k}>{" ".join(v)} </{k}>'
+            elif k=='down':
+                if v:
+                    prompt+=f'{multi_modal_prefix}<{k}>{v} </{k}>' if isinstance(v, str) else f'{multi_modal_prefix}<{k}>{" ".join(v)} </{k}>'
+            elif k=='age':
+                if isinstance(v, int):
+                    if prompt_config['species'].strip() == 'human':
+                        prompt+=f'<{k}_individ>{v} </{k}_individ>'
+                    elif prompt_config['species'].strip() == 'macaque':
+                        prompt+=f'<{k}_individ>Macaca-{int(v/20)} </{k}_individ>'
+            else:
+                if v:
+                    prompt+=f'<{k}>{v.strip()} </{k}>' if isinstance(v, str) else f'<{k}>{" ".join(v)} </{k}>'
+                else:
+                    prompt+=f'<{k}></{k}>'
+        return prompt
+
+    def custom_generate(self,
+                        input_ids, 
+                        acc_embs_up_kg_mean, 
+                        acc_embs_down_kg_mean, 
+                        acc_embs_up_txt_mean, 
+                        acc_embs_down_txt_mean,
+                        device, 
+                        max_new_tokens,
+                        mode, 
+                        temperature=0.8, 
+                        top_p=0.2, top_k=3550, 
+                        n_next_tokens=50, num_return_sequences=1, random_seed=138):
+
+        torch.manual_seed(random_seed)
+
+        # Set parameters
+        # temperature - Higher value for more randomness, lower for more control
+        # top_p - Probability threshold for nucleus sampling (aka top-p sampling)
+        # top_k - Ignore logits below the top-k value to reduce randomness (if non-zero)
+        # n_next_tokens - Number of top next tokens when predicting compounds
+
+        modality0_emb = torch.unsqueeze(torch.from_numpy(acc_embs_up_kg_mean), 0).to(device) if isinstance(acc_embs_up_kg_mean, np.ndarray) else None
+        modality1_emb = torch.unsqueeze(torch.from_numpy(acc_embs_down_kg_mean), 0).to(device) if isinstance(acc_embs_down_kg_mean, np.ndarray) else None
+        modality2_emb = torch.unsqueeze(torch.from_numpy(acc_embs_up_txt_mean), 0).to(device) if isinstance(acc_embs_up_txt_mean, np.ndarray) else None
+        modality3_emb = torch.unsqueeze(torch.from_numpy(acc_embs_down_txt_mean), 0).to(device) if isinstance(acc_embs_down_txt_mean, np.ndarray) else None
+
+
+        # Generate sequences
+        outputs = []
+        next_token_compounds = []
+        next_token_up_genes = [] 
+        next_token_down_genes = []
+
+        for _ in range(num_return_sequences):
+            start_time = time.time()
+            generated_sequence = []
+            current_token = input_ids.clone()
+
+            for _ in range(max_new_tokens):  # Maximum length of generated sequence
+                # Forward pass through the model
+                logits = self.model.forward(
+                    input_ids=current_token, 
+                    modality0_emb=modality0_emb,
+                    modality0_token_id=self.tokenizer.encode('<modality0>')[0], # 62191, 
+                    modality1_emb=modality1_emb,
+                    modality1_token_id=self.tokenizer.encode('<modality1>')[0], # 62192,
+                    modality2_emb=modality2_emb,
+                    modality2_token_id=self.tokenizer.encode('<modality2>')[0], # 62193, 
+                    modality3_emb=modality3_emb,
+                    modality3_token_id=self.tokenizer.encode('<modality3>')[0], # 62194
+                )[0]
+
+                # Apply temperature to logits
+                if temperature != 1.0:
+                    logits = logits / temperature
+
+                # Apply top-p sampling (nucleus sampling)
+                sorted_logits, sorted_indices = torch.sort(logits, descending=True)
+                cumulative_probs = torch.cumsum(torch.softmax(sorted_logits, dim=-1), dim=-1)
+                sorted_indices_to_remove = cumulative_probs > top_p
+
+                if top_k > 0:
+                    sorted_indices_to_remove[..., top_k:] = 1
+
+                # Set the logit values of the removed indices to a very small negative value
+                inf_tensor = torch.tensor(float("-inf")).type(torch.bfloat16).to(logits.device)
+
+                logits = logits.where(sorted_indices_to_remove, inf_tensor)
+
+
+                # Sample the next token
+                if current_token[0][-1] == self.tokenizer.encode('<drug>')[0] and len(next_token_compounds)==0:
+                    next_token_compounds.append(torch.topk(torch.softmax(logits, dim=-1)[0][len(current_token[0])-1, :].flatten(), n_next_tokens).indices)
+
+                # Sample the next token for UP genes
+                if current_token[0][-1] == self.tokenizer.encode('<up>')[0] and len(next_token_up_genes)==0:
+                    next_token_up_genes.append(torch.topk(torch.softmax(logits, dim=-1)[0][len(current_token[0])-1, :].flatten(), n_next_tokens).indices)
+                    
+                # Sample the next token for DOWN genes
+                if current_token[0][-1] == self.tokenizer.encode('<down>')[0] and len(next_token_down_genes)==0:
+                    next_token_down_genes.append(torch.topk(torch.softmax(logits, dim=-1)[0][len(current_token[0])-1, :].flatten(), n_next_tokens).indices)
+
+                next_token = torch.multinomial(torch.softmax(logits, dim=-1)[0], num_samples=1)[len(current_token[0])-1, :].unsqueeze(0)
+
+
+                # Append the sampled token to the generated sequence
+                generated_sequence.append(next_token.item())
+
+                # Stop generation if an end token is generated
+                if next_token == self.tokenizer.eos_token_id:
+                    break
+
+                # Prepare input for the next iteration
+                current_token = torch.cat((current_token, next_token), dim=-1)
+            print(time.time()-start_time)
+            outputs.append(generated_sequence)
+        
+        # Process generated up/down lists
+        processed_outputs = {"up": [], "down": []}
+        if mode in ['meta2diff', 'meta2diff2compound']:
+            predicted_up_genes_tokens = [self.tokenizer.convert_ids_to_tokens(j) for j in next_token_up_genes]
+            predicted_up_genes = []
+            for j in predicted_up_genes_tokens:
+                generated_up_sample = [i.strip() for i in j]
+                predicted_up_genes.append(sorted(set(generated_up_sample) & set(self.unique_genes_p3), key = generated_up_sample.index))
+            processed_outputs['up'] = predicted_up_genes
+
+            predicted_down_genes_tokens = [self.tokenizer.convert_ids_to_tokens(j) for j in next_token_down_genes]
+            predicted_down_genes = []
+            for j in predicted_down_genes_tokens:
+                generated_down_sample = [i.strip() for i in j]
+                predicted_down_genes.append(sorted(set(generated_down_sample) & set(self.unique_genes_p3), key = generated_down_sample.index))
+            processed_outputs['down'] = predicted_down_genes
+                
+        else:
+            processed_outputs = outputs
+        
+        predicted_compounds_ids = [self.tokenizer.convert_ids_to_tokens(j) for j in next_token_compounds]
+        predicted_compounds = []
+        for j in predicted_compounds_ids:
+            predicted_compounds.append([i.strip() for i in j])
+            
+        return processed_outputs, predicted_compounds, random_seed
+
+
+    def __call__(self, data: Dict[str, Any]) -> Dict[str, str]:
+        """
+        Args:
+            data (:dict:):
+                The payload with the text prompt and generation parameters.
+        """
+        data = data.copy()
+        parameters = data.pop("parameters", None)
+        config_data = data.pop("inputs", None)
+        mode = data.pop('mode', 'Not specified')
+        
+        prompt = self.create_prompt(config_data)
+        if mode != "diff2compound":
+            prompt+="<up>"
+        
+        inputs = self.tokenizer(prompt, return_tensors="pt")
+        input_ids = inputs["input_ids"].to(self.device)
+
+        max_new_tokens = self.model.config.max_seq_len - len(input_ids[0]) 
+        try:
+            if set(["up", "down"]) & set(config_data.keys()):
+                acc_embs_up1 = []
+                acc_embs_up2 = []
+                for gs in config_data['up']: 
+                    try:
+                        acc_embs_up1.append(self.emb_hgt_genes[self.emb_hgt_genes.gene_symbol==gs].embs.values[0])
+                        acc_embs_up2.append(self.emb_gpt_genes[self.emb_gpt_genes.gene_symbol==gs].embs.values[0])
+                    except Exception as e: 
+                        pass
+                acc_embs_up1_mean = np.array(acc_embs_up1).mean(0) if acc_embs_up1 else None
+                acc_embs_up2_mean = np.array(acc_embs_up2).mean(0) if acc_embs_up2 else None
+
+                acc_embs_down1 = []
+                acc_embs_down2 = []
+                for gs in config_data['down']:
+                    try:
+                        acc_embs_down1.append(self.emb_hgt_genes[self.emb_hgt_genes.gene_symbol==gs].embs.values[0])
+                        acc_embs_down2.append(self.emb_gpt_genes[self.emb_gpt_genes.gene_symbol==gs].embs.values[0])
+                    except Exception as e: 
+                        pass
+                acc_embs_down1_mean = np.array(acc_embs_down1).mean(0) if acc_embs_down1 else None
+                acc_embs_down2_mean = np.array(acc_embs_down2).mean(0) if acc_embs_down2 else None
+            else:
+                acc_embs_up1_mean, acc_embs_up2_mean, acc_embs_down1_mean, acc_embs_down2_mean = None, None, None, None
+
+            generated_sequence, raw_next_token_generation, out_seed = self.custom_generate(input_ids = input_ids, 
+                                                             acc_embs_up_kg_mean=acc_embs_up1_mean,
+                                                             acc_embs_down_kg_mean=acc_embs_down1_mean, 
+                                                             acc_embs_up_txt_mean=acc_embs_up2_mean,
+                                                             acc_embs_down_txt_mean=acc_embs_down2_mean, max_new_tokens=max_new_tokens, mode=mode,
+                                                             device=self.device, **parameters)
+            next_token_generation = [sorted(set(i) & set(self.unique_compounds_p3), key = i.index) for i in raw_next_token_generation]
+
+            if mode == "meta2diff":
+                outputs = {"up": generated_sequence['up'], "down": generated_sequence['down']}
+                out = {"output": outputs, "mode": mode, "message": "Done!", "input": prompt, 'random_seed': out_seed}
+            elif mode == "meta2diff2compound":
+                outputs = {"up": generated_sequence['up'], "down": generated_sequence['down']}
+                out = {
+                "output": outputs, "compounds": next_token_generation, "raw_output": raw_next_token_generation, "mode": mode, 
+                    "message": "Done!", "input": prompt, 'random_seed': out_seed}
+            elif mode == "diff2compound":
+                outputs = generated_sequence
+                out = {
+                "output": outputs, "compounds": next_token_generation, "raw_output": raw_next_token_generation, "mode": mode, 
+                    "message": "Done!", "input": prompt, 'random_seed': out_seed}
+            else:
+                out = {"message": f"Specify one of the following modes: meta2diff, meta2diff2compound, diff2compound. Your mode is: {mode}"}
+
+        except Exception as e:
+            print(e)
+            outputs, next_token_generation = [None], [None]
+            out = {"output": outputs, "mode": mode, 'message': f"{e}", "input": prompt, 'random_seed': 138}
+
+        return out
+
+def main():
+    pass
+
+if __name__=="__main__":
+    main()

demo/P3LIB/formula_picker.py

@@ -0,0 +1,549 @@
+import pandas as pd
+import pickle
+from typing import List, Dict, Optional
+from copy import copy as cp
+import json
+
+from abc import ABC, abstractmethod
+
+
+class TCMEntity(ABC):
+    empty_override = True
+    desc = ''
+    cid = -1
+    entity = 'superclass'
+
+    def __init__(self,
+                 pref_name: str, desc: str = '',
+                 synonyms: Optional[List[str]] = None,
+                 **kwargs):
+        self.pref_name = pref_name
+        self.desc = desc
+        self.synonyms = [] if synonyms is None else [x for x in synonyms if str(x).strip() != 'NA']
+
+        self.targets = {"known": dict(), "predicted": dict()}
+
+        self.formulas = []
+        self.herbs = []
+        self.ingrs = []
+
+        for k, v in kwargs.items():
+            self.__dict__[k] = v
+
+    def serialize(self):
+        init_dict = dict(
+            cid=self.cid,
+            targets_known=self.targets['known'],
+            targets_pred=self.targets['predicted'],
+            pref_name=self.pref_name, desc=self.desc,
+            synonyms=cp(self.synonyms),
+            entity=self.entity
+        )
+        link_dict = self._get_link_dict()
+        out_dict = {"init": init_dict, "links": link_dict}
+        return out_dict
+
+    @classmethod
+    def load(cls,
+             db: 'TCMDB', ser_dict: dict,
+             skip_links = True):
+        init_args = ser_dict['init']
+
+        if skip_links:
+            init_args.update({"empty_override":True})
+        else:
+            init_args.update({"empty_override": False})
+
+        new_entity = cls(**init_args)
+        if not skip_links:
+            links = ser_dict['links']
+            new_entity._set_links(db, links)
+        return (new_entity)
+
+    def _get_link_dict(self):
+        return dict(
+            ingrs=[x.cid for x in self.ingrs],
+            herbs=[x.pref_name for x in self.herbs],
+            formulas=[x.pref_name for x in self.formulas]
+        )
+
+    def _set_links(self, db: 'TCMDB', links: dict):
+        for ent_type in links:
+            self.__dict__[ent_type] = [db.__dict__[ent_type].get(x) for x in links[ent_type]]
+            self.__dict__[ent_type] = [x for x in self.__dict__[ent_type] if x is not None]
+
+
+class Ingredient(TCMEntity):
+    entity: str = 'ingredient'
+
+    def __init__(self, cid: int,
+                 targets_pred: Optional[Dict] = None,
+                 targets_known: Optional[Dict] = None,
+                 synonyms: Optional[List[str]] = None,
+                 pref_name: str = '', desc: str = '',
+                 empty_override: bool = True, **kwargs):
+
+        if not empty_override:
+            assert targets_known is not None or targets_pred is not None, \
+                f"Cant submit a compound with no targets at all (CID:{cid})"
+
+        super().__init__(pref_name, synonyms, desc, **kwargs)
+
+        self.cid = cid
+        self.targets = {
+            'known': targets_known if targets_known is not None else {"symbols": [], 'entrez_ids': []},
+            'predicted': targets_pred if targets_pred is not None else {"symbols": [], 'entrez_ids': []}
+        }
+
+
+class Herb(TCMEntity):
+    entity: str = 'herb'
+
+    def __init__(self, pref_name: str,
+                 ingrs: Optional[List[Ingredient]] = None,
+                 synonyms: Optional[List[str]] = None,
+                 desc: str = '',
+                 empty_override: bool = True, **kwargs):
+
+        if ingrs is None:
+            ingrs = []
+
+        if not ingrs and not empty_override:
+            raise ValueError(f"No ingredients provided for {pref_name}")
+
+        super().__init__(pref_name, synonyms, desc, **kwargs)
+
+        self.ingrs = ingrs
+
+    def is_same(self, other: 'Herb') -> bool:
+        if len(self.ingrs) != len(other.ingrs):
+            return False
+        this_ingrs = set(x.cid for x in self.ingrs)
+        other_ingrs = set(x.cid for x in other.ingrs)
+        return this_ingrs == other_ingrs
+
+
+class Formula(TCMEntity):
+    entity: str = 'formula'
+
+    def __init__(self, pref_name: str,
+                 herbs: Optional[List[Herb]] = None,
+                 synonyms: Optional[List[str]] = None,
+                 desc: str = '',
+                 empty_override: bool = False, **kwargs):
+
+        if herbs is None:
+            herbs = []
+
+        if not herbs and not empty_override:
+            raise ValueError(f"No herbs provided for {pref_name}")
+
+        super().__init__(pref_name, synonyms, desc, **kwargs)
+        self.herbs = herbs
+
+    def is_same(self, other: 'Formula') -> bool:
+        if len(self.herbs) != len(other.herbs):
+            return False
+        this_herbs = set(x.pref_name for x in self.herbs)
+        other_herbs = set(x.pref_name for x in other.herbs)
+        return this_herbs == other_herbs
+
+
+class TCMDB:
+    hf_repo: str = "f-galkin/batman2"
+    hf_subsets: Dict[str, str] = {'formulas': 'batman_formulas',
+                                  'herbs': 'batman_herbs',
+                                  'ingredients': 'batman_ingredients'}
+
+    def __init__(self, p_batman: str):
+        p_batman = p_batman.removesuffix("/") + "/"
+
+        self.batman_files = dict(p_formulas='formula_browse.txt',
+                                 p_herbs='herb_browse.txt',
+                                 p_pred_by_tg='predicted_browse_by_targets.txt',
+                                 p_known_by_tg='known_browse_by_targets.txt',
+                                 p_pred_by_ingr='predicted_browse_by_ingredinets.txt',
+                                 p_known_by_ingr='known_browse_by_ingredients.txt')
+
+        self.batman_files = {x: p_batman + y for x, y in self.batman_files.items()}
+
+        self.ingrs = None
+        self.herbs = None
+        self.formulas = None
+
+    @classmethod
+    def make_new_db(cls, p_batman: str):
+        new_db = cls(p_batman)
+
+        new_db.parse_ingredients()
+        new_db.parse_herbs()
+        new_db.parse_formulas()
+
+        return (new_db)
+
+    def parse_ingredients(self):
+
+        pred_tgs = pd.read_csv(self.batman_files['p_pred_by_tg'],
+                               sep='\t', index_col=None, header=0,
+                               na_filter=False)
+        known_tgs = pd.read_csv(self.batman_files['p_known_by_tg'],
+                                sep='\t', index_col=None, header=0,
+                                na_filter=False)
+        entrez_to_symb = {int(pred_tgs.loc[x, 'entrez_gene_id']): pred_tgs.loc[x, 'entrez_gene_symbol'] for x in
+                          pred_tgs.index}
+        # 9927 gene targets
+        entrez_to_symb.update({int(known_tgs.loc[x, 'entrez_gene_id']): \
+                                   known_tgs.loc[x, 'entrez_gene_symbol'] for x in known_tgs.index})
+
+        known_ingreds = pd.read_csv(self.batman_files['p_known_by_ingr'],
+                                    index_col=0, header=0, sep='\t',
+                                    na_filter=False)
+        # this BATMAN table is badly formatted
+        # you cant just read it
+        # df_pred = pd.read_csv(p_pred, index_col=0, header=0, sep='\t')
+        pred_ingreds = dict()
+        with open(self.batman_files['p_pred_by_ingr'], 'r') as f:
+            # skip header
+            f.readline()
+            newline = f.readline()
+            while newline != '':
+                cid, other_line = newline.split(' ', 1)
+                name, entrez_ids = other_line.rsplit(' ', 1)
+                entrez_ids = [int(x.split("(")[0]) for x in entrez_ids.split("|") if not x == "\n"]
+                pred_ingreds[int(cid)] = {"targets": entrez_ids, 'name': name}
+                newline = f.readline()
+
+        all_BATMAN_CIDs = list(set(pred_ingreds.keys()) | set(known_ingreds.index))
+        all_BATMAN_CIDs = [int(x) for x in all_BATMAN_CIDs if str(x).strip() != 'NA']
+
+        # get targets for selected cpds
+        ingredients = dict()
+        for cid in all_BATMAN_CIDs:
+            known_name, pred_name, synonyms = None, None, []
+            if cid in known_ingreds.index:
+                known_name = known_ingreds.loc[cid, 'IUPAC_name']
+                known_symbs = known_ingreds.loc[cid, 'known_target_proteins'].split("|")
+            else:
+                known_symbs = []
+
+            pred_ids = pred_ingreds.get(cid, [])
+            if pred_ids:
+                pred_name = pred_ids.get('name')
+                if known_name is None:
+                    cpd_name = pred_name
+                elif known_name != pred_name:
+                    cpd_name = min([known_name, pred_name], key=lambda x: sum([x.count(y) for y in "'()-[]1234567890"]))
+                    synonyms = [x for x in [known_name, pred_name] if x != cpd_name]
+
+                pred_ids = pred_ids.get('targets', [])
+
+            ingredients[cid] = dict(pref_name=cpd_name,
+                                    synonyms=synonyms,
+                                    targets_known={"symbols": known_symbs,
+                                                   "entrez_ids": [int(x) for x, y in entrez_to_symb.items() if
+                                                                  y in known_symbs]},
+                                    targets_pred={"symbols": [entrez_to_symb.get(x) for x in pred_ids],
+                                                  "entrez_ids": pred_ids})
+        ingredients_objs = {x: Ingredient(cid=x, **y) for x, y in ingredients.items()}
+        self.ingrs = ingredients_objs
+
+    def parse_herbs(self):
+        if self.ingrs is None:
+            raise ValueError("Herbs cannot be added before the ingredients")
+        # load the herbs file
+        name_cols = ['Pinyin.Name', 'Chinese.Name', 'English.Name', 'Latin.Name']
+        herbs_df = pd.read_csv(self.batman_files['p_herbs'],
+                               index_col=None, header=0, sep='\t',
+                               na_filter=False)
+        for i in herbs_df.index:
+
+            herb_name = herbs_df.loc[i, 'Pinyin.Name'].strip()
+            if herb_name == 'NA':
+                herb_name = [x.strip() for x in herbs_df.loc[i, name_cols].tolist() if not x == 'NA']
+                herb_name = [x for x in herb_name if x != '']
+                if not herb_name:
+                    raise ValueError(f"LINE {i}: provided a herb with no names")
+                else:
+                    herb_name = herb_name[-1]
+
+            herb_cids = herbs_df.loc[i, 'Ingredients'].split("|")
+
+            herb_cids = [x.split("(")[-1].removesuffix(")").strip() for x in herb_cids]
+            herb_cids = [int(x) for x in herb_cids if x.isnumeric()]
+
+            missed_ingrs = [x for x in herb_cids if self.ingrs.get(x) is None]
+            for cid in missed_ingrs:
+                self.add_ingredient(cid=int(cid), pref_name='',
+                                    empty_override=True)
+            herb_ingrs = [self.ingrs[int(x)] for x in herb_cids]
+
+            self.add_herb(pref_name=herb_name,
+                          ingrs=herb_ingrs,
+                          synonyms=[x for x in herbs_df.loc[i, name_cols].tolist() if not x == "NA"],
+                          empty_override=True)
+
+    def parse_formulas(self):
+        if self.herbs is None:
+            raise ValueError("Formulas cannot be added before the herbs")
+        formulas_df = pd.read_csv(self.batman_files['p_formulas'], index_col=None, header=0,
+                                  sep='\t', na_filter=False)
+        for i in formulas_df.index:
+
+            composition = formulas_df.loc[i, 'Pinyin.composition'].split(",")
+            composition = [x.strip() for x in composition if not x.strip() == 'NA']
+            if not composition:
+                continue
+
+            missed_herbs = [x.strip() for x in composition if self.herbs.get(x) is None]
+            for herb in missed_herbs:
+                self.add_herb(pref_name=herb,
+                              desc='Missing in the original herb catalog, but present among formula components',
+                              ingrs=[], empty_override=True)
+
+            formula_herbs = [self.herbs[x] for x in composition]
+            self.add_formula(pref_name=formulas_df.loc[i, 'Pinyin.Name'].strip(),
+                             synonyms=[formulas_df.loc[i, 'Chinese.Name']],
+                             herbs=formula_herbs)
+
+    def add_ingredient(self, **kwargs):
+        if self.ingrs is None:
+            self.ingrs = dict()
+
+        new_ingr = Ingredient(**kwargs)
+        if not new_ingr.cid in self.ingrs:
+            self.ingrs.update({new_ingr.cid: new_ingr})
+
+    def add_herb(self, **kwargs):
+        if self.herbs is None:
+            self.herbs = dict()
+
+        new_herb = Herb(**kwargs)
+        old_herb = self.herbs.get(new_herb.pref_name)
+        if not old_herb is None:
+            if_same = new_herb.is_same(old_herb)
+            if if_same:
+                return
+
+            same_name = new_herb.pref_name
+            all_dupes = [self.herbs[x] for x in self.herbs if x.split('~')[0] == same_name] + [new_herb]
+            new_names = [same_name + f"~{x + 1}" for x in range(len(all_dupes))]
+            for i, duped in enumerate(all_dupes):
+                duped.pref_name = new_names[i]
+            self.herbs.pop(same_name)
+            self.herbs.update({x.pref_name: x for x in all_dupes})
+        else:
+            self.herbs.update({new_herb.pref_name: new_herb})
+
+        for cpd in new_herb.ingrs:
+            cpd_herbs = [x.pref_name for x in cpd.herbs]
+            if not new_herb.pref_name in cpd_herbs:
+                cpd.herbs.append(new_herb)
+
+    def add_formula(self, **kwargs):
+
+        if self.formulas is None:
+            self.formulas = dict()
+
+        new_formula = Formula(**kwargs)
+        old_formula = self.formulas.get(new_formula.pref_name)
+        if not old_formula is None:
+            is_same = new_formula.is_same(old_formula)
+            if is_same:
+                return
+            same_name = new_formula.pref_name
+            all_dupes = [self.formulas[x] for x in self.formulas if x.split('~')[0] == same_name] + [new_formula]
+            new_names = [same_name + f"~{x + 1}" for x in range(len(all_dupes))]
+            for i, duped in enumerate(all_dupes):
+                duped.pref_name = new_names[i]
+            self.formulas.pop(same_name)
+            self.formulas.update({x.pref_name: x for x in all_dupes})
+        else:
+            self.formulas.update({new_formula.pref_name: new_formula})
+
+        for herb in new_formula.herbs:
+            herb_formulas = [x.pref_name for x in herb.formulas]
+            if not new_formula.pref_name in herb_formulas:
+                herb.formulas.append(new_formula)
+
+    def link_ingredients_n_formulas(self):
+        for h in self.herbs.values():
+            for i in h.ingrs:
+                fla_names = set(x.pref_name for x in i.formulas)
+                i.formulas += [x for x in h.formulas if not x.pref_name in fla_names]
+            for f in h.formulas:
+                ingr_cids = set(x.cid for x in f.ingrs)
+                f.ingrs += [x for x in h.ingrs if not x.cid in ingr_cids]
+
+    def serialize(self):
+        out_dict = dict(
+            ingredients={cid: ingr.serialize() for cid, ingr in self.ingrs.items()},
+            herbs={name: herb.serialize() for name, herb in self.herbs.items()},
+            formulas={name: formula.serialize() for name, formula in self.formulas.items()}
+        )
+        return (out_dict)
+
+    def save_to_flat_json(self, p_out: str):
+        ser_db = db.serialize()
+        flat_db = dict()
+        for ent_type in ser_db:
+            for i, obj in ser_db[ent_type].items():
+                flat_db[f"{ent_type}:{i}"] = obj
+        with open(p_out, "w") as f:
+            f.write(json.dumps(flat_db))
+
+    def save_to_json(self, p_out: str):
+        with open(p_out, "w") as f:
+            json.dump(self.serialize(), f)
+
+    @classmethod
+    def load(cls, ser_dict: dict):
+        db = cls(p_batman="")
+
+        # make sure to create all entities before you link them together
+        db.ingrs = {int(cid): Ingredient.load(db, ingr, skip_links=True) for cid, ingr in
+                    ser_dict['ingredients'].items()}
+        db.herbs = {name: Herb.load(db, herb, skip_links=True) for name, herb in ser_dict['herbs'].items()}
+        db.formulas = {name: Formula.load(db, formula, skip_links=True) for name, formula in
+                       ser_dict['formulas'].items()}
+
+        # now set the links
+        for i in db.ingrs.values():
+            # NB: somehow gotta make it work w/out relying on str-int conversion
+            i._set_links(db, ser_dict['ingredients'][str(i.cid)]['links'])
+        for h in db.herbs.values():
+            h._set_links(db, ser_dict['herbs'][h.pref_name]['links'])
+        for f in db.formulas.values():
+            f._set_links(db, ser_dict['formulas'][f.pref_name]['links'])
+        return (db)
+
+    @classmethod
+    def read_from_json(cls, p_file: str):
+        with open(p_file, "r") as f:
+            json_db = json.load(f)
+        db = cls.load(json_db)
+        return (db)
+
+    @classmethod
+    def download_from_hf(cls):
+        from datasets import load_dataset
+        dsets = {x: load_dataset(cls.hf_repo, y) for x, y in cls.hf_subsets.items()}
+
+        # speed this up somehow
+
+        known_tgs = {str(x['cid']): [y.split("(") for y in eval(x['targets_known'])] for x in dsets['ingredients']['train']}
+        known_tgs = {x:{'symbols':[z[0] for z in y], "entrez_ids":[int(z[1].strip(")")) for z in y]} for x,y in known_tgs.items()}
+        pred_tgs = {str(x['cid']): [y.split("(") for y in eval(x['targets_pred'])] for x in dsets['ingredients']['train']}
+        pred_tgs = {x:{'symbols':[z[0] for z in y], "entrez_ids":[int(z[1].strip(")")) for z in y]} for x,y in pred_tgs.items()}
+
+        json_db = dict()
+        json_db['ingredients'] = {str(x['cid']): {'init': dict(cid=int(x['cid']),
+                                                               targets_known=known_tgs[str(x['cid'])],
+                                                               targets_pred=pred_tgs[str(x['cid'])],
+                                                               pref_name=x['pref_name'],
+                                                               synonyms=eval(x['synonyms']),
+                                                               desc=x['description']
+                                                               ),
+
+                                                  'links': dict(
+                                                      herbs=eval(x['herbs']),
+                                                      formulas=eval(x['formulas'])
+                                                  )
+                                                  }
+                                  for x in dsets['ingredients']['train']}
+
+        json_db['herbs'] = {x['pref_name']: {'init': dict(pref_name=x['pref_name'],
+                                                          synonyms=eval(x['synonyms']),
+                                                          desc=x['description']),
+                                             'links': dict(ingrs=eval(x['ingredients']),
+                                                           formulas=eval(x['formulas']))} for x in
+                            dsets['herbs']['train']}
+
+        json_db['formulas'] = {x['pref_name']: {'init': dict(pref_name=x['pref_name'],
+                                                             synonyms=eval(x['synonyms']),
+                                                             desc=x['description']),
+                                                'links': dict(ingrs=eval(x['ingredients']),
+                                                              herbs=eval(x['herbs']))} for x in
+                               dsets['formulas']['train']}
+
+        db = cls.load(json_db)
+        return (db)
+
+    def drop_isolated(self, how='any'):
+        match how:
+            case 'any':
+                self.herbs = {x: y for x, y in self.herbs.items() if (y.ingrs and y.formulas)}
+                self.formulas = {x: y for x, y in self.formulas.items() if (y.ingrs and y.herbs)}
+                self.ingrs = {x: y for x, y in self.ingrs.items() if (y.formulas and y.herbs)}
+            case 'all':
+                self.herbs = {x: y for x, y in self.herbs.items() if (y.ingrs or y.formulas)}
+                self.formulas = {x: y for x, y in self.formulas.items() if (y.ingrs or y.herbs)}
+                self.ingrs = {x: y for x, y in self.ingrs.items() if (y.formulas or y.herbs)}
+            case _:
+                raise ValueError(f'Unknown how parameter: {how}. Known parameters are "any" and "all"')
+
+    def select_formula_by_cpd(self, cids: List):
+        cids = set(x for x in cids if x in self.ingrs)
+        if not cids:
+            return
+        cpd_counts = {x: len(set([z.cid for z in y.ingrs]) & cids) for x, y in self.formulas.items()}
+        n_max = max(cpd_counts.values())
+        if n_max == 0:
+            return (n_max, [])
+        selected = [x for x, y in cpd_counts.items() if y == n_max]
+        return (n_max, selected)
+
+    def pick_formula_by_cpd(self, cids: List):
+        cids = [x for x in cids if x in self.ingrs]
+        if not cids:
+            return
+        raise NotImplementedError()
+
+    def select_formula_by_herb(self, herbs: List):
+        raise NotImplementedError()
+
+    def pick_formula_by_herb(self, herbs: List):
+        raise NotImplementedError()
+
+
+def main(ab_initio=False,
+         p_BATMAN="./BATMAN/",
+         fname='BATMAN_DB.json'):
+    p_BATMAN = p_BATMAN.removesuffix("/") + "/"
+    # Use in case you want to recreate the TCMDB database of Chinese medicine from BATMAN files
+    if ab_initio:
+        db = TCMDB.make_new_db(p_BATMAN)
+        db.link_ingredients_n_formulas()
+        db.save_to_json(p_BATMAN + fname)
+        # db.save_to_json('../TCM screening/BATMAN_DB.json')
+
+    else:
+        db = TCMDB.read_from_json('../TCM screening/BATMAN_DB.json')
+        # db = TCMDB.read_from_json(p_BATMAN + fname)
+
+        cids = [969516,  # curcumin
+                445154,  # resveratrol
+                5280343,  # quercetin
+                6167,  # colchicine
+                5280443,  # apigening
+                65064,  # EGCG3
+                5757,  # estradiol
+                5994,  # progesterone
+                5280863,  # kaempferol
+                107985,  # triptolide
+                14985,  # alpha-tocopherol
+                1548943,  # Capsaicin
+                64982,  # Baicalin
+                6013,  # Testosterone
+                ]
+
+        p3_formula = db.select_formula_by_cpd(cids)
+        # somehow save file if needed ↓
+        ser_db = db.serialize()
+
+
+###
+
+if __name__ == '__main__':
+    main(ab_initio=True, p_BATMAN="./BATMAN/", fname='BATMAN_DB.json')
+
+