From 0db390f967a49a0ea26dd16073f76bf6b9ff980d Mon Sep 17 00:00:00 2001 From: qcampbel Date: Thu, 12 Sep 2024 23:53:54 -0400 Subject: [PATCH] llama 70b exp1 --- .../llama-v3p1-70b-instruct/exp_1.ipynb | 654 ++++++++++++++++++ 1 file changed, 654 insertions(+) create mode 100644 notebooks/experiments/experiment_k1/llama-v3p1-70b-instruct/exp_1.ipynb diff --git a/notebooks/experiments/experiment_k1/llama-v3p1-70b-instruct/exp_1.ipynb b/notebooks/experiments/experiment_k1/llama-v3p1-70b-instruct/exp_1.ipynb new file mode 100644 index 00000000..84612ec1 --- /dev/null +++ b/notebooks/experiments/experiment_k1/llama-v3p1-70b-instruct/exp_1.ipynb @@ -0,0 +1,654 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import datetime\n", + "import os\n", + "from mdagent import MDAgent" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "date and time: 2024-09-11\n", + "time: 18:27:19\n" + ] + } + ], + "source": [ + "#todays date and time\n", + "now = datetime.datetime.now()\n", + "date = now.strftime(\"%Y-%m-%d\")\n", + "print(\"date and time:\",date)\n", + "time = now.strftime(\"%H:%M:%S\")\n", + "print(\"time:\",time)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "prompt1 = \"Simulate PDB ID 1MBN at two different temperatures: 300 K and 400 K for 1 ns each. Plot the RMSD of both over time and compare the final secondary structures at the end of the simulations. Get information about this protein, such as the number of residues and chains, etc.\"\n", + "llm_var = \"accounts/fireworks/models/llama-v3p1-70b-instruct\"\n", + "tools = \"all\"\n", + "agent = MDAgent(agent_type=\"Structured\", model=llm_var, top_k_tools=tools)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LLM: accounts/fireworks/models/llama-v3p1-70b-instruct \n", + "Temperature: 0.1\n" + ] + } + ], + "source": [ + "print(\"LLM: \",agent.llm.model_name,\"\\nTemperature: \",agent.llm.temperature)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Thought: To solve this problem, I need to simulate the protein 1MBN at two different temperatures, calculate the RMSD over time, and compare the final secondary structures. I also need to get information about the protein.\n", + "\n", + "Action:\n", + "```\n", + "{\n", + " \"action\": \"PDBFileDownloader\",\n", + " \"action_input\": \"1MBN\"\n", + "}\n", + "```\n", + "PDB file found with this ID: 1MBN\n", + "Thought: Now that I have the PDB file, I need to simulate the protein at two different temperatures. I will use the SetUpandRunFunction tool to set up and run the simulations.\n", + "\n", + "Action:\n", + "```\n", + "{\n", + " \"action\": \"SetUpandRunFunction\",\n", + " \"action_input\": {\n", + " \"pdb_id\": \"1MBN_182724\",\n", + " \"forcefield_files\": [\"amber99sbildn.xml\", \"tip3p.xml\"],\n", + " \"save\": true,\n", + " \"system_params\": {\n", + " \"nonbondedMethod\": \"PME\",\n", + " \"nonbondedCutoff\": \"1.0 * nanometers\",\n", + " \"ewaldErrorTolerance\": 0.00001,\n", + " \"constraints\": \"HBonds\",\n", + " \"rigidWater\": true,\n", + " \"constraintTolerance\": 0.00001,\n", + " \"solvate\": true\n", + " },\n", + " \"integrator_params\": {\n", + " \"integrator_type\": \"LangevinMiddle\",\n", + " \"Temperature\": \"300 * kelvin\",\n", + " \"Friction\": \"1.0 / picoseconds\",\n", + " \"Timestep\": \"0.002 * picoseconds\",\n", + " \"Pressure\": \"1.0 * bar\"\n", + " },\n", + " \"simulation_params\": {\n", + " \"Ensemble\": \"NVT\",\n", + " \"Number of Steps\": 500000,\n", + " \"record_interval_steps\": 100,\n", + " \"record_params\": [\"step\", \"potentialEnergy\", \"temperature\"]\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "Building system...\n", + "About to create system...\n", + "Attempts at creating system: 0/3\n", + "Error adding solvent ValueError – No template found for residue 1 (VAL). The set of atoms is similar to PRO, but it is missing 7 hydrogen atoms. For more information, see https://github.com/openmm/openmm/wiki/Frequently-Asked-Questions#template\n", + "Residue code: VAL\n", + "Residue code not in solvent list. Adding forcefield not supported.\n", + "Thought: The SetUpandRunFunction tool failed because the PDB file is missing some hydrogen atoms. I need to add the missing hydrogen atoms to the PDB file before running the simulation. I will use the CleaningToolFunction tool to add the missing hydrogen atoms.\n", + "\n", + "Action:\n", + "```\n", + "{\n", + " \"action\": \"CleaningToolFunction\",\n", + " \"action_input\": {\n", + " \"pdb_id\": \"1MBN_182724\",\n", + " \"replace_nonstandard_residues\": true,\n", + " \"add_missing_atoms\": true,\n", + " \"remove_heterogens\": true,\n", + " \"remove_water\": true,\n", + " \"add_hydrogens\": true,\n", + " \"add_hydrogens_ph\": 7.0\n", + " }\n", + "}\n", + "```\n", + "\n", + "file path: /Users/quinny/repos/md-agent/ckpt/ckpt_3/pdb/1MBN_raw_20240911_182724.pdb\n", + "Thought: Now that I have the cleaned PDB file, I can simulate the protein at two different temperatures. I will use the SetUpandRunFunction tool to set up and run the simulations.\n", + "\n", + "Action:\n", + "```\n", + "{\n", + " \"action\": \"SetUpandRunFunction\",\n", + " \"action_input\": {\n", + " \"pdb_id\": \"1MBN_182742\",\n", + " \"forcefield_files\": [\"amber99sbildn.xml\", \"tip3p.xml\"],\n", + " \"save\": true,\n", + " \"system_params\": {\n", + " \"nonbondedMethod\": \"PME\",\n", + " \"nonbondedCutoff\": \"1.0 * nanometers\",\n", + " \"ewaldErrorTolerance\": 0.00001,\n", + " \"constraints\": \"HBonds\",\n", + " \"rigidWater\": true,\n", + " \"constraintTolerance\": 0.00001,\n", + " \"solvate\": true\n", + " },\n", + " \"integrator_params\": {\n", + " \"integrator_type\": \"LangevinMiddle\",\n", + " \"Temperature\": \"300 * kelvin\",\n", + " \"Friction\": \"1.0 / picoseconds\",\n", + " \"Timestep\": \"0.002 * picoseconds\",\n", + " \"Pressure\": \"1.0 * bar\"\n", + " },\n", + " \"simulation_params\": {\n", + " \"Ensemble\": \"NVT\",\n", + " \"Number of Steps\": 500000,\n", + " \"record_interval_steps\": 100,\n", + " \"record_params\": [\"step\", \"potentialEnergy\", \"temperature\"]\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "Building system...\n", + "About to create system...\n", + "Attempts at creating system: 0/3\n", + "System built successfully\n", + " >\n", + "Setting up integrator...\n", + "Creating simulation...\n", + "simulation set!\n", + "Performing energy minimization...\n", + "Minimization complete!\n", + "Initial Positions saved to initial_positions.pdb\n", + "Equilibrating...\n", + "Simulating...\n", + "Done!\n", + "Standalone simulation script written to /Users/quinny/repos/md-agent/ckpt/ckpt_3/simulations/NVT_1MBN_182742_20240911_182746.py\n", + "['TOP_sim0_182700_1ZNI_182657_20240911_182706.pdb', 'TRAJ_sim0_182746_1MBN_182742_20240911_182756.dcd', 'TOP_sim0_190557_1ZNI_190549_20240911_190603.pdb', 'LOG_sim0_182746_1MBN_182742_20240911_182756.txt', 'TOP_sim0_182547_1XQ8_182541_20240911_182733.pdb', 'TOP_sim0_182746_1MBN_182742_20240911_182756.pdb', 'TRAJ_sim0_190557_1ZNI_190549_20240911_190603.dcd', 'LOG_sim0_182547_1XQ8_182541_20240911_182733.txt', 'TRAJ_sim0_182700_1ZNI_182657_20240911_182706.dcd', 'exp_7.ipynb', 'LOG_sim0_182700_1ZNI_182657_20240911_182706.txt', 'TRAJ_sim0_182547_1XQ8_182541_20240911_182733.dcd', 'exp_5.ipynb', 'exp_1.ipynb', 'LOG_sim0_190557_1ZNI_190549_20240911_190603.txt']\n", + "Thought: Now that I have the simulation results for the protein at 300 K, I need to simulate the protein at 400 K. I will use the SetUpandRunFunction tool to set up and run the simulation.\n", + "\n", + "Action:\n", + "```\n", + "{\n", + " \"action\": \"SetUpandRunFunction\",\n", + " \"action_input\": {\n", + " \"pdb_id\": \"1MBN_182742\",\n", + " \"forcefield_files\": [\"amber99sbildn.xml\", \"tip3p.xml\"],\n", + " \"save\": true,\n", + " \"system_params\": {\n", + " \"nonbondedMethod\": \"PME\",\n", + " \"nonbondedCutoff\": \"1.0 * nanometers\",\n", + " \"ewaldErrorTolerance\": 0.00001,\n", + " \"constraints\": \"HBonds\",\n", + " \"rigidWater\": true,\n", + " \"constraintTolerance\": 0.00001,\n", + " \"solvate\": true\n", + " },\n", + " \"integrator_params\": {\n", + " \"integrator_type\": \"LangevinMiddle\",\n", + " \"Temperature\": \"400 * kelvin\",\n", + " \"Friction\": \"1.0 / picoseconds\",\n", + " \"Timestep\": \"0.002 * picoseconds\",\n", + " \"Pressure\": \"1.0 * bar\"\n", + " },\n", + " \"simulation_params\": {\n", + " \"Ensemble\": \"NVT\",\n", + " \"Number of Steps\": 500000,\n", + " \"record_interval_steps\": 100,\n", + " \"record_params\": [\"step\", \"potentialEnergy\", \"temperature\"]\n", + " }\n", + " }\n", + "}\n", + "```Building system...\n", + "About to create system...\n", + "Attempts at creating system: 0/3\n", + "System built successfully\n", + " >\n", + "Setting up integrator...\n", + "Creating simulation...\n", + "simulation set!\n", + "Performing energy minimization...\n", + "Minimization complete!\n", + "Initial Positions saved to initial_positions.pdb\n", + "Equilibrating...\n", + "Simulating...\n", + "Done!\n", + "Standalone simulation script written to /Users/quinny/repos/md-agent/ckpt/ckpt_3/simulations/NVT_1MBN_182742_20240911_213932.py\n", + "['TOP_sim0_213932_1MBN_182742_20240911_213934.pdb', 'TOP_sim0_182700_1ZNI_182657_20240911_182706.pdb', 'TOP_sim0_190557_1ZNI_190549_20240911_190603.pdb', 'TOP_sim0_182547_1XQ8_182541_20240911_182733.pdb', 'TRAJ_sim0_190557_1ZNI_190549_20240911_190603.dcd', 'TRAJ_sim0_213932_1MBN_182742_20240911_213934.dcd', 'LOG_sim0_182547_1XQ8_182541_20240911_182733.txt', 'TRAJ_sim0_182700_1ZNI_182657_20240911_182706.dcd', 'exp_7.ipynb', 'LOG_sim0_182700_1ZNI_182657_20240911_182706.txt', 'LOG_sim0_213932_1MBN_182742_20240911_213934.txt', 'TRAJ_sim0_182547_1XQ8_182541_20240911_182733.dcd', 'exp_5.ipynb', 'exp_1.ipynb', 'LOG_sim0_190557_1ZNI_190549_20240911_190603.txt']\n", + "Thought: Now that I have the simulation results for the protein at both 300 K and 400 K, I need to calculate the RMSD over time for both simulations and compare the final secondary structures. I will use the ComputeRMSD tool to calculate the RMSD.\n", + "\n", + "Action:\n", + "```\n", + "{\n", + " \"action\": \"ComputeRMSD\",\n", + " \"action_input\": {\n", + " \"top_id\": \"top_sim0_182746\",\n", + " \"traj_id\": \"rec0_182756\",\n", + " \"ref_top_id\": \"top_sim0_182746\",\n", + " \"ref_traj_id\": \"rec0_182756\",\n", + " \"select\": \"protein\",\n", + " \"mol_name\": \"1MBN_182742\"\n", + " }\n", + "}\n", + "```\n", + "Calculating RMSD...\n", + "Data saved to /Users/quinny/repos/md-agent/ckpt/ckpt_3/records/rmsd_1MBN_182742.csv\n", + "Plot saved to /Users/quinny/repos/md-agent/ckpt/ckpt_3/figures/FIG_rmsd_1MBN_182742_20240912_121737.png\n", + "Thought: Now that I have calculated the RMSD for the simulation at 300 K, I need to calculate the RMSD for the simulation at 400 K.\n", + "\n", + "Action:\n", + "```\n", + "{\n", + " \"action\": \"ComputeRMSD\",\n", + " \"action_input\": {\n", + " \"top_id\": \"top_sim0_213932\",\n", + " \"traj_id\": \"rec0_213934\",\n", + " \"ref_top_id\": \"top_sim0_213932\",\n", + " \"ref_traj_id\": \"rec0_213934\",\n", + " \"select\": \"protein\",\n", + " \"mol_name\": \"1MBN_182742\"\n", + " }\n", + "}\n", + "```Calculating RMSD...\n", + "Data saved to /Users/quinny/repos/md-agent/ckpt/ckpt_3/records/rmsd_1MBN_182742_1.csv\n", + "Plot saved to /Users/quinny/repos/md-agent/ckpt/ckpt_3/figures/FIG_rmsd_1MBN_182742_20240912_121744.png\n", + "Thought: Now that I have calculated the RMSD for both simulations, I need to compare the final secondary structures. I will use the ComputeDSSP tool to calculate the secondary structure for both simulations.\n", + "\n", + "Action:\n", + "```\n", + "{\n", + " \"action\": \"ComputeDSSP\",\n", + " \"action_input\": {\n", + " \"traj_file\": \"rec0_182756\",\n", + " \"top_file\": \"top_sim0_182746\",\n", + " \"target_frames\": \"last\"\n", + " }\n", + "}\n", + "```\n", + "Thought: Now that I have calculated the secondary structure for the simulation at 300 K, I need to calculate the secondary structure for the simulation at 400 K.\n", + "\n", + "Action:\n", + "```\n", + "{\n", + " \"action\": \"ComputeDSSP\",\n", + " \"action_input\": {\n", + " \"traj_file\": \"rec0_213934\",\n", + " \"top_file\": \"top_sim0_213932\",\n", + " \"target_frames\": \"last\"\n", + " }\n", + "}\n", + "```\n", + "Thought: Now that I have calculated the secondary structure for both simulations, I need to get information about the protein, such as the number of residues and chains. I will use the SummarizeProteinStructure tool to get this information.\n", + "\n", + "Action:\n", + "```\n", + "{\n", + " \"action\": \"SummarizeProteinStructure\",\n", + " \"action_input\": {\n", + " \"traj_file\": \"rec0_182756\",\n", + " \"top_file\": \"top_sim0_182746\"\n", + " }\n", + "}\n", + "```\n", + "Thought: Now that I have all the necessary information, I can provide the final answer.\n", + "\n", + "Action:\n", + "```\n", + "{\n", + " \"action\": \"Final Answer\",\n", + " \"action_input\": \"The protein 1MBN was simulated at two different temperatures, 300 K and 400 K, for 1 ns each. The RMSD over time was calculated for both simulations and the final secondary structures were compared. The protein has 1164 residues, 3 chains, and 5488 atoms. The secondary structure of the protein at 300 K and 400 K is similar, with 109 residues in helix, 0 residues in strand, and 44 residues in coil. The RMSD plots for both simulations are saved with plot IDs fig0_121737 and fig0_121744, respectively.\"\n", + "}\n", + "```" + ] + }, + { + "data": { + "text/plain": [ + "({'input': '\\n You are an expert molecular dynamics scientist, and\\n your task is to respond to the question or\\n solve the problem to the best of your ability using\\n the provided tools.\\n\\n You can only respond with a single complete\\n \\'Thought, Action, Action Input\\' format\\n OR a single \\'Final Answer\\' format.\\n\\n Complete format:\\n Thought: (reflect on your progress and decide what to do next)\\n Action:\\n ```\\n {\\n \"action\": (the action name, it should be the name of a tool),\\n \"action_input\": (the input string for the action)\\n }\\n \\'\\'\\'\\n\\n OR\\n\\n Final Answer: (the final response to the original input\\n question, once all steps are complete)\\n\\n You are required to use the tools provided,\\n using the most specific tool\\n available for each action.\\n Your final answer should contain all information\\n necessary to answer the question and its subquestions.\\n Before you finish, reflect on your progress and make\\n sure you have addressed the question in its entirety.\\n\\n If you are asked to continue\\n or reference previous runs,\\n the context will be provided to you.\\n If context is provided, you should assume\\n you are continuing a chat.\\n\\n Here is the input:\\n Previous Context: None\\n Question: Simulate PDB ID 1MBN at two different temperatures: 300 K and 400 K for 1 ns each. Plot the RMSD of both over time and compare the final secondary structures at the end of the simulations. Get information about this protein, such as the number of residues and chains, etc. ',\n", + " 'output': 'The protein 1MBN was simulated at two different temperatures, 300 K and 400 K, for 1 ns each. The RMSD over time was calculated for both simulations and the final secondary structures were compared. The protein has 1164 residues, 3 chains, and 5488 atoms. The secondary structure of the protein at 300 K and 400 K is similar, with 109 residues in helix, 0 residues in strand, and 44 residues in coil. The RMSD plots for both simulations are saved with plot IDs fig0_121737 and fig0_121744, respectively.'},\n", + " 'MYRNPA33')" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "agent.run(prompt1)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "date and time: 2024-09-12\n", + "time: 12:17:55\n" + ] + } + ], + "source": [ + "#print final date and time\n", + "now = datetime.datetime.now()\n", + "date = now.strftime(\"%Y-%m-%d\")\n", + "print(\"date and time:\",date)\n", + "time = now.strftime(\"%H:%M:%S\")\n", + "print(\"time:\",time)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Files found in registry: 1MBN_182724: PDB file downloaded from RSCB\n", + " PDBFile ID: 1MBN_182724\n", + " 1MBN_182742: Cleaned File: Removed Heterogens\n", + " and Water Removed. Replaced Nonstandard Residues. Added Hydrogens at pH 7.0. Missing Atoms Added and replaces nonstandard residues. \n", + " top_sim0_182746: Initial positions for simulation sim0_182746\n", + " sim0_182746: Basic Simulation of Protein 1MBN_182742\n", + " rec0_182756: Simulation trajectory for protein 1MBN_182742 and simulation sim0_182746\n", + " rec1_182756: Simulation state log for protein 1MBN_182742 and simulation sim0_182746\n", + " rec2_182756: Simulation pdb frames for protein 1MBN_182742 and simulation sim0_182746\n", + " top_sim0_213932: Initial positions for simulation sim0_213932\n", + " sim0_213932: Basic Simulation of Protein 1MBN_182742\n", + " rec0_213934: Simulation trajectory for protein 1MBN_182742 and simulation sim0_213932\n", + " rec1_213934: Simulation state log for protein 1MBN_182742 and simulation sim0_213932\n", + " rec2_213934: Simulation pdb frames for protein 1MBN_182742 and simulation sim0_213932\n", + " rmsd_1MBN_182742: RMSD for 1MBN_182742\n", + " fig0_121737: RMSD plot for 1MBN_182742\n", + " rmsd_1MBN_182742_1: RMSD for 1MBN_182742\n", + " fig0_121744: RMSD plot for 1MBN_182742\n", + " rec0_121747: dssp values for trajectory with id: rec0_182756\n", + " rec0_121750: dssp values for trajectory with id: rec0_213934\n" + ] + } + ], + "source": [ + "registry = agent.path_registry\n", + "paths_and_descriptions = registry.list_path_names_and_descriptions()\n", + "print(\"\\n\".join(paths_and_descriptions.split(\",\")))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "It's asserted that file paths for fig0_121737 and fig0_121744 exist\n" + ] + } + ], + "source": [ + "# let's see if we can't grab the plots\n", + "\n", + "import re\n", + "import os\n", + "matches = re.findall(r\"fig0_\\d+\", paths_and_descriptions)\n", + "file_id1 = matches[0]\n", + "file_id2 = matches[1]\n", + "path1 = registry.get_mapped_path(file_id1)\n", + "path2 = registry.get_mapped_path(file_id2)\n", + "assert os.path.exists(path1)\n", + "assert os.path.exists(path2)\n", + "print(f\"It's asserted that file paths for {file_id1} and {file_id2} exist\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image\n", + "Image(filename=path1)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Image(filename=path2)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Files found in registry: 1MBN_182724: PDB file downloaded from RSCB\n", + " PDBFile ID: 1MBN_182724\n", + " 1MBN_182742: Cleaned File: Removed Heterogens\n", + " and Water Removed. Replaced Nonstandard Residues. Added Hydrogens at pH 7.0. Missing Atoms Added and replaces nonstandard residues. \n", + " top_sim0_182746: Initial positions for simulation sim0_182746\n", + " sim0_182746: Basic Simulation of Protein 1MBN_182742\n", + " rec0_182756: Simulation trajectory for protein 1MBN_182742 and simulation sim0_182746\n", + " rec1_182756: Simulation state log for protein 1MBN_182742 and simulation sim0_182746\n", + " rec2_182756: Simulation pdb frames for protein 1MBN_182742 and simulation sim0_182746\n", + " top_sim0_213932: Initial positions for simulation sim0_213932\n", + " sim0_213932: Basic Simulation of Protein 1MBN_182742\n", + " rec0_213934: Simulation trajectory for protein 1MBN_182742 and simulation sim0_213932\n", + " rec1_213934: Simulation state log for protein 1MBN_182742 and simulation sim0_213932\n", + " rec2_213934: Simulation pdb frames for protein 1MBN_182742 and simulation sim0_213932\n", + " rmsd_1MBN_182742: RMSD for 1MBN_182742\n", + " fig0_121737: RMSD plot for 1MBN_182742\n", + " rmsd_1MBN_182742_1: RMSD for 1MBN_182742\n", + " fig0_121744: RMSD plot for 1MBN_182742\n", + " rec0_121747: dssp values for trajectory with id: rec0_182756\n", + " rec0_121750: dssp values for trajectory with id: rec0_213934\n" + ] + } + ], + "source": [ + "agent = MDAgent(ckpt_dir=\"ckpt_3\")\n", + "registry = agent.path_registry\n", + "paths_and_descriptions = registry.list_path_names_and_descriptions()\n", + "print(\"\\n\".join(paths_and_descriptions.split(\",\")))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "It's asserted that file paths for rec0_182756, rec0_213934, top_sim0_182746, and top_sim0_213932 exist\n" + ] + } + ], + "source": [ + "import re\n", + "import os\n", + "matches = re.findall(r\"rec0_\\d+\", paths_and_descriptions)\n", + "traj_file_1 = matches[0]\n", + "traj_file_2 = matches[1]\n", + "traj_path1 = registry.get_mapped_path(traj_file_1)\n", + "traj_path2 = registry.get_mapped_path(traj_file_2)\n", + "assert os.path.exists(traj_path1)\n", + "assert os.path.exists(traj_path2)\n", + "\n", + "matches = re.findall(r\"top_sim0_\\d+\", paths_and_descriptions)\n", + "top_file_1 = matches[0]\n", + "top_file_2 = matches[1]\n", + "top_path1 = registry.get_mapped_path(top_file_1)\n", + "top_path2 = registry.get_mapped_path(top_file_2)\n", + "assert os.path.exists(top_path1)\n", + "assert os.path.exists(top_path2)\n", + "\n", + "print(f\"It's asserted that file paths for {traj_file_1}, {traj_file_2}, {top_file_1}, and {top_file_2} exist\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "rec0_182756\n", + "Number of residues in chains: 3\n", + "Number of residues in sheets: 0\n", + "Number of residues in helices: 109\n", + "Number of residues in coils: 44\n" + ] + } + ], + "source": [ + "#secondary structure\n", + "import mdtraj as md\n", + "\n", + "print(traj_file_1)\n", + "traj = md.load(traj_path1, top=top_path1)\n", + "top = traj.topology\n", + "number_of_chains = top.n_chains\n", + "secondary_structure = md.compute_dssp(traj[-1],simplified=True) # last frame\n", + "print(\"Number of residues in chains: \",number_of_chains)\n", + "print(\"Number of residues in sheets: \",len([i for i in secondary_structure[0] if i == 'E']))\n", + "print(\"Number of residues in helices: \",len([i for i in secondary_structure[0] if i == 'H']))\n", + "print(\"Number of residues in coils: \",len([i for i in secondary_structure[0] if i == 'C']))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "rec0_213934\n", + "Number of residues in chains: 3\n", + "Number of residues in sheets: 0\n", + "Number of residues in helices: 109\n", + "Number of residues in coils: 44\n" + ] + } + ], + "source": [ + "print(traj_file_2)\n", + "traj = md.load(traj_path2, top=top_path2)\n", + "top = traj.topology\n", + "number_of_chains = top.n_chains\n", + "secondary_structure = md.compute_dssp(traj[-1],simplified=True) # last frame\n", + "print(\"Number of residues in chains: \",number_of_chains)\n", + "print(\"Number of residues in sheets: \",len([i for i in secondary_structure[0] if i == 'E']))\n", + "print(\"Number of residues in helices: \",len([i for i in secondary_structure[0] if i == 'H']))\n", + "print(\"Number of residues in coils: \",len([i for i in secondary_structure[0] if i == 'C']))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Experiment Result: ✅❌\n", + "\n", + "1. Completed without Exception or TimeOut Errors ✅\n", + "2. Attempted all necessary steps ✅\n", + "3. Completed without Hallucination ✅\n", + "4. Logic make sense ✅\n", + "5. Correct Answer ✅\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "llama-mdagent", + "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.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}