You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension: \n jupyter labextension install jupyterlab_3dmol
\n
\n",
+ "text/html": [
+ "
\n",
+ "
You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension: \n",
+ " jupyter labextension install jupyterlab_3dmol
\n",
+ "
\n",
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# make structure visualization function\n",
+ "def plot_recycling_iteration(df_row, colnames, exp_colname, colors=('blue','purple')):\n",
+ " for i, c in enumerate(colnames):\n",
+ " view.addModel(open(df_row[exp_colname], \"r\").read(), \"pdb\", viewer=(i, df_row['recycling_iteration']))\n",
+ " view.addModel(open(df_row[c], \"r\").read(), \"pdb\", viewer=(i, df_row['recycling_iteration']))\n",
+ " \n",
+ " view.setStyle({'model':0}, {'cartoon':{'color':'white'}}, viewer=(i, df_row['recycling_iteration']))\n",
+ " view.setStyle({'model':1}, {'cartoon':{'color':colors[i]}}, viewer=(i, df_row['recycling_iteration']))\n",
+ "\n",
+ "# visualize structural representations across recycling iterations \n",
+ "pdb_name = \"1EX7_A\"\n",
+ "manipulations = ('none', 'template')\n",
+ "exp_colname = 'exp_same_fname'\n",
+ "\n",
+ "example_df = (conf_df\n",
+ " .query(f\"name == '{pdb_name}'\")\n",
+ " .pivot(columns='manipulation', values='af_fname', index=['name', exp_colname, 'recycling_iteration'])\n",
+ " .reset_index()\n",
+ " .sort_values('recycling_iteration'))\n",
+ "\n",
+ "aligned_colnames = [f'{m}_aligned' for m in manipulations]\n",
+ "for m in manipulations:\n",
+ " example_df[f'{m}_aligned'] = example_df.apply(lambda x: align_structures(x[exp_colname], x[m]), axis=1)\n",
+ " \n",
+ "view = py3Dmol.view(js=\"https://3dmol.org/build/3Dmol.js\", viewergrid=(2, 6))\n",
+ "example_df.apply(lambda x: plot_recycling_iteration(x, aligned_colnames, exp_colname), axis=1)\n",
+ "view.zoomTo()\n",
+ "view.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cc06bc8-ef9b-4fc4-a1a1-dc63ee66734b",
+ "metadata": {
+ "tags": []
+ },
+ "source": [
+ "**3D structural representations across recycling iterations**\n",
+ "\n",
+ "Each column indicates a recycling iteration (left = start of AF run, right = end)\n",
+ "Top row is the AF structural output without any manipulations (blue = AF prediction, white = experimental structure)\n",
+ "Bottom row is the AF structural output with manipulations (purple = AF prediction, white = experimental structure)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9a755104-7454-4c59-a437-41d2544e7c7a",
+ "metadata": {
+ "tags": []
+ },
+ "source": [
+ "## Correlation between intermediate pair representations and structural outputs"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "85b4571c-dfaf-4700-b906-f6771a3eef06",
+ "metadata": {},
+ "source": [
+ "### Data setup"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "9dd47aca-04d2-4bac-acb6-0a5e744861ce",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "# calc distance between pair representations\n",
+ "def get_euclidean_distance(pair1, pair2):\n",
+ " with open(pair1, 'rb') as file:\n",
+ " pair1_data = pickle.load(file)\n",
+ " with open(pair2, 'rb') as file:\n",
+ " pair2_data = pickle.load(file)\n",
+ "\n",
+ " # calculate distance between pair representations \n",
+ " # note - have to divide and remultiply max bc float16 too small, still some overflow warnings\n",
+ " diff_a_b = pair1_data['representations']['pair'] - pair2_data['representations']['pair']\n",
+ " # a_b_max = np.max(diff_a_b) \n",
+ " # norm = scipy.linalg.norm(diff_a_b / a_b_max) * a_b_max \n",
+ " norm = scipy.linalg.norm(diff_a_b.astype(np.float32))\n",
+ " distance = norm / np.sqrt(np.size(pair1_data['representations']['pair']))\n",
+ " \n",
+ " return distance\n",
+ "\n",
+ "def get_cosine_similarity(pair1, pair2):\n",
+ " with open(pair1, 'rb') as file:\n",
+ " pair1_data = pickle.load(file)\n",
+ " with open(pair2, 'rb') as file:\n",
+ " pair2_data = pickle.load(file)\n",
+ "\n",
+ " # calculate cosine similarity between pair representations \n",
+ " a = pair1_data['representations']['pair'].flatten().astype(np.float32)\n",
+ " b = pair2_data['representations']['pair'].flatten().astype(np.float32)\n",
+ " similarity = np.dot(a, b) / (scipy.linalg.norm(a) * scipy.linalg.norm(b))\n",
+ " \n",
+ " return similarity\n",
+ "\n",
+ "def get_similarity_data(seqs, combos):\n",
+ " distance_data = []\n",
+ " for i, seq in enumerate(seqs):\n",
+ " print(f'Calculating distances for {seq} ({i} / {len(seqs)})...')\n",
+ " for (model1, model2), (recycling1, recycling2) in combos:\n",
+ " # load intermediate pair representations and structure representations\n",
+ " struct1 = glob.glob(f'{output_dir}//{seq}*rank_00{model1}*.r{recycling1}.pdb')[0]\n",
+ " struct2 = glob.glob(f'{output_dir}//{seq}*rank_00{model2}*.r{recycling2}.pdb')[0]\n",
+ "\n",
+ " pair1 = glob.glob(f'{output_dir}//{seq}*rank_00{model1}*.r{recycling1}.pickle')[0]\n",
+ " pair2 = glob.glob(f'{output_dir}//{seq}*rank_00{model2}*.r{recycling2}.pickle')[0]\n",
+ "\n",
+ " # calculate RMSD between structures\n",
+ " rmsd = get_rmsd(struct1, struct2)\n",
+ "\n",
+ " # calculate approximate LDDT between structures\n",
+ " lddt = get_lddt(struct1, struct2)\n",
+ "\n",
+ " # calculate euclidean distance\n",
+ " distance = get_euclidean_distance(pair1, pair2)\n",
+ " \n",
+ " # calculate cosine similarity\n",
+ " cosine_similarity = get_cosine_similarity(pair1, pair2)\n",
+ "\n",
+ " # add comparison labels\n",
+ " recycling_comparison = f'{recycling1} vs. {recycling2}'\n",
+ " model_comparison = f'{model1} vs. {model2}'\n",
+ "\n",
+ " distance_data.append((dict(sequence_name=seq, \n",
+ " val1_model=model1, \n",
+ " val2_model=model2, \n",
+ " val1_recycling=recycling1, \n",
+ " val2_recycling=recycling2,\n",
+ " recycling_comparison=recycling_comparison,\n",
+ " rmsd=rmsd, \n",
+ " lddt=lddt,\n",
+ " distance=distance,\n",
+ " cosine_similarity=cosine_similarity)))\n",
+ " return pd.DataFrame(distance_data)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ebf7ce51-d80e-43b3-a2b4-b6585bf9e9cf",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Calculating distances for 1AEL-12_A (0 / 91)...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Calculating distances for 1BV2-3_A (1 / 91)...\n",
+ "Calculating distances for 1C54-19_A (2 / 91)...\n",
+ "Calculating distances for 1EAL-2_A (3 / 91)...\n",
+ "Calculating distances for 1F3Y-17_A (4 / 91)...\n",
+ "Calculating distances for 1FMF-4_A (5 / 91)...\n",
+ "Calculating distances for 1GH1-7_A (6 / 91)...\n",
+ "Calculating distances for 1GQN_A (7 / 91)...\n",
+ "Calculating distances for 1GQZ_A (8 / 91)...\n",
+ "Calculating distances for 1HSI_B (9 / 91)...\n",
+ "Calculating distances for 1I56_A (10 / 91)...\n",
+ "Calculating distances for 1IGP_A (11 / 91)...\n",
+ "Calculating distances for 1JFJ-3_A (12 / 91)...\n",
+ "Calculating distances for 1K2H-4_A (13 / 91)...\n",
+ "Calculating distances for 1LIP-2_A (14 / 91)...\n",
+ "Calculating distances for 1MUT-11_A (15 / 91)...\n",
+ "Calculating distances for 1MX7-20_A (16 / 91)...\n",
+ "Calculating distances for 1NTR-7_A (17 / 91)...\n",
+ "Calculating distances for 1O1U-9_A (18 / 91)...\n",
+ "Calculating distances for 1PDB_A (19 / 91)...\n",
+ "Calculating distances for 1TFU_A (20 / 91)...\n",
+ "Calculating distances for 1TJD_A (21 / 91)...\n",
+ "Calculating distances for 1XSA-23_A (22 / 91)...\n",
+ "Calculating distances for 1Z15_A (23 / 91)...\n",
+ "Calculating distances for 2CJO-5_A (24 / 91)...\n",
+ "Calculating distances for 2D9E-12_A (25 / 91)...\n",
+ "Calculating distances for 2F63-4_A (26 / 91)...\n",
+ "Calculating distances for 2FHM-12_A (27 / 91)...\n",
+ "Calculating distances for 2IN2_A (28 / 91)...\n",
+ "Calculating distances for 2JU3-3_A (29 / 91)...\n",
+ "Calculating distances for 2JWW-13_A (30 / 91)...\n",
+ "Calculating distances for 2K43-1_A (31 / 91)...\n",
+ "Calculating distances for 2L50-24_A (32 / 91)...\n",
+ "Calculating distances for 2L68-9_A (33 / 91)...\n",
+ "Calculating distances for 2LAO_A (34 / 91)...\n",
+ "Calculating distances for 2LHS-6_A (35 / 91)...\n",
+ "Calculating distances for 2NLN-4_A (36 / 91)...\n",
+ "Calculating distances for 2P3M-16_A (37 / 91)...\n",
+ "Calculating distances for 2UZ5-9_A (38 / 91)...\n",
+ "Calculating distances for 4AKE_B (39 / 91)...\n",
+ "Calculating distances for 1IJA-15_A (40 / 91)...\n",
+ "Calculating distances for 1JM4-15_B (41 / 91)...\n",
+ "Calculating distances for 1MO7-3_A (42 / 91)...\n",
+ "Calculating distances for 1SKT-10_A (43 / 91)...\n",
+ "Calculating distances for 1SYM-2_B (44 / 91)...\n",
+ "Calculating distances for 1W4U-9_A (45 / 91)...\n",
+ "Calculating distances for 2KXL-8_A (46 / 91)...\n",
+ "Calculating distances for 2LKC-4_A (47 / 91)...\n",
+ "Calculating distances for 1LMZ-9_A (48 / 91)...\n",
+ "Calculating distances for 2CG7_A (49 / 91)...\n",
+ "Calculating distances for 2BNH_A (50 / 91)...\n",
+ "Calculating distances for 1URP_D (51 / 91)...\n",
+ "Calculating distances for 1ORM-9_A (52 / 91)...\n",
+ "Calculating distances for 1PFL-19_A (53 / 91)...\n",
+ "Calculating distances for 1FSF_A (54 / 91)...\n",
+ "Calculating distances for 1AKZ_A (55 / 91)...\n"
+ ]
+ }
+ ],
+ "source": [
+ "# for each model, compare the final output structures\n",
+ "model_combos = list(itertools.combinations(range(1,6), 2))\n",
+ "model_combos = [(c, (5, 5)) for c in model_combos]\n",
+ "model_df = get_similarity_data(pair_df['apo_id'].to_list(), model_combos)\n",
+ "model_df['log_distance'] = np.log(model_df['distance'])\n",
+ "model_df.head()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5400ae3f-45a5-4425-b50a-cdc5ba2375b7",
+ "metadata": {},
+ "source": [
+ "### Visualization"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 171,
+ "id": "065d84fa-e957-4d46-8ceb-47ece54be52f",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# plots with RMSD vs. pair distance\n",
+ "fig, ax = plt.subplots(figsize=(3, 3))\n",
+ "g = sns.regplot(data=model_df,\n",
+ " x=\"distance\", \n",
+ " y=\"lddt\", \n",
+ " ax=ax,\n",
+ " color='k',\n",
+ " ci=None,\n",
+ " scatter_kws={'s':7, 'edgecolors':'white', 'linewidths':0.3}, \n",
+ " #scatter_kws={'s':7, 'facecolors':'white', 'edgecolors': 'k', 'linewidths': 0.3}\n",
+ ")\n",
+ "g.figure.suptitle('Correlation between pair representations\\n and AlphaFold outputs')\n",
+ "g.set_xlabel('Euclidean distance between \\npair representations')\n",
+ "g.set_ylabel('plDDT between \\nstructural outputs')\n",
+ "r, p = pearsonr(model_df['distance'], model_df['lddt'])\n",
+ "g.text(.05, .05, '$r^2$ = {:.2f} \\np < 0.0001'.format(r**2), transform=g.transAxes)\n",
+ "g.figure.tight_layout()\n",
+ "g.annotate('', xy=(0.3, 0.04), xytext=(1.1, 0.04), xycoords='figure fraction', arrowprops=dict(arrowstyle='<|-|>'))\n",
+ "ax.annotate('more \\nsimilar', xy=(0.2,0.05), xycoords='figure fraction', ha='center', va='center',fontsize=9)\n",
+ "ax.annotate('less \\nsimilar', xy=(1.2,0.05), xycoords='figure fraction', ha='center', va='center',fontsize=9)\n",
+ "g.annotate('', xy=(0.1, 0.3), xytext=(0.1, 0.75), xycoords='figure fraction', arrowprops=dict(arrowstyle='<|-|>'))\n",
+ "g.annotate('more \\nsimilar', xy=(0.1, 0.8), xycoords='figure fraction', ha='center', va='center',fontsize=9)\n",
+ "g.annotate('less \\nsimilar', xy=(0.1, 0.25), xycoords='figure fraction', ha='center', va='center',fontsize=9)\n",
+ "sns.despine(offset=5)\n",
+ "g.figure.savefig('pair_structure_corr.png', bbox_inches='tight')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9c1b1841-4a66-4e74-a888-137d0ef19faa",
+ "metadata": {},
+ "source": [
+ "**Approach viability: correlation between intermediate representations and AlphaFold outputs.** Global plDDT scores decrease with increased distance between intermediate representations (Pearson correlation -0.58, p-value < 0.0001). Each data point represents a comparison between two AlphaFold models generated from the same sequence (n = 91 sequences, n = 910 individual comparisons (5 models x 2 per comparison x 91 sequences))."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "id": "2275af2d-0f1a-4ce1-a4b3-e1ff8220764f",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Calculating distances for 1AEL-12_A (0 / 91)...\n",
+ "Calculating distances for 1BV2-3_A (1 / 91)...\n",
+ "Calculating distances for 1C54-19_A (2 / 91)...\n",
+ "Calculating distances for 1EAL-2_A (3 / 91)...\n",
+ "Calculating distances for 1F3Y-17_A (4 / 91)...\n",
+ "Calculating distances for 1FMF-4_A (5 / 91)...\n",
+ "Calculating distances for 1GH1-7_A (6 / 91)...\n",
+ "Calculating distances for 1GQN_A (7 / 91)...\n",
+ "Calculating distances for 1GQZ_A (8 / 91)...\n",
+ "Calculating distances for 1HSI_B (9 / 91)...\n",
+ "Calculating distances for 1I56_A (10 / 91)...\n",
+ "Calculating distances for 1IGP_A (11 / 91)...\n",
+ "Calculating distances for 1JFJ-3_A (12 / 91)...\n",
+ "Calculating distances for 1K2H-4_A (13 / 91)...\n",
+ "Calculating distances for 1LIP-2_A (14 / 91)...\n",
+ "Calculating distances for 1MUT-11_A (15 / 91)...\n",
+ "Calculating distances for 1MX7-20_A (16 / 91)...\n",
+ "Calculating distances for 1NTR-7_A (17 / 91)...\n",
+ "Calculating distances for 1O1U-9_A (18 / 91)...\n",
+ "Calculating distances for 1PDB_A (19 / 91)...\n",
+ "Calculating distances for 1TFU_A (20 / 91)...\n",
+ "Calculating distances for 1TJD_A (21 / 91)...\n",
+ "Calculating distances for 1XSA-23_A (22 / 91)...\n",
+ "Calculating distances for 1Z15_A (23 / 91)...\n",
+ "Calculating distances for 2CJO-5_A (24 / 91)...\n",
+ "Calculating distances for 2D9E-12_A (25 / 91)...\n",
+ "Calculating distances for 2F63-4_A (26 / 91)...\n",
+ "Calculating distances for 2FHM-12_A (27 / 91)...\n",
+ "Calculating distances for 2IN2_A (28 / 91)...\n",
+ "Calculating distances for 2JU3-3_A (29 / 91)...\n",
+ "Calculating distances for 2JWW-13_A (30 / 91)...\n",
+ "Calculating distances for 2K43-1_A (31 / 91)...\n",
+ "Calculating distances for 2L50-24_A (32 / 91)...\n",
+ "Calculating distances for 2L68-9_A (33 / 91)...\n",
+ "Calculating distances for 2LAO_A (34 / 91)...\n",
+ "Calculating distances for 2LHS-6_A (35 / 91)...\n",
+ "Calculating distances for 2NLN-4_A (36 / 91)...\n",
+ "Calculating distances for 2P3M-16_A (37 / 91)...\n",
+ "Calculating distances for 2UZ5-9_A (38 / 91)...\n",
+ "Calculating distances for 4AKE_B (39 / 91)...\n",
+ "Calculating distances for 1IJA-15_A (40 / 91)...\n",
+ "Calculating distances for 1JM4-15_B (41 / 91)...\n",
+ "Calculating distances for 1MO7-3_A (42 / 91)...\n",
+ "Calculating distances for 1SKT-10_A (43 / 91)...\n",
+ "Calculating distances for 1SYM-2_B (44 / 91)...\n",
+ "Calculating distances for 1W4U-9_A (45 / 91)...\n",
+ "Calculating distances for 2KXL-8_A (46 / 91)...\n",
+ "Calculating distances for 2LKC-4_A (47 / 91)...\n",
+ "Calculating distances for 1LMZ-9_A (48 / 91)...\n",
+ "Calculating distances for 2CG7_A (49 / 91)...\n",
+ "Calculating distances for 2BNH_A (50 / 91)...\n",
+ "Calculating distances for 1URP_D (51 / 91)...\n",
+ "Calculating distances for 1ORM-9_A (52 / 91)...\n",
+ "Calculating distances for 1PFL-19_A (53 / 91)...\n",
+ "Calculating distances for 1FSF_A (54 / 91)...\n",
+ "Calculating distances for 1AKZ_A (55 / 91)...\n",
+ "Calculating distances for 2AI6-18_A (56 / 91)...\n",
+ "Calculating distances for 1VR6_A (57 / 91)...\n",
+ "Calculating distances for 1Y3Q_A (58 / 91)...\n",
+ "Calculating distances for 1GUD_A (59 / 91)...\n",
+ "Calculating distances for 1EX6_B (60 / 91)...\n",
+ "Calculating distances for 1WD7_B (61 / 91)...\n",
+ "Calculating distances for 1W0J_E (62 / 91)...\n",
+ "Calculating distances for 1RF5_A (63 / 91)...\n",
+ "Calculating distances for 1S2O_A (64 / 91)...\n",
+ "Calculating distances for 1K5H_A (65 / 91)...\n",
+ "Calculating distances for 1ZOL_A (66 / 91)...\n",
+ "Calculating distances for 1VIY_C (67 / 91)...\n",
+ "Calculating distances for 1ZA1_A (68 / 91)...\n",
+ "Calculating distances for 1JEJ_A (69 / 91)...\n",
+ "Calculating distances for 1HOO_B (70 / 91)...\n",
+ "Calculating distances for 1E5L_A (71 / 91)...\n",
+ "Calculating distances for 1HW1_B (72 / 91)...\n",
+ "Calculating distances for 1L0W_B (73 / 91)...\n",
+ "Calculating distances for 1OTJ_D (74 / 91)...\n",
+ "Calculating distances for 1EVK_A (75 / 91)...\n",
+ "Calculating distances for 1G6W_D (76 / 91)...\n",
+ "Calculating distances for 1NJG_B (77 / 91)...\n",
+ "Calculating distances for 1RKA_A (78 / 91)...\n",
+ "Calculating distances for 1K6W_A (79 / 91)...\n",
+ "Calculating distances for 1YL5_B (80 / 91)...\n",
+ "Calculating distances for 6OY9_B (81 / 91)...\n",
+ "Calculating distances for 1A6D_A (82 / 91)...\n",
+ "Calculating distances for 2RCS_H (83 / 91)...\n",
+ "Calculating distances for 1AW2_A (84 / 91)...\n",
+ "Calculating distances for 1RKM_A (85 / 91)...\n",
+ "Calculating distances for 7AZP_A (86 / 91)...\n",
+ "Calculating distances for 4LP5_A (87 / 91)...\n",
+ "Calculating distances for 1CFC_A (88 / 91)...\n",
+ "Calculating distances for 2KQ2-6_A (89 / 91)...\n",
+ "Calculating distances for 1DMO-18_A (90 / 91)...\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
sequence_name
\n",
+ "
val1_model
\n",
+ "
val2_model
\n",
+ "
val1_recycling
\n",
+ "
val2_recycling
\n",
+ "
recycling_comparison
\n",
+ "
rmsd
\n",
+ "
lddt
\n",
+ "
distance
\n",
+ "
cosine_similarity
\n",
+ "
\n",
+ " \n",
+ " \n",
+ "
\n",
+ "
0
\n",
+ "
1AEL-12_A
\n",
+ "
1
\n",
+ "
1
\n",
+ "
0
\n",
+ "
1
\n",
+ "
0vs1
\n",
+ "
0.262049
\n",
+ "
0.981923
\n",
+ "
2.411981
\n",
+ "
0.996727
\n",
+ "
\n",
+ "
\n",
+ "
1
\n",
+ "
1AEL-12_A
\n",
+ "
1
\n",
+ "
1
\n",
+ "
1
\n",
+ "
2
\n",
+ "
1vs2
\n",
+ "
0.066101
\n",
+ "
0.998367
\n",
+ "
1.184137
\n",
+ "
0.999157
\n",
+ "
\n",
+ "
\n",
+ "
2
\n",
+ "
1AEL-12_A
\n",
+ "
1
\n",
+ "
1
\n",
+ "
2
\n",
+ "
3
\n",
+ "
2vs3
\n",
+ "
0.029745
\n",
+ "
1.000000
\n",
+ "
0.726376
\n",
+ "
0.999650
\n",
+ "
\n",
+ "
\n",
+ "
3
\n",
+ "
1AEL-12_A
\n",
+ "
1
\n",
+ "
1
\n",
+ "
3
\n",
+ "
4
\n",
+ "
3vs4
\n",
+ "
0.030091
\n",
+ "
0.998959
\n",
+ "
0.711998
\n",
+ "
0.999670
\n",
+ "
\n",
+ "
\n",
+ "
4
\n",
+ "
1AEL-12_A
\n",
+ "
1
\n",
+ "
1
\n",
+ "
4
\n",
+ "
5
\n",
+ "
4vs5
\n",
+ "
0.028606
\n",
+ "
0.999997
\n",
+ "
0.697618
\n",
+ "
0.999681
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " sequence_name val1_model val2_model val1_recycling val2_recycling \\\n",
+ "0 1AEL-12_A 1 1 0 1 \n",
+ "1 1AEL-12_A 1 1 1 2 \n",
+ "2 1AEL-12_A 1 1 2 3 \n",
+ "3 1AEL-12_A 1 1 3 4 \n",
+ "4 1AEL-12_A 1 1 4 5 \n",
+ "\n",
+ " recycling_comparison rmsd lddt distance cosine_similarity \n",
+ "0 0vs1 0.262049 0.981923 2.411981 0.996727 \n",
+ "1 1vs2 0.066101 0.998367 1.184137 0.999157 \n",
+ "2 2vs3 0.029745 1.000000 0.726376 0.999650 \n",
+ "3 3vs4 0.030091 0.998959 0.711998 0.999670 \n",
+ "4 4vs5 0.028606 0.999997 0.697618 0.999681 "
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# for each model, compare each recycling iteration\n",
+ "recycling_combos = [(i, i+1) for i in range(5)]\n",
+ "recycling_combos = [((i, i), c) for i in range(1,6) for c in recycling_combos] \n",
+ "recycling_df = get_similarity_data(pair_df['apo_id'].to_list(), recycling_combos)\n",
+ "recycling_df.head()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 169,
+ "id": "285818ef-2edf-4ffb-a75c-17130476f923",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# plots with RMSD/LDDT differences between iterations\n",
+ "value_vars = ['distance', 'lddt']\n",
+ "temp_df = recycling_df.melt(id_vars=['sequence_name', 'recycling_comparison'], \n",
+ " value_vars=value_vars, \n",
+ " value_name='value', \n",
+ " var_name='metric')\n",
+ "\n",
+ "g = sns.catplot(\n",
+ " data=temp_df, x=\"recycling_comparison\", y='value',col='metric', hue='sequence_name', kind='point', \n",
+ " capsize=0, errorbar=None, markersize=7, color='k', markers=None, alpha=0.1, linewidth=0.75, legend=False,\n",
+ " sharey=False, height=3, aspect=1.25\n",
+ ")\n",
+ "ylabels = ['Euclidean distance between \\nintermediate representations', 'plDDT between \\nstructural outputs',]\n",
+ "for i, ax in enumerate(g.axes[0]):\n",
+ " sns.pointplot(ax=ax,\n",
+ " data=recycling_df, x=\"recycling_comparison\", y=value_vars[i],\n",
+ " capsize=0, errorbar=\"ci\", markersize=5, color='#f654a6', linewidth=2,\n",
+ " )\n",
+ " ax.set_xlabel('Recycling iterations')\n",
+ " ax.set_ylabel(ylabels[i])\n",
+ " ax.set_title('')\n",
+ "g.fig.suptitle('Representational similarity between recycling iterations')\n",
+ "g.axes[0][0].annotate('', xy=(0.06, 0.15), xytext=(0.06, 0.85), xycoords='axes fraction', arrowprops=dict(arrowstyle='<|-|>'))\n",
+ "g.axes[0][0].annotate('less \\nsimilar', xy=(0.06, 0.9), xycoords='axes fraction', ha='center', va='center',fontsize=9)\n",
+ "g.axes[0][0].annotate('more \\nsimilar', xy=(0.06, 0.1), xycoords='axes fraction', ha='center', va='center',fontsize=9)\n",
+ "g.axes[0][1].annotate('', xy=(0.06, 0.15), xytext=(0.06, 0.85), xycoords='axes fraction', arrowprops=dict(arrowstyle='<|-|>'))\n",
+ "g.axes[0][1].annotate('more \\nsimilar', xy=(0.06, 0.9), xycoords='axes fraction', ha='center', va='center',fontsize=9)\n",
+ "g.axes[0][1].annotate('less \\nsimilar', xy=(0.06, 0.1), xycoords='axes fraction', ha='center', va='center',fontsize=9)\n",
+ "g.fig.tight_layout()\n",
+ "sns.despine(offset=5)\n",
+ "g.figure.savefig('recycling_changes.png', bbox_inches='tight')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "54f2815e-e830-4c61-a679-487f2a21592c",
+ "metadata": {},
+ "source": [
+ "*Representational changes between recycling iterations.* Grey lines indicate comparisons between recycling iterations for an individual model, purple lines indicate average across all models and sequences (n=91 sequences, n = 455 runs (sequences x 5 models))\n",
+ "Left, euclidian distance between intermediate pair representations.\n",
+ "Right, plDDT between structural outputs"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "MetfishKernel",
+ "language": "python",
+ "name": "metfish"
+ },
+ "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.0"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/src/metfish/commands.py b/src/metfish/commands.py
index d026a44..719b21c 100644
--- a/src/metfish/commands.py
+++ b/src/metfish/commands.py
@@ -4,8 +4,8 @@
import pandas as pd
-from .utils import get_Pr
-from .utils import extract_seq
+from .utils import get_Pr, extract_seq
+from .preprocess import prep_conformer_pairs
def get_Pr_cli(argv=None):
@@ -41,7 +41,7 @@ def get_Pr_cli(argv=None):
step=args.step)
pd.DataFrame({"r": r, "P(r)": p}).to_csv(out, index=False)
-
+
def extract_seq_cli(argv=None):
parser = argparse.ArgumentParser(
@@ -54,3 +54,25 @@ def extract_seq_cli(argv=None):
args = parser.parse_args()
extract_seq(args.filename,args.output)
+
+def prep_conformer_pairs_cli(argv=None):
+
+ desc = "Preprocess conformer pair pdb files to generate fasta sequences, atom positions in AF structure format"
+ epi = """Requires folder with the csv of apo/holo pairs and pdbs from Saldano et al., 2022"""
+
+ parser = argparse.ArgumentParser(description=desc, epilog=epi)
+ parser.add_argument("data_dir", help="the directory containing the pdb files / csv")
+ parser.add_argument("-o", "--output_dir", type=str, default=None,
+ help="the directory to save output files to. Defaults to data_dir if not provided")
+ parser.add_argument("-n", "--n_pairs", type=int, default=6,
+ help="the # of pairs to look at, N pairs -> 2N structures predicted")
+ parser.add_argument("-a", "--af_output_dir", type=str, default=None,
+ help="path with alphafold outputs, used to calculate which conformer is less similar to the original AF prediction.",
+ )
+
+ args = parser.parse_args()
+
+ prep_conformer_pairs(args.data_dir,
+ output_dir=args.output_dir,
+ n_pairs=args.n_pairs,
+ af_output_dir=args.af_output_dir,)
\ No newline at end of file
diff --git a/src/metfish/preprocess.py b/src/metfish/preprocess.py
new file mode 100644
index 0000000..03774d9
--- /dev/null
+++ b/src/metfish/preprocess.py
@@ -0,0 +1,75 @@
+import pandas as pd
+import pickle
+import glob
+import shutil
+
+from metfish.utils import get_alphafold_atom_positions, get_rmsd, convert_pdb_to_sequence, save_clean_pdb
+from pathlib import Path
+
+
+def prep_conformer_pairs(data_dir, output_dir=None, n_pairs=6, af_output_dir=None):
+ """Preprocess pdb files to generate fasta sequences, atom positions in AF structure format.
+
+ Requires folder with the csv of apo/holo pairs and pdbs from Saldano et al., 2022
+
+ Args:
+ data_dir (str): the directory containing the pdb files
+ output_dir (str, optional): the directory to save output files to. Defaults to data_dir if not provided
+ n_pairs (int, optional): the # of pairs to look at, N pairs -> 2N structures predicted. Defaults to 6.
+ af_output_dir (str, optional): path with alphafold outputs,
+ used to calculate which conformer is less similar to the original AF prediction. Defaults to None.
+ """
+ # load apo and holo id names
+ output_dir = output_dir or data_dir
+ pairs_df = pd.read_csv(f"{data_dir}/apo_holo_pairs.csv")
+ if n_pairs < pairs_df.shape[0]:
+ pairs_df = pairs_df.sample(n_pairs, random_state=1234) # selects random rows as subsample
+
+ # convert pdb files into sequences, AF structures to use as AF inputs
+ holo_id = pairs_df["holo_id"].to_list()
+ apo_id = pairs_df["apo_id"].to_list()
+ for name in [*holo_id, *apo_id]:
+ # clean pdbs (extract only ATOM coordinates)
+ raw_pdb = f"{data_dir}/{name}.pdb"
+ clean_pdb = f"{output_dir}/pdbs/{name}_atom_only.pdb"
+ Path(f"{output_dir}/pdbs/").mkdir(parents=True, exist_ok=True)
+ save_clean_pdb(raw_pdb, clean_pdb)
+
+ # save pairs as fasta sequence files
+ seq = convert_pdb_to_sequence(f"{output_dir}/pdbs/{name}_atom_only.pdb")
+ seq = "\n".join([f">{name}", seq])
+ Path(f"{output_dir}/sequences/apo_and_holo/").mkdir(parents=True, exist_ok=True)
+ with open(f"{output_dir}/sequences/apo_and_holo/{name}.fasta", "w") as f:
+ f.write(seq)
+
+ # copy apo ids over to separate folder for AF input (AF only needs to run one of apo/holo pair bc same sequence)
+ Path(f"{output_dir}/sequences/apo_only/").mkdir(parents=True, exist_ok=True)
+ if name in apo_id:
+ shutil.copyfile(
+ f"{output_dir}/sequences/apo_and_holo/{name}.fasta", f"{output_dir}/sequences/apo_only/{name}.fasta"
+ )
+
+ # save pairs as alphafold structure representations
+ try:
+ struct = get_alphafold_atom_positions(f"{output_dir}/pdbs/{name}_atom_only.pdb")
+ Path(f"{output_dir}/af_structures/").mkdir(parents=True, exist_ok=True)
+ with open(f"{output_dir}/af_structures/{name}.pickle", "wb") as f:
+ pickle.dump(struct, file=f)
+ except ValueError as e:
+ print(f'Error with sequence {name} - {e}')
+
+ # calculate RMSD values between alphafold output and apo / holo conformers
+ if af_output_dir is not None:
+ rmsd_h, rmsd_a = list(), list()
+ for h, a in zip(holo_id, apo_id):
+ af_output = glob.glob(f"{af_output_dir}/{a}_unrelaxed_rank_001_*_000.pdb")[0]
+ rmsd_h.append(get_rmsd(f"{output_dir}/pdbs/{h}_atom_only.pdb", af_output))
+ rmsd_a.append(get_rmsd(f"{output_dir}/pdbs/{a}_atom_only.pdb", af_output))
+
+ pairs_df["rmsd_apo_af"] = rmsd_a
+ pairs_df["rmsd_holo_af"] = rmsd_h
+ pairs_df["less_similar_conformer"] = pairs_df.apply(
+ lambda x: x["holo_id"] if x["rmsd_apo_af"] < x["rmsd_holo_af"] else x["apo_id"], axis=1
+ )
+
+ pairs_df.to_csv(f"{output_dir}/apo_holo_pairs_with_similarity.csv", index=False)
diff --git a/src/metfish/representation_manipulation.py b/src/metfish/representation_manipulation.py
new file mode 100644
index 0000000..c329925
--- /dev/null
+++ b/src/metfish/representation_manipulation.py
@@ -0,0 +1,115 @@
+import pickle
+import numpy as np
+import pandas as pd
+import warnings
+
+from pathlib import Path
+
+
+def modify_representations(prev: dict = None, method: str = "none", **kwargs):
+ """Modify the pair, position (structural), or MSA (first row only) representations
+ that will be used as inputs for the next recycling iteration of AlphaFold.
+
+ Args:
+ prev (dict): Dict of pair, position, and msa representations.
+ method (str): Method to use to modify representations.
+
+ Returns:
+ dict: modified pair, position and msa representations
+ """
+
+ # apply modification method (test examples, will eventually modify prev outputs based on SAXS data)
+ match method:
+ case "none":
+ repr_modified = prev
+ case "reinitialize":
+ repr_modified = reinitialize(prev)
+ case "add_noise":
+ repr_modified = add_noise(prev)
+ case "replace_structure":
+ repr_modified = replace_structure(prev, **kwargs)
+ case _:
+ warnings.warn("Representation modification method not supported - defaulting to no modification")
+ repr_modified = prev
+
+ return repr_modified
+
+
+def add_noise(prev):
+ """Adds gaussian noise to the pair, structure, and MSA representations"""
+ prev_with_noise = dict()
+ rng = np.random.default_rng()
+
+ for key, value in prev.items():
+ noise = rng.standard_normal(value.shape).astype("float16") # gaussian noise with μ = 0, σ = 1
+ prev_with_noise[key] = value + noise
+
+ return prev_with_noise
+
+
+def reinitialize(prev):
+ """Reinitializes the pair, structure, and MSA, representations to zero arrays"""
+
+ L = np.shape(prev["prev_pair"])[0]
+
+ prev = {
+ "prev_msa_first_row": np.zeros([L, 256], dtype=np.float16),
+ "prev_pair": np.zeros([L, L, 128], dtype=np.float16),
+ "prev_pos": np.zeros([L, 37, 3], dtype=np.float16),
+ }
+
+ return prev
+
+
+def replace_structure(prev, job_name, input_dir=None, replacement_method="template"):
+ """Replace intermediate structure (atom position) representations from alphafold"""
+ # load in conformer pair information
+ input_dir = input_dir or Path(__file__).resolve().parents[2] / 'data'
+ conformer_pairs_fname = f"{input_dir}/apo_holo_pairs_with_similarity.csv"
+
+ pdb_name = job_name.split("_")[0]
+ conformer_df = pd.read_csv(conformer_pairs_fname)
+ pairs = list(zip(conformer_df["apo_id"], conformer_df["holo_id"]))
+
+ # get relevant pairs
+ index = [ind for ind, (a, h) in enumerate(pairs) if pdb_name in a or pdb_name in h]
+ pair_info = conformer_df.iloc[index, :]
+
+ # get structure name depending on replacement method
+ match replacement_method:
+ case "less_similar":
+ replacement_pdb_name = pair_info["less_similar_conformer"]
+ case "alternate":
+ replacement_pdb_name = (
+ pair_info["holo_id"] if pdb_name in pair_info["apo_id"].to_list()[0] else pair_info["apo_id"]
+ ) # get opposite conformer
+ case "template":
+ replacement_pdb_name = (
+ pair_info["apo_id"] if pdb_name in pair_info["apo_id"].to_list()[0] else pair_info["holo_id"]
+ ) # provide conformer experimental structure
+ case _:
+ replacement_pdb_name = []
+
+ if any(replacement_pdb_name):
+ # load replacement structure
+ print(f"Replacing {pdb_name} intermediate structure with {replacement_pdb_name.to_list()[0]}.")
+ with open(f"{input_dir}/af_structures/{replacement_pdb_name.to_list()[0]}.pickle", "rb") as f:
+ replacement_structure = pickle.load(f)
+
+ # NOTE - additional zero values seem to get added to the first dimension of the position array
+ # (n_res) when running multiple sequences. AF ignores anything longer than n_res when writing
+ # to a pdb file from the protein class, so replacing the first n_res values and adding a warning
+ if np.shape(prev["prev_pos"])[0] != np.shape(replacement_structure)[0]:
+ warnings.warn(
+ f"Alphafold intermediate {np.shape(prev['prev_pos'])} and modified conformer "
+ f"{np.shape(replacement_structure)} structures were not the same shape.",
+ )
+
+ # replace conformer with alternative option
+ n_res = np.shape(replacement_structure)[0]
+ prev["prev_pos"][:n_res, :, :] = replacement_structure.astype("float16")
+
+ else:
+ warnings.warn(f'No replacement option found for "{pdb_name}". Continuing without modification')
+
+ return prev
diff --git a/src/metfish/utils.py b/src/metfish/utils.py
index 7cd9c60..350d673 100644
--- a/src/metfish/utils.py
+++ b/src/metfish/utils.py
@@ -1,16 +1,25 @@
import os
import warnings
+import numpy as np
+import pandas as pd
from Bio.PDB.MMCIFParser import FastMMCIFParser
from Bio.PDB.PDBParser import PDBParser
-import numpy as np
-from periodictable import elements
-from scipy.spatial.distance import pdist, squareform
+from Bio.PDB import PDBIO
+from Bio.SVDSuperimposer import SVDSuperimposer
+from Bio import SeqUtils, Align
+from Bio.PDB.PDBIO import Select
from Bio import SeqIO
from Bio.SeqRecord import SeqRecord
+from periodictable import elements
+from scipy.spatial.distance import pdist, squareform
+from alphafold.common import protein
+from alphafold.model import lddt
+
n_elec_df = {el.symbol: el.number for el in elements}
+amino_acids = [a.upper() for a in SeqUtils.IUPACData.protein_letters_3to1.keys()]
def get_Pr(structure, structure_id="", dmax=None, step=0.5):
@@ -72,6 +81,161 @@ def get_Pr(structure, structure_id="", dmax=None, step=0.5):
return r, p
+def get_alphafold_atom_positions(fname: str):
+ """ Use alphafold protein module to convert pdb file to alphafold's atomic position representation
+
+ Args:
+ fname (str): path to the pdb file
+
+ Returns:
+ structure: An np.ndarray with cartesian coordinates of atoms in angstroms [num_res, num_atom_type, 3].
+ The atom types correspond to residue_constants.atom_types, i.e. the first three are N, CA, CB.
+ """
+ # read in file text and use af protein module to convert to position representation
+ with open(fname, 'r') as file:
+ pdb_str = file.read()
+ prot = protein.from_pdb_string(pdb_str) # protein module uses pdb file contents as input
+
+ return prot.atom_positions
+
+def save_clean_pdb(fname_original: str, fname_clean: str):
+ """Rewrite pdb file with only ATOM entries"""
+ raw_structure = PDBParser(QUIET=True).get_structure('', fname_original)
+
+ class AtomsOnly(Select):
+ def accept_residue(self, res):
+ return res.get_id()[0] == " " # this is the heteroatom field, if not empty is HETATM
+
+ io = PDBIO()
+ io.set_structure(raw_structure)
+ io.save(fname_clean, select=AtomsOnly())
+
+def convert_pdb_to_sequence(fname: str):
+ """ Get single letter amino acid sequence from a pdb structure file """
+ structure = PDBParser(QUIET=True).get_structure('', fname)
+ residues = [res.resname for res in structure.get_residues() if res.resname in amino_acids]
+ sequence = get_single_letter_sequences(residues)
+
+ return sequence
+
+def convert_pdb_to_atom_df(fname: str):
+ """Get a data frame with atom coordinates, names, and residue names from a pdb structure file"""
+ structure = PDBParser(QUIET=True).get_structure('', fname)
+
+ atom_data = []
+ for res in structure.get_residues():
+ coords = [a.get_vector()[:] for a in res]
+ types = [a.get_name() for a in res]
+ atom_data.append(dict(residue_name=res.resname, atom_name=types, coords=coords))
+
+ return pd.DataFrame(atom_data).explode(['atom_name', 'coords'])
+
+def get_single_letter_sequences(residues):
+ ret = list()
+ for res in residues:
+ res = res[0] + res[1:].lower()
+ ret.append(SeqUtils.IUPACData.protein_letters_3to1[res])
+ return "".join(ret)
+
+def align_sequences(ref_df, query_df):
+ """ Align protein sequences """
+ ref_seq = get_single_letter_sequences(ref_df['residue_name'])
+ query_seq = get_single_letter_sequences(query_df['residue_name'])
+
+ # if not the same sequence, align
+ if ref_seq != query_seq:
+ aligner = Align.PairwiseAligner()
+ alignments = aligner.align(ref_seq, query_seq)
+
+ ref_idx, query_idx = alignments[0].indices[:, ~(alignments[0].indices == -1).any(axis=0)]
+
+ ref_df = ref_df.iloc[ref_idx]
+ query_df = query_df.iloc[query_idx]
+
+ return ref_df, query_df
+
+def superimpose_structures(fname_fixed, fname_moving, atom_types=["CA", "N", "C", "O"]):
+ """ Superimpose two protein structures.
+
+ Args:
+ fname_fixed (str): path to PDB file
+ fname_moving (str): path to PDB file
+ atom_types (list): atom types to align structures with, traditionally aligned with either
+ 1) only alpha-carbon atoms (CA), or 2) the "protein backbone" atoms (CA, N, C, O), or all atoms
+
+ Returns:
+ superimposer: returns instance of BioPython SVDSuperImposer class
+ """
+
+ # read in structures
+ fixed_atom_df = convert_pdb_to_atom_df(fname_fixed)
+ moving_atom_df = convert_pdb_to_atom_df(fname_moving)
+
+ # filter for atom types and amino acide residues only
+ fixed_atom_df = fixed_atom_df.query(f"residue_name in {amino_acids} & atom_name in {atom_types}")
+ moving_atom_df = moving_atom_df.query(f"residue_name in {amino_acids} & atom_name in {atom_types}")
+
+ # align sequences (if already aligned, will return same df)
+ fixed_atom_df, moving_atom_df = align_sequences(fixed_atom_df, moving_atom_df)
+
+ # get coordinates of the atoms
+ fixed_coords = np.array(fixed_atom_df['coords'].to_list())
+ moving_coords = np.array(moving_atom_df['coords'].to_list())
+
+ # superimpose structures
+ si = SVDSuperimposer()
+ si.set(fixed_coords, moving_coords)
+ si.run() # Run the SVD alignment
+
+ return si
+
+def get_rmsd(fname_a, fname_b, atom_types=["CA", "N", "C", "O"]):
+ """ Calculate the RMSD between superimposed coordinates of two protein structures.
+ """
+
+ si = superimpose_structures(fname_a, fname_b, atom_types=atom_types)
+ return si.get_rms()
+
+def align_structures(fname_fixed, fname_moving):
+ """Align two protein structures from pdb files and save aligned structures
+
+ Args:
+ fname_fixed (str): path to PDB file
+ fname_moving (str): path to PDB file
+
+ Returns:
+ fname_aligned: path to aligned PDB file (rotate/translated version of fname_moving)
+ """
+
+ # load structure to transform
+ structure = PDBParser(QUIET=True).get_structure('', fname_moving)
+
+ # superimpose on experimental structure file
+ si = superimpose_structures(fname_fixed, fname_moving)
+ rot, trans = si.get_rotran()
+ for atom in structure.get_atoms():
+ atom.transform(rot.astype("f"), trans.astype("f"))
+
+ # save modified outputs as PDB files
+ fname_aligned = f"{fname_moving.strip('.pdb')}_aligned.pdb"
+ io = PDBIO()
+ io.set_structure(structure)
+ io.save(fname_aligned)
+
+ return fname_aligned
+
+def get_lddt(fname_predicted, fname_true):
+ structure_predicted = PDBParser(QUIET=True).get_structure('', fname_predicted)
+ structure_true = PDBParser(QUIET=True).get_structure('', fname_true)
+ coords_predicted = [a.get_vector()[:] for res in structure_predicted.get_residues() for a in res]
+ coords_true = [a.get_vector()[:] for res in structure_true.get_residues() for a in res]
+
+ coords_predicted = np.array(coords_predicted)[np.newaxis, :, :]
+ coords_true = np.array(coords_true)[np.newaxis, :, :]
+ true_pos_mask = np.array([[[1]] * np.shape(coords_true)[1]])
+
+ return np.asarray(lddt.lddt(coords_predicted, coords_true, true_pos_mask))[0]
+
def extract_seq(pdb_input,output_path):
"""
Args:
@@ -92,4 +256,4 @@ def extract_seq(pdb_input,output_path):
else:
new_seq_record = SeqRecord(record.seq, id=pdb_name, description='')
SeqIO.write(new_seq_record, output_path ,"fasta")
- counter+=1
\ No newline at end of file
+ counter+=1