FAQ: gget alphafold

[lauraluebbert]

This is a compilation of general questions regarding gget alphafold. If you encounter a problem while using gget alphafold, please update to the latest gget version (pip install -U gget) and feel free to comment here or open a new issue.

 
1. openmm version 7.5.1 is no longer available from conda-forge. How can I install it?
Hopefully, in future versions we will be able to drop the requirement for this exact version of openmm. For now, please install openmm using command conda install -qy conda==4.13.0 && conda install -qy -c conda-forge openmm=7.5.1 (Recommendation: Follow with conda update -qy conda to update conda to the latest version afterwards). Follow by running gget setup alpahfold / gget.setup("alphafold"). For use in Google Colab, see this notebook.

 
2. What to do if the model parameter download fails while calling gget setup?
Make sure you have the latest version of curl installed. If the curl download fails, you can manually download the model parameters from https://storage.googleapis.com/alphafold/alphafold_params_colab_2022-03-02.tar into the gget/bins/alphafold/params/ folder inside the gget package folder (you might have to create the 'params' folder).

 
3. I've encountered the following error: "ModuleNotFoundError: No module named 'google.protobuf'". What can I do?
This seems to be a known problem with google protobuf discussed here and here. This issue can be resolved by reinstalling protobuf using conda or pip, e.g. conda remove -qy protobuf && conda install -qy protobuf.

 
4. How can I plot the PDB file in 3D and colored by the model prediction error from the files returned by gget alpahfold?
PDB files can be viewed interactively in 3D online or using the program PyMOL. To recreate the interactive plot colored by prediction error (as plotted automatically by gget alphafold when called from a Python environment) from the files returned by gget, please update to gget version ≥ 0.3.10 and use the following code (adjusted from AlphaFold Colab):

# Define the path to the pdb file returned by gget alphafold
prediction = "selected_prediction.pdb"
# Define the path to the JSON containing the predicted aligned error returned by gget alphafold
pae_data = "predicted_aligned_error.json"
# Set True/False whether to show sidechains
show_sidechains = True
# Define as True if the model is a multimer
multimer = False
# Define path to save matplotlib plots
save_path = "gget_alphafold_results.png"

## Plot (no need to adjust the code below)
import numpy as np
import json
import py3Dmol
from alphafold.relax import utils
from IPython import display
from ipywidgets import GridspecLayout
from ipywidgets import Output
import matplotlib.pyplot as plt
%config InlineBackend.figure_format='retina'

# Load files returned by gget alphafold
relaxed_pdb = open(prediction, "r").read()
with open(pae_data) as f:
    pae_json = json.load(f)

# Color bands for visualizing plddt
PLDDT_BANDS = [
    (0, 50, "#FF7D45"),
    (50, 70, "#FFDB13"),
    (70, 90, "#65CBF3"),
    (90, 100, "#0053D6"),
]

def plot_plddt_legend():
    """
    Function to plot the legend for pLDDT.
    """
    thresh = [
        "Very low (pLDDT < 50)",
        "Low (70 > pLDDT > 50)",
        "Confident (90 > pLDDT > 70)",
        "Very high (pLDDT > 90)",
    ]

    colors = [x[2] for x in PLDDT_BANDS]

    plt.figure(figsize=(2, 2))
    for c in colors:
        plt.bar(0, 0, color=c)
    plt.legend(thresh, frameon=False, loc="center", fontsize=20)
    plt.xticks([])
    plt.yticks([])
    ax = plt.gca()
    ax.spines["right"].set_visible(False)
    ax.spines["top"].set_visible(False)
    ax.spines["left"].set_visible(False)
    ax.spines["bottom"].set_visible(False)
    plt.title("Model Confidence", fontsize=20, pad=20)

    return plt

# Construct multiclass b-factors to indicate confidence bands
# 0=very low, 1=low, 2=confident, 3=very high
banded_b_factors = []
for plddt in pae_json["plddt"]:
    for idx, (min_val, max_val, _) in enumerate(PLDDT_BANDS):
        if plddt >= min_val and plddt <= max_val:
            banded_b_factors.append(idx)
            break

banded_b_factors = np.array(banded_b_factors)[:, None] * pae_json["final_atom_mask"]
to_visualize_pdb = utils.overwrite_b_factors(relaxed_pdb, banded_b_factors)

# Show the structure coloured by chain if the multimer model has been used.
if multimer:
    multichain_view = py3Dmol.view(width=800, height=600)
    multichain_view.addModelsAsFrames(to_visualize_pdb)
    multichain_style = {"cartoon": {"colorscheme": "chain"}}
    multichain_view.setStyle({"model": -1}, multichain_style)
    multichain_view.zoomTo()
    multichain_view.show()

# Color the structure by per-residue pLDDT
color_map = {i: bands[2] for i, bands in enumerate(PLDDT_BANDS)}
view = py3Dmol.view(width=800, height=600)
view.addModelsAsFrames(to_visualize_pdb)
style = {"cartoon": {"colorscheme": {"prop": "b", "map": color_map}}}
if show_sidechains:
    style["stick"] = {}
view.setStyle({"model": -1}, style)
view.zoomTo()

grid = GridspecLayout(1, 2)
output_plt = Output()
with output_plt:
    view.show()
grid[0, 0] = output_plt

output_plt = Output()
with output_plt:
    plot_plddt_legend().show()
grid[0, 1] = output_plt

display.display(grid)

# Display pLDDT and predicted aligned error
num_plots = 2
plt.figure(figsize=[8 * num_plots, 6])
plt.subplot(1, num_plots, 1)
plt.plot(pae_json["plddt"])
plt.title("Predicted LDDT")
plt.xlabel("Residue")
plt.ylabel("pLDDT")

plt.subplot(1, 2, 2)
plt.imshow(pae_json["predicted_aligned_error"], vmin=0.0, vmax=pae_json["max_predicted_aligned_error"], cmap="Greens_r")
plt.colorbar(fraction=0.046, pad=0.04)

plt.title("Predicted Aligned Error")
plt.xlabel("Scored residue")
plt.ylabel("Aligned residue")

# Save matplotlib figures
plt.savefig(
    save_path,
    dpi=300,
    bbox_inches="tight",
    transparent=True,
)