{ "cells": [ { "cell_type": "markdown", "id": "9371cf89", "metadata": {}, "source": [ "# Loading Script\n", "\n", "Run this first to load local ChemQ3MTP libraries" ] }, { "cell_type": "code", "execution_count": 2, "id": "f52f283e", "metadata": {}, "outputs": [], "source": [ "import torch\n", "import sys\n", "import os\n", "from pathlib import Path\n", "import importlib.util\n", "from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer\n", "\n", "def load_custom_modules(library_path):\n", " \"\"\"Load all the custom modules required by the model from library directory\"\"\"\n", " \n", " library_path = Path(library_path)\n", " \n", " # Add the library directory to Python path\n", " if str(library_path) not in sys.path:\n", " sys.path.insert(0, str(library_path))\n", " \n", " print(f\"๐Ÿ”ง Loading custom modules from {library_path}...\")\n", " \n", " # Required module files\n", " required_files = {\n", " 'configuration_chemq3mtp.py': 'configuration_chemq3mtp',\n", " 'modeling_chemq3mtp.py': 'modeling_chemq3mtp', \n", " 'FastChemTokenizerHF.py': 'FastChemTokenizerHF'\n", " }\n", " \n", " loaded_modules = {}\n", " \n", " # Load each required module\n", " for filename, module_name in required_files.items():\n", " file_path = library_path / filename\n", " \n", " if not file_path.exists():\n", " print(f\"โŒ Required file not found: {filename}\")\n", " return None\n", " \n", " try:\n", " spec = importlib.util.spec_from_file_location(module_name, file_path)\n", " module = importlib.util.module_from_spec(spec)\n", " \n", " # Execute the module\n", " spec.loader.exec_module(module)\n", " loaded_modules[module_name] = module\n", " \n", " print(f\" โœ… Loaded {filename}\")\n", " \n", " except Exception as e:\n", " print(f\" โŒ Failed to load {filename}: {e}\")\n", " return None\n", " \n", " return loaded_modules\n", "\n", "def register_model_components(loaded_modules):\n", " \"\"\"Register the model components with transformers\"\"\"\n", " \n", " print(\"๐Ÿ”— Registering model components...\")\n", " \n", " try:\n", " # Get the classes from loaded modules\n", " ChemQ3MTPConfig = loaded_modules['configuration_chemq3mtp'].ChemQ3MTPConfig\n", " ChemQ3MTPForCausalLM = loaded_modules['modeling_chemq3mtp'].ChemQ3MTPForCausalLM\n", " FastChemTokenizerSelfies = loaded_modules['FastChemTokenizerHF'].FastChemTokenizerSelfies\n", " \n", " # Register with transformers\n", " AutoConfig.register(\"chemq3_mtp\", ChemQ3MTPConfig)\n", " AutoModelForCausalLM.register(ChemQ3MTPConfig, ChemQ3MTPForCausalLM)\n", " AutoTokenizer.register(ChemQ3MTPConfig, FastChemTokenizerSelfies)\n", " \n", " print(\"โœ… Model components registered successfully\")\n", " \n", " return ChemQ3MTPConfig, ChemQ3MTPForCausalLM, FastChemTokenizerSelfies\n", " \n", " except Exception as e:\n", " print(f\"โŒ Registration failed: {e}\")\n", " return None, None, None\n", "\n", "def load_model(model_path):\n", " \"\"\"Load the model using the registered components\"\"\"\n", " \n", " print(\"๐Ÿš€ Loading model...\")\n", " \n", " try:\n", " # Load config\n", " config = AutoConfig.from_pretrained(str(model_path), trust_remote_code=False)\n", " print(f\"โœ… Config loaded: {config.__class__.__name__}\")\n", " \n", " # Load model\n", " model = AutoModelForCausalLM.from_pretrained(\n", " str(model_path),\n", " config=config,\n", " torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,\n", " trust_remote_code=False # We've already registered everything\n", " )\n", " print(f\"โœ… Model loaded: {model.__class__.__name__}\")\n", " \n", " # Load tokenizer\n", " tokenizer = AutoTokenizer.from_pretrained(str(model_path), trust_remote_code=False)\n", " print(f\"โœ… Tokenizer loaded: {tokenizer.__class__.__name__}\")\n", " \n", " return model, tokenizer, config\n", " \n", " except Exception as e:\n", " print(f\"โŒ Model loading failed: {e}\")\n", " import traceback\n", " traceback.print_exc()\n", " return None, None, None\n", "\n", "def test_model(model, tokenizer, config):\n", " \"\"\"Test the loaded model\"\"\"\n", " \n", " print(\"\\n๐Ÿงช Testing model...\")\n", " \n", " # Setup device\n", " device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", " print(f\"๐Ÿ–ฅ๏ธ Using device: {device}\")\n", " \n", " model = model.to(device)\n", " model.eval()\n", " \n", " # Model info\n", " print(f\"\\n๐Ÿ“Š Model Information:\")\n", " print(f\" Model class: {model.__class__.__name__}\")\n", " print(f\" Config class: {config.__class__.__name__}\")\n", " print(f\" Tokenizer class: {tokenizer.__class__.__name__}\")\n", " print(f\" Model type: {config.model_type}\")\n", " print(f\" Vocab size: {config.vocab_size}\")\n", " \n", " # Set pad token if needed\n", " if not hasattr(tokenizer, 'pad_token') or tokenizer.pad_token is None:\n", " if hasattr(tokenizer, 'eos_token'):\n", " tokenizer.pad_token = tokenizer.eos_token\n", " print(\"โœ… Set pad_token to eos_token\")\n", " \n", " # Test tokenization\n", " print(\"\\n๐Ÿ”ค Testing tokenization...\")\n", " test_inputs = [\"[C][C][O]\", \"[C]\", \"[O]\"]\n", " \n", " for test_input in test_inputs:\n", " try:\n", " tokens = tokenizer(test_input, return_tensors=\"pt\")\n", " print(f\" '{test_input}' -> {tokens.input_ids.tolist()}\")\n", " except Exception as e:\n", " print(f\" โŒ Tokenization failed for '{test_input}': {e}\")\n", " continue\n", " \n", " # Test generation\n", " print(\"\\n๐ŸŽฏ Testing generation...\")\n", " test_prompts = [\"[C]\", \"[C][C]\"]\n", " \n", " for prompt in test_prompts:\n", " try:\n", " input_ids = tokenizer(prompt, return_tensors=\"pt\").input_ids.to(device)\n", " \n", " with torch.no_grad():\n", " outputs = model.generate(\n", " input_ids,\n", " max_length=input_ids.shape[1] + 20,\n", " temperature=0.8,\n", " top_p=0.9,\n", " top_k=50,\n", " do_sample=True,\n", " pad_token_id=tokenizer.pad_token_id if hasattr(tokenizer, 'pad_token_id') else 0,\n", " num_return_sequences=3\n", " )\n", " \n", " print(f\"\\n Prompt: '{prompt}'\")\n", " for i, output in enumerate(outputs):\n", " generated = tokenizer.decode(output, skip_special_tokens=True)\n", " print(f\" {i+1}: {generated}\")\n", " \n", " except Exception as e:\n", " print(f\" โŒ Generation failed for '{prompt}': {e}\")\n", " \n", " # Test MTP functionality if available\n", " print(\"\\n๐Ÿ”ฌ Testing MTP functionality...\")\n", " try:\n", " if hasattr(model, 'set_mtp_training'):\n", " print(\" โœ… MTP training methods available\")\n", " if hasattr(model, 'generate_with_logprobs'):\n", " print(\" โœ… MTP generation methods available\")\n", " else:\n", " print(\" โ„น๏ธ Standard model - no MTP methods detected\")\n", " except Exception as e:\n", " print(f\" โš ๏ธ MTP test error: {e}\")\n" ] }, { "cell_type": "markdown", "id": "b16c5461", "metadata": {}, "source": [ "# Testing MTP Head Generation with RL-checkpoints (Local)\n", "\n", "- Download checkpoints at https://huggingface.co/gbyuvd/ChemMiniQ3-SAbRLo-RL-checkpoints\n", "- Make sure to change this in loading script: \n", "```\n", " # Load model from checkpoint directory\n", " checkpoint_dir = \"./ppo_checkpoints_45/model_step_4500\"\n", "```" ] }, { "cell_type": "code", "execution_count": 3, "id": "cefc1a68", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "๐Ÿš€ ChemQ3-MTP Model Loader Starting...\n", "\n", "๐Ÿ“ Loading library from: ./ChemQ3MTP\n", "๐Ÿ”ง Loading custom modules from ChemQ3MTP...\n", " โœ… Loaded configuration_chemq3mtp.py\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "`torch_dtype` is deprecated! Use `dtype` instead!\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " โœ… Loaded modeling_chemq3mtp.py\n", " โœ… Loaded FastChemTokenizerHF.py\n", "\n", "๐Ÿ”— Registering model components...\n", "โœ… Model components registered successfully\n", "\n", "๐Ÿ“ Loading model weights from checkpoint: ./checkpoints-1/model_step_4500\n", "๐Ÿ“ Checkpoint files:\n", " config.json (1161 bytes)\n", " generation_config.json (174 bytes)\n", " model.safetensors (39437252 bytes)\n", " tokenizer_config.json (302 bytes)\n", " training_state.pt (78926669 bytes)\n", " vocab.json (21574 bytes)\n", "\n", "๐Ÿš€ Loading model...\n", "โœ… Config loaded: ChemQ3MTPConfig\n", "โœ… Model loaded: ChemQ3MTPForCausalLM\n", "โœ… Tokenizer loaded: FastChemTokenizerSelfies\n", "\n", "๐Ÿงช Testing model...\n", "๐Ÿ–ฅ๏ธ Using device: cuda\n", "\n", "๐Ÿ“Š Model Information:\n", " Model class: ChemQ3MTPForCausalLM\n", " Config class: ChemQ3MTPConfig\n", " Tokenizer class: FastChemTokenizerSelfies\n", " Model type: chemq3_mtp\n", " Vocab size: 782\n", "\n", "๐Ÿ”ค Testing tokenization...\n", " '[C][C][O]' -> [[0, 379, 379, 377, 1]]\n", " '[C]' -> [[0, 379, 1]]\n", " '[O]' -> [[0, 377, 1]]\n", "\n", "๐ŸŽฏ Testing generation...\n", "\n", " Prompt: '[C]'\n", " 1: [C]\n", " 2: [C] [=C] [C] [=C] [C] [=C] [Branch1] [#C] [C] [=C] [C] [Branch1] [C] [O] [=N] [C] [Branch1] [Ring1] [C] [=O] [=C] [Ring1] [=Branch2] [C] [=C] [Ring1] [=C]\n", " 3: [C]\n", "\n", " Prompt: '[C][C]'\n", " 1: [C] [C]\n", " 2: [C] [C]\n", " 3: [C] [C] .[C] [C] [C] [N] [Branch1] [C] [C] [C] [C] [N] [C] [C] [=C] [C] [=C] [C] [=C] [Ring1] [=Branch1] [N] [C] [Ring1] [#Branch2] [=O]\n", "\n", "๐Ÿ”ฌ Testing MTP functionality...\n", " โœ… MTP training methods available\n", " โœ… MTP generation methods available\n", "\n", "๐ŸŽ‰ Model loading and testing completed successfully!\n" ] } ], "source": [ "def main():\n", " print(\"๐Ÿš€ ChemQ3-MTP Model Loader Starting...\\n\")\n", " \n", " # Library directory (contains the .py files)\n", " library_dir = \"./ChemQ3MTP\"\n", " \n", " # Check if library directory exists\n", " if not Path(library_dir).exists():\n", " print(f\"โŒ Library directory does not exist: {library_dir}\")\n", " return None, None, None\n", " \n", " print(f\"๐Ÿ“ Loading library from: {library_dir}\")\n", " \n", " # Load custom modules from library directory\n", " loaded_modules = load_custom_modules(Path(library_dir))\n", " if loaded_modules is None:\n", " return None, None, None\n", " \n", " print()\n", " \n", " # Register components\n", " config_class, model_class, tokenizer_class = register_model_components(loaded_modules)\n", " if config_class is None:\n", " return None, None, None\n", " \n", " print()\n", " \n", " # Load model from checkpoint directory\n", " checkpoint_dir = \"./checkpoints-1/model_step_4500\" # <======\n", " \n", " # Check if checkpoint directory exists\n", " if not Path(checkpoint_dir).exists():\n", " print(f\"โŒ Checkpoint directory does not exist: {checkpoint_dir}\")\n", " return None, None, None\n", " \n", " print(f\"๐Ÿ“ Loading model weights from checkpoint: {checkpoint_dir}\")\n", " \n", " # List checkpoint files\n", " print(\"๐Ÿ“ Checkpoint files:\")\n", " for file in Path(checkpoint_dir).iterdir():\n", " if file.is_file():\n", " print(f\" {file.name} ({file.stat().st_size} bytes)\")\n", " \n", " print()\n", " \n", " # Load the model from checkpoint\n", " model, tokenizer, config = load_model(Path(checkpoint_dir))\n", " if model is None:\n", " return None, None, None\n", " \n", " # Test the model\n", " test_model(model, tokenizer, config)\n", " \n", " print(\"\\n๐ŸŽ‰ Model loading and testing completed successfully!\")\n", " \n", " return model, tokenizer, config\n", "\n", "if __name__ == \"__main__\":\n", " model, tokenizer, config = main()" ] }, { "cell_type": "code", "execution_count": 4, "id": "56628930", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Using MTP-specific generation...\n", "Generated SELFIES: [=C][C][Branch2][Ring1][Ring1][C][=C][C][=C][Branch1][=Branch2][C][=C][C][=C][C][=N][Ring1][=Branch1][S][Ring1][O][=C][C][=C][Ring1][S][N][C][C][C][C][C][Ring1][=Branch1]\n", "Decoded SMILES: C1C(C2=CC=C(C3=CC=CC=N3)S2=C)C=C1N4CCCCC4\n" ] }, { "data": { "image/jpeg": "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", "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Generate Mol Viz with MTP-specific generation\n", "from rdkit import Chem\n", "from rdkit.Chem import Draw\n", "import selfies as sf\n", "import torch\n", "\n", "# Setup device first\n", "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "\n", "# Check if MTP-specific generation is available\n", "if hasattr(model, 'generate_with_logprobs'):\n", " print(\"Using MTP-specific generation...\")\n", " input_ids = tokenizer(\"\", return_tensors=\"pt\").input_ids.to(device)\n", " \n", " # Try MTP-specific generation with log probabilities\n", " try:\n", " outputs = model.generate_with_logprobs(\n", " input_ids,\n", " max_new_tokens=25, # Correct parameter name\n", " temperature=1,\n", " top_k=50,\n", " do_sample=True,\n", " return_probs=True, # This returns action probabilities\n", " tokenizer=tokenizer # Pass tokenizer for decoding\n", " )\n", " \n", " # Handle the output (returns: decoded_list, logprobs, tokens, probs)\n", " gen = outputs[2] # Get the generated token IDs (index 2)\n", " except Exception as e:\n", " print(f\"MTP generation failed: {e}, falling back to standard generation\")\n", " gen = model.generate(input_ids, max_length=25, top_k=50, temperature=1, do_sample=True, pad_token_id=tokenizer.pad_token_id)\n", "else:\n", " print(\"Using standard generation...\")\n", " input_ids = tokenizer(\"\", return_tensors=\"pt\").input_ids.to(device)\n", " gen = model.generate(input_ids, max_length=25, top_k=50, temperature=1, do_sample=True, pad_token_id=tokenizer.pad_token_id)\n", "\n", "# Decode and process the generated molecule\n", "generatedmol = tokenizer.decode(gen[0], skip_special_tokens=True)\n", "test = generatedmol.replace(' ', '')\n", "csmi_gen = sf.decoder(test)\n", "print(f\"Generated SELFIES: {test}\")\n", "print(f\"Decoded SMILES: {csmi_gen}\")\n", "\n", "mol = Chem.MolFromSmiles(csmi_gen)\n", "\n", "# Draw the molecule\n", "if mol is not None:\n", " img = Draw.MolToImage(mol)\n", " display(img) # Use display() in Jupyter notebooks\n", "else:\n", " print(\"โŒ Could not create molecule from generated SMILES\")\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "0dc9e278", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "--- Standard Generation Test ---\n", "Generated SELFIES 1: [C]\n", "Generated SELFIES 2: [C] .[N] [=C] [Branch1] [C] [N] [S] [N] [C] [C] [C] [C] [=C] [C] [Branch1] [C] [Br] [=C] [C] [=C] [Ring1] [#Branch1] [C] [Ring1] [N]\n", "Generated SELFIES 3: [C] [Ring1] [Ring1] [C] [C] [C] [C] [C] [Ring1] [=Branch1]\n" ] } ], "source": [ "print(\"\\n--- Standard Generation Test ---\")\n", "input_ids = tokenizer(\" [C]\", return_tensors=\"pt\").input_ids.to(device)\n", "with torch.no_grad():\n", " model.set_mtp_training(False)\n", " gen = model.generate(\n", " input_ids,\n", " max_length=25,\n", " top_k=50,\n", " top_p=0.9,\n", " temperature=1.0,\n", " do_sample=True,\n", " pad_token_id=tokenizer.pad_token_id,\n", " eos_token_id=tokenizer.eos_token_id,\n", " num_return_sequences=3,\n", " )\n", " for i, sequence in enumerate(gen):\n", " result = tokenizer.decode(sequence, skip_special_tokens=True)\n", " print(f\"Generated SELFIES {i+1}: {result}\")" ] }, { "cell_type": "code", "execution_count": 6, "id": "366bd9c2", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Device set to use cuda:0\n" ] }, { "data": { "text/plain": [ "[{'label': 'Easy', 'score': 0.9802612066268921}]" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from transformers import pipeline\n", "\n", "classifier = pipeline(\"text-classification\", model=\"gbyuvd/synthaccess-chemselfies\")\n", "classifier(\".[C] [C] [=C] [C] [=C] [Branch1] [P] [C] [N] [C] [C] [C@@H1] [C] [C] [C@@H1] [C] [C@H1] [Ring1] [=Branch1] [C@H1] [Ring1] [=Branch2] [C] [Ring1] [Ring2] [S] [Ring1] [#C]\") # Gabapentin\n", "# [{'label': 'Easy', 'score': 0.9187200665473938}]\n" ] } ], "metadata": { "kernelspec": { "display_name": "base", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.13.0" } }, "nbformat": 4, "nbformat_minor": 5 }