【この記事のまとめ】

環状ペプチドのデザイン後、静的なドッキング評価だけでは不十分な「結合の安定性」を、OpenMMを用いた分子動力学（MD）シミュレーションによって原子レベルで動的に検証する実践的な手法を解説します。

• 「動的な妥当性」の検証: Bolzgenなどで生成した静止構造が、溶液中での熱ゆらぎや溶媒環境下でも安定した相互作用を維持できるかを、物理法則に基づいてシミュレーションし、信頼性を判断できます。
• OpenMMによる高速・柔軟な解析: Pythonライブラリとして動作するOpenMMを活用し、GPUによる高速計算（CUDA）とスクリプト制御を組み合わせた、研究・実務レベルのMD実行フローを網羅。
• 5つの指標による定量評価: RMSD（構造のずれ）、RMSF（残基の揺れ）、水素結合数、最小距離、回転半径（Rg）を可視化し、ペプチドが解離せず結合様式が維持されているかを客観的に評価。

この記事を読み進めることで、専門的なMDエンジンの環境構築から、シミュレーション実行、そして解析結果のプロット作成までを一気通貫で習得でき、In silico創薬の精度を飛躍的に高めることが可能です。

MDシミュレーションとは？

In silicoペプチド創薬における分子動力学（MD）シミュレーションは、タンパク質–ペプチド複合体構造が「物理的に妥当で、本当に安定に存在しうるか」を検証するためのステップです。このステップでは、コンピューター上で分子を原子レベルで時間発展させることで、溶液中における分子の振る舞いを再現し、タンパク質とペプチドの結合が実際に安定して維持されるかを評価します。Bolzgenなどで生成した静的な構造モデルが単に見かけ上もっともらしい配置を示しているだけなのか、それとも熱ゆらぎや溶媒環境を考慮しても安定な相互作用を保つのかを、動的に観察することで解析できる点がMDの大きな特徴です。

本記事のワークフローでは、bolzgenによって直接生成された環状ペプチドと標的タンパク質の複合体構造のMDを評価するためにOpenMMを実施します。特にペプチドは柔軟性が高く、初期モデルから構造が緩和したり、相互作用が再編成されたりすることが多いため、MDなしでは結合の信頼性を十分に判断できません。複合体構造に対してMDシミュレーションを行うことで、その結合が維持されるのか、重要な相互作用が安定しているのか、あるいは結合様式が大きく変化するのかといった、静的モデルからは得られない重要な情報を把握することが可能になります。

OpenMMとは？

OpenMMは、「分子動力学（MD）シミュレーション」を簡単かつ高速に実行できるオープンソースソフトウェアです。GPUを利用した高速計算と、Pythonから直感的に操作できる点が特徴で、タンパク質やペプチド複合体のシミュレーションを比較的短いコードで実行できます。

MDシミュレーションでは、分子を構成する原子一つひとつに働く力（力場）を計算し、その力に基づいてニュートンの運動方程式を数値的に解くことで、時間とともに原子がどのように動くかを追跡します。OpenMMは、この「力の計算」と「時間発展の積分」を効率よく行う事が可能で、水分子やイオンを含めた現実に近い環境で分子の振る舞いを再現できます。

実際のシミュレーションは、①構造データの読み込み、②力場の設定、③水やイオンの追加、④エネルギー最小化、⑤温度・圧力を整える平衡化、⑥本番シミュレーションの実行、という流れで進みます。OpenMMではこれらをPythonスクリプトで順に設定できるため、プロトコルの理解と再現がしやすく、ドッキング後の複合体が溶液中で安定に存在できるかを評価するのに適しています。

本記事では、このOpenMMを用いてタンパク質・ペプチド複合体のMDシミュレーションをどのように準備し、実行するのか、さらにMD結果の定量的な確認方法を、初心者にも分かるように順を追って解説していきます。

GROMACSとの違い

GROMACS と OpenMM は、いずれも高性能な分子動力学（MD）シミュレーションソフトウェアですが、設計思想と利用スタイルに明確な違いがあります。

GROMACSは、長年にわたり発展してきた成熟したMDエンジンであり、高速かつ安定した計算性能に定評があります。設定ファイル（.mdpなど）を用いてシミュレーション条件を定義し、コマンドラインから実行するスタイルが基本となります。そのため、大規模系のルーチン計算や再現性の高い標準的なMDワークフローにおいて非常に強力です。実験系研究者や計算化学分野での定番ツールとして広く使用されています。

一方、OpenMMは「完成された実行プログラム」というよりも、**「MD計算を構築するためのプログラマブルなライブラリ」**に近い位置づけです。Pythonから直接シミュレーションを組み立てる設計になっており、計算条件やアルゴリズムをコードレベルで柔軟に制御できます。このため、カスタム力場の導入、新規ポテンシャルの実装、機械学習モデルとの統合など、研究開発色の強い用途に適しています。

計算アーキテクチャの観点でも違いがあります。GROMACSはCPU並列化を基盤にしつつGPUアクセラレーションを統合する設計であるのに対し、OpenMMは当初からGPU活用を前提に設計されており、CUDAやOpenCLを利用した効率的なGPU計算に強みを持ちます。

まとめると、GROMACSは「高性能で完成度の高いMD実行エンジン」、OpenMMは「柔軟性と拡張性を重視したMD開発フレームワーク」と捉えると理解しやすいでしょう。長年GROMACSを使用してきた研究者にとって、OpenMMは操作感そのものが異なり、よりプログラミング主導でMDを設計することを前提にしたツールであると言えます。

環境構築

まずはこちらを参考に環境構築から行っていきます。今回もWindowsのWSLを利用していきます。WSLの利用方法はこちらの記事に記載してあるので、そちらを参考にしてください。

今回のツールはGPUを利用するツールのため、まずはこちらのサイトでお使いのPCに搭載されているGPUに 対応したドライバ（Windows11用。Linux用ではありません）をDLして、Windows 上でインストーラを実行し、再起動して有効化してください。また、どのドライバーが良いのか分からない場合は、こちらのNDIVIA appをインストールすると最適なドライバーをインストールしてくれるようです（既にインストール済みの場合は不要です。）

次に、WSLのターミナルで以下のコードを実行して、環境構築をしていきます。

ターミナルを開き、以下を実行してください。

# ① 環境をconda-forgeのみで作成
conda create -n peptide-md -c conda-forge python=3.11 -y
conda activate peptide-md
# ② 依存解決を高速化
conda install -n peptide-md -c conda-forge mamba -y
# ③ CUDA対応OpenMM + PDBFixer をインストール
mamba install -c conda-forge \ openmm \ cuda-version=12 \ pdbfixer \ mdtraj \ matplotlib \ numpy \ -y

これでWSL上にOpenMM環境が構築されました！

複合体構造の修正とOpenMMでのMDの実行

今回は以下の記事で生成した環状ペプチドのMDを行ってみます。

【環状ペプチド】Bolzgenを使ったDe novo環状ペプチドの生成【In silico創薬】 – LabCode

以下のfinal_2_designの中にあるCIFファイルの中からMDにかけたいファイルを決め、その名前をProtein_Peptide.cifに変更してください（PDBファイルの場合でも大丈夫です。）。

WSLターミナルを開き、

mkdir -p ~/md_run
cd ~/md_run

と入力し、MD作業用のディレクトリを作成・移動します。WSL側に用意することでシミュレーションを高速に実行できます。そして、以下のコマンドでこのディレクトリ内に、MDシミュレーションにかけたい複合体のPDBファイルを移動させておきます。

cp /mnt/c/Users/<Windowsのユーザー名>/Documents/bolzgen/output_run1/final_ranked_designs/final_2_designs/Protein_Peptide.cif .

こちらのコマンドは、CIFファイル（またはPDBファイル）の保存場所に合わせて適宜変更して下さい。

ここまで終わったら以下を実行して下さい。

# 複合体構造の修正(立体構造ファイル名や拡張子などは適宜変更して下さい)
pdbfixer Protein_Peptide.cif \ --add-atoms=all \ --ph=7.0 \ --output=fixed.pdb
# nanoというファイル編集ツールを開く
nano run_openmm.py

実行するとファイル編集画面が開くと思います。

そこに以下をコピペして下さい。

from openmm.app import *
from openmm import *
from openmm.unit import *
from sys import stdout
print("Loading structure...")
pdb = PDBFile("fixed.pdb")
print("Loading force field...")
forcefield = ForceField("amber14-all.xml", "amber14/tip3p.xml")
modeller = Modeller(pdb.topology, pdb.positions)
print("Adding solvent...")
modeller.addSolvent( forcefield, padding=1.0*nanometers, ionicStrength=0.15*molar
)
print("Saving solvated system (system.pdb)...")
PDBFile.writeFile( modeller.topology, modeller.positions, open("system.pdb", "w")
)
print("Creating system...")
system = forcefield.createSystem( modeller.topology, nonbondedMethod=PME, nonbondedCutoff=1*nanometer, constraints=HBonds
)
print("Integrator...")
integrator = LangevinIntegrator( 300*kelvin, 1/picosecond, 0.002*picoseconds
)
integrator.setRandomNumberSeed(42)
print("Using GPU...")
platform = Platform.getPlatformByName("CUDA")
properties = {"Precision": "mixed"}
simulation = Simulation( modeller.topology, system, integrator, platform, properties
)
simulation.context.setPositions(modeller.positions)
print("Minimizing energy...")
simulation.minimizeEnergy()
print("Equilibrating (100 ps)...")
simulation.context.setVelocitiesToTemperature(300*kelvin)
simulation.step(50000)
print("Setting reporters...")
simulation.reporters.append( DCDReporter("traj.dcd", 1000)
)
simulation.reporters.append( StateDataReporter( "log.txt", 1000, step=True, temperature=True, potentialEnergy=True, density=True, speed=True )
)
print("Production run (5 ns)...")
simulation.step(2500000)
print("Done.")

コピペ後には、キーボードでCtrl+O → Enter → Ctrl+Xを入力して、ファイルの保存を行って下さい。このファイルがOpenMMを実行する為のpythonファイルになっています。

最後にこのpythonファイルをWSL上で実行します。これでopenMMによるMDが実行されます。

（数十分から数時間かかります。）

python run_openmm.py

MD結果の確認

今回はWSL上で実行したので、実行結果のファイルはWSL上に保存されています。

まずは以下のコマンドで、実行結果ファイルがあるかを確認しましょう。

ls -lh

このコマンドで以下のようになっていればMDは成功です！

(peptide-md) xx@XX:~/md_run$ ls -lh total 1.4G -rwxr-xr-x 1 xx xx 97K Feb 27 15:17 Protein_Peptide.cif -rw-r--r-- 1 xx xx 170K Feb 27 15:18 fixed.pdb -rw-r--r-- 1 xx xx 335K Feb 27 16:19 log.txt -rw-r--r-- 1 xx xx 1.4K Feb 27 15:19 run_openmm.py

-rw-r--r-- 1 xx xx 1.8M Feb 27 16:19 system.pdb

-rw-r--r-- 1 xx xx 1.3G Feb 27 16:19 traj.dcdlog.txtには実行ログが、traj.dcdとsystem.pdbにはMD計算の結果が入っています。

実はWSL上のファイルは、Windows端末から直接確認することができます。

エクスプローラーのアドレスバー(下の画像を参照)に\\wsl$ と入力すると、これらのWSL上のファイルにWindows上のファイルかのようにアクセスすることが可能です。

Ubuntu→home→ユーザー名 →md_run(今回作成した環境名)と進んでいくと、これらの結果ファイルにアクセスできますので、この方法で確認するのもいいでしょう。

次に以下のコマンドで、pythonで動くmdtrajというパッケージを使って、このtraj.dcdとsystem.pdbの中身を分析していきます。これらのファイルには、時間変化ごとの立体構造の軌跡が入っているのですがそのままでは結果を把握できないので、この軌跡の情報を分析して定量的に評価するために、以下の5つの要素をプロットで可視化していきます。

• RMSD
  • 全体構造のずれ
  • → システムが安定しているか確認
• RMSF
  • 各残基の揺れ
  • → 柔らかい部分・不安定部位の特定
• 水素結合（H-bond）
  • タンパク–ペプチド間の水素結合数
  • → 相互作用の安定性評価
• 最小距離（Minimum Distance）とコンタクト数
  • 両者の最短原子間距離や接触の数
  • → 解離していないか確認
• 回転半径（Radius of Gyration, Rg）
  • 構造の広がり具合
  • → 折りたたみ状態・崩壊の有無を確認

これらをプロットすることで、

• 構造が安定しているか
• ペプチドが解離していないか
• 結合様式が維持されているか
• 特定領域が過度に揺らいでいないか

といった点を総合的に判断できるようになります。

MDの結果ファイルからこれらの情報を抽出するためのpythonコードを、nanoを用いて作成します。まずは、以下のコマンドを実行してください。

# nanoというファイル編集ツールを開く
nano analyze_md.py

実行するとファイル編集画面が開くと思います。

そこに以下をコピペして下さい。

#!/usr/bin/env python3
import mdtraj as md
import numpy as np
import matplotlib.pyplot as plt
# ===============================
# 0. 設定
# ===============================
EQUIL_TIME_NS = 0.1 # 平衡化の時間(単位ns)
CONTACT_CUTOFF = 0.4 # nm (4.0 Å)
print("Loading trajectory...")
traj = md.load("traj.dcd", top="system.pdb")
# ===============================
# 1. PBC補正 & センタリング
# ===============================
print("Applying PBC correction and centering...")
traj.center_coordinates()
traj = traj.image_molecules()
traj = traj[traj.time / 1000 >= EQUIL_TIME_NS] # 平衡化の時間分差し引いてプロットをスタート
start_time = EQUIL_TIME_NS
time_ns = start_time + np.arange(traj.n_frames) * 0.002
# ===============================
# 2. Atom selection
# ===============================
# Cα (RMSD/RMSF用)
protein_ca = traj.topology.select("chainid 0 and name CA")
peptide_ca = traj.topology.select("chainid 1 and name CA")
complex_ca = traj.topology.select("(chainid 0 or chainid 1) and name CA")
# 重原子 (Contacts/MinDist/Rg用)
protein_heavy = traj.topology.select("chainid 0 and not element H")
peptide_heavy = traj.topology.select("chainid 1 and not element H")
complex_heavy = traj.topology.select("(chainid 0 or chainid 1) and not element H")
# 全原子セット (Hbond用判定用)
protein_atoms = set(traj.topology.select("chainid 0"))
peptide_atoms = set(traj.topology.select("chainid 1"))
# ===============================
# 3. アラインメント
# ===============================
print("Aligning trajectory...")
traj.superpose(traj, 0, atom_indices=protein_ca)
# ===============================
# 4. RMSD (Complex追加)
# ===============================
print("Calculating RMSD...")
rmsd_protein = md.rmsd(traj, traj, 0, atom_indices=protein_ca) * 10
rmsd_peptide = md.rmsd(traj, traj, 0, atom_indices=peptide_ca) * 10
rmsd_complex = md.rmsd(traj, traj, 0, atom_indices=complex_ca) * 10
plt.figure(figsize=(8, 5))
plt.plot(time_ns, rmsd_protein, label="Protein (GABARAP)")
plt.plot(time_ns, rmsd_peptide, label="Peptide (Cyclic)")
plt.plot(time_ns, rmsd_complex, label="Complex", color="black", linewidth=1.5)
plt.xlabel("Time (ns)")
plt.ylabel("RMSD (Å)")
plt.legend()
plt.title("Cα RMSD (10ns Full Run)")
plt.grid(True, linestyle='--', alpha=0.6)
plt.savefig("rmsd_ca_10ns.png")
plt.close()
# ===============================
# 5. RMSF (連続プロット)
# ===============================
print("Calculating RMSF...")
rmsf_protein = md.rmsf(traj, traj[0], atom_indices=protein_ca) * 10
rmsf_peptide = md.rmsf(traj, traj[0], atom_indices=peptide_ca) * 10
prot_res_count = len(protein_ca)
res_idx_protein = np.arange(prot_res_count)
res_idx_peptide = np.arange(len(peptide_ca)) + prot_res_count
plt.figure(figsize=(10, 5))
plt.plot(res_idx_protein, rmsf_protein, label="Protein", color="blue")
plt.plot(res_idx_peptide, rmsf_peptide, label="Peptide", color="orange")
plt.axvline(x=prot_res_count - 0.5, linestyle="--", color="red", label="Boundary")
plt.xlabel("Residue Index")
plt.ylabel("RMSF (Å)")
plt.legend()
plt.title("Cα RMSF (10ns)")
plt.savefig("rmsf_ca_10ns.png")
plt.close()
# ===============================
# 6. H-bonds (Inter-molecular only)
# ===============================
print("Calculating Inter-molecular H-bonds...")
hbonds_raw = md.wernet_nilsson(traj, periodic=True)
hbond_counts = []
for frame_bonds in hbonds_raw: count = 0 for a, h, d in frame_bonds: if (a in protein_atoms and d in peptide_atoms) or \ (a in peptide_atoms and d in protein_atoms): count += 1 hbond_counts.append(count)
plt.figure(figsize=(8, 5))
plt.plot(time_ns, hbond_counts, color="green")
plt.xlabel("Time (ns)")
plt.ylabel("Number of H-bonds")
plt.title("Protein–Peptide Inter-molecular H-bonds")
plt.savefig("hbonds_10ns.png")
plt.close()
# ===============================
# 7. Heavy Atom Min Distance & Contacts (Inter-molecular)
# ===============================
print("Calculating Heavy Atom distances and contacts (Inter-molecular)...")
# ペアをタンパク質重原子 vs ペプチド重原子に限定することでメモリを節約
heavy_pairs = []
for i in protein_heavy: for j in peptide_heavy: heavy_pairs.append((i, j))
# 分子間重原子ペアのみの距離計算
distances = md.compute_distances(traj, heavy_pairs, periodic=True)
# 最小距離 (Å)
min_dist = distances.min(axis=1) * 10
# コンタクト数 (0.4nm以内の重原子ペア数)
contact_count = (distances < CONTACT_CUTOFF).sum(axis=1)
plt.figure(figsize=(8, 5))
plt.plot(time_ns, contact_count, color="purple")
plt.xlabel("Time (ns)")
plt.ylabel("Number of Heavy Atom Contacts")
plt.title("Protein–Peptide Heavy Atom Contacts")
plt.savefig("contacts_heavy_10ns.png")
plt.close()
plt.figure(figsize=(8, 5))
plt.plot(time_ns, min_dist, color="red")
plt.xlabel("Time (ns)")
plt.ylabel("Min Heavy Atom Distance (Å)")
plt.title("Protein–Peptide Minimum Heavy Atom Distance")
plt.savefig("mindist_heavy_10ns.png")
plt.close()
# ===============================
# 8. Radius of Gyration (Complex)
# ===============================
print("Calculating Rg for Complex...")
# protein_heavy ではなく complex_heavy を使用してスライス
complex_traj = traj.atom_slice(complex_heavy)
rg_complex = md.compute_rg(complex_traj) * 10
plt.figure(figsize=(8, 5))
plt.plot(time_ns, rg_complex, color="brown")
plt.xlabel("Time (ns)")
plt.ylabel("Rg (Å)")
# タイトルも Complex に変更
plt.title("Complex Radius of Gyration (Heavy Atoms)")
plt.savefig("rg_complex_10ns.png")
plt.close()
print("\nDone! All analysis files generated.")

コピペ後には、先ほどと同様にキーボードでCtrl+O → Enter → Ctrl+Xを入力して、ファイルの保存を行って下さい。このファイルがtraj.dcdファイル等を分析するためのpythonファイルになます。

最後にこのpythonファイルをWSL上で実行します。これでopenMMによるtraj.dcdファイル等の分析が実行されます。

python analyze_md.py

実行するとつの画像ファイルができているはずです。先ほどのwindowsのエクスプローラーから確認してみてください。

以下の様になっていれば成功です(各画像の解釈は後程、解説します)。

コードの解説

上に書いたソースコードの解説をしていきます。

先ずは、①環境構築のコマンドから解説をします。

# ① 環境をconda-forgeのみで作成
conda create -n peptide-md -c conda-forge python=3.11 -y
conda activate peptide-md
# ② 依存解決を高速化
conda install -n peptide-md -c conda-forge mamba -y
# ③ CUDA対応OpenMM + PDBFixer をインストール
mamba install -c conda-forge \ openmm \ cuda-version=12 \ pdbfixer \ mdtraj \ matplotlib \ numpy \ -y

先ず以下で、condaでpeptide-md という環境を用意します。

conda create -n peptide-md -c conda-forge python=3.11 -y conda activate peptide-md

さらに、以下のコマンドでconda-forgeを使って、mambaをインストールします。mamba はcondaの高速版で、openMMはインストールに時間がかかるので、今回はこちらを利用します

conda install -n peptide-md -c conda-forge mamba -y

さらに、以下のコマンドで必要なパッケージをインストールします。

mamba install -c conda-forge \ openmm \ cuda-version=12 \ pdbfixer \ mdtraj \ matplotlib \ numpy \ -y

それぞれのパッケージには以下のような役割があり、-y でユーザーが承認しなくとも自動でインストールされるように設定してあります。

openmm → MDエンジン

cuda-version=12 → GPUを使えるようにする

pdbfixer → 構造修正

mdtraj →MD結果の分析

matplotlib・numpy → 可視化、数値計算

次に、②複合体構造の修正とOpenMMでのMDの実行を解説します。

先ずは、pdbfixerの実行部分について解説します。

# 複合体構造の修正
pdbfixer Protein_Peptide.cif \ --add-atoms=all \ --ph=7.0 \ --output=fixed.pdb
# nanoというファイル編集ツールを開く
nano run_openmm.py

ここでは、pdbfixer を使って、Bolzgenで生成した Protein_Peptide.cif（元の構造ファイル）を修理しています。

オプションの意味は以下。

• -add-atoms=all→ 足りない原子（特に水素）を全部追加
• -ph=7.0→ pH7（生理条件）で水素の付き方を決める
• -output=fixed.pdb→ 修理後の構造を fixed.pdb という名前で保存

なぜこの処理が必要かというと、Bolzgenの生成した構造ファイルは、原子モデルとしては不完全な状態 (水素原子が入っていない場合や一部の原子が欠けている、電荷状態が決まっていないといった状態)であることが多く、そのままMDを行うと物理計算が出来ないことがあるためです。今回は、水素原子とpHの設定を行い、より“完全な原子モデル”に整えたのちに、MD計算を行っていきます。

また。それと同時にnano というテキストエディタでrun_openmm.py というpythonファイルを作成しています。openMMはオプションコマンドではなく、pythonファイルでMDの詳細設定を指示する必要があるためです。

では、nano で作成したrun_openmm.py の中身を解説していきます。これはopenMMの実行ファイルとなっており、「タンパク質＋ペプチドを水の中に入れて、300Kで10ナノ秒動かす」という分子シミュレーションを行うように指定してあります。

以下で詳しく解説します。

① ライブラリの読み込み

from openmm.app import * from openmm import * from openmm.unit import * from sys import stdout

OpenMMを使うためのパッケージを読み込んでいます。 unit は nm や kelvin などの単位を扱うためのもの。

② 構造ファイルの読み込みpdb = PDBFile('fixed.pdb')

fixed.pdb（PDBFixerで整えた構造）を読み込んでいます。 これが計算の出発点。

③ 力場（force field）の読み込みforcefield = ForceField('amber14-all.xml', 'amber14/tip3p.xml')

分子にかかる力のルールを指定しています。

amber14-all.xml → タンパク質用

tip3p.xml → 水分子用

つまり 「タンパク質と水をどう計算するか」を決めています。

④ 溶媒を追加modeller.addSolvent(...)

タンパク質の周囲に溶媒(今回は水)を入れています。

padding=1.0 nm → 周囲1nmの水の層

ionicStrength=0.15 M → 生理食塩水くらいの塩濃度

現実の体内環境に近づけています。

⑤ 解析用トポロジー保存PDBFile.writeFile(...)

結果の保存方法を指定。

traj.dcd は座標だけ

system.pdb が原子定義を持つ

⑥ システム作成system = forcefield.createSystem(...)

ここで「物理計算モデル」を作っています。

PME → 長距離の静電相互作用を正確に計算

constraints=HBonds → 水素結合の長さを固定（高速化）

ここが“物理エンジン”部分。

⑦ 温度制御設定integrator = LangevinIntegrator(...)

300K（約27℃）で計算する設定。

300 K → 温度

1/picosecond → 摩擦係数

0.002 ps → 2 fsステップ

2フェムト秒刻みで時間を進めます。

⑧ GPUを使う設定platform = Platform.getPlatformByName('CUDA')

NVIDIA GPUを使う指定。 GPUで高速計算します。

⑨ エネルギー最小化simulation.minimizeEnergy()

ぶつかっている原子を少し整えます。 「初期構造のほぐして、自然な状態にする」。

⑩ 平衡化（100 ps）simulation.context.setVelocitiesToTemperature(300*kelvin) simulation.step(50000)

2 fs × 50,000 = 100 ps

シミュレーション計算で少しだけ時間を経過させ、分子構造を平衡化(安定)させる。

⑪ 出力設定DCDReporter('traj.dcd', 1000)

1000ステップごとに座標保存 → traj.dcd（軌道ファイル）

StateDataReporter('log.txt', ...)

温度・エネルギーなどを保存 → log.tx

⑫ 本番計算（10 ns）simulation.step(5000000)

2 fs × 5,000,000 = 10 ns

実際の分子運動シミュレーション。

最後に③MD結果の確認について解説します。

ここでも同様にnano analyze_md.py というコマンドで、analyze_md.py というpythonファイルを作成しています。analyze_md.py の中身は以下で詳しく解説します。

① ライブラリの読み込み

import mdtraj as md import numpy as np import matplotlib.pyplot as plt

mdtraj: MD解析のデファクトスタンダード。軌跡の読み込み、距離計算、水素結合判定などを高速に行います。

numpy: 配列計算の基礎。計算された距離や時間の単位変換、統計処理に使用します。

matplotlib: データの可視化。

② 軌跡ファイルの読み込み

traj = md.load("traj.dcd", top="system.pdb")traj.dcd: 座標のタイムコースデータ。原子が「いつ、どこにいたか」の記録です。system.pdb: 座標に意味を与える構造情報。「どの原子が、どの残基に属し、どのチェーンか」を紐付けます。

③ PBC補正と平衡化部分の除外

traj.center_coordinates() traj = traj.image_molecules()PBC補正 (center / image): 周期境界条件により箱の外へ飛び出した分子を箱の中に引き戻し、タンパク質を中心に据えます。これをしないと、分子が瞬間移動したような異常なグラフになります。

traj = traj[traj.time / 1000 >= EQUIL_TIME_NS] start_time = EQUIL_TIME_NS

平衡化の除外: シミュレーション開始直後の不安定な初期状態を解析から捨てることで、平衡化後の安定状態の値を解析に利用します。

time_ns = start_time + np.arange(traj.n_frames) * 0.002

時間軸の再構成: 0.002ns (2ps) ごとに書き込まれたフレームとプロットの時間軸(横軸)を合わせます。

④ 解析対象の選択 (Selection)

`# 重原子 (Contacts/MinDist/Rg用) protein_ca = traj.topology.select(“chainid 0 and name CA”) peptide_ca = traj.topology.select(“chainid 1 and name CA”) complex_ca = traj.topology.select(“(chainid 0 or chainid 1) and name CA”)

全原子セット (Hbond用判定用)

protein_heavy = traj.topology.select(“chainid 0 and not element H”) peptide_heavy = traj.topology.select(“chainid 1 and not element H”) complex_heavy = traj.topology.select(“(chainid 0 or chainid 1) and not element H”)`

役割: 「システム全体(溶媒含む)」から「解析したい部分」だけを抽出します。

CA原子のみ : アミノ酸の中心のCのみを抜き出す。骨格の動きを見るため、RMSD/RMSFに使用。

Heavy Atoms (重原子)のみ: 水素以外の全原子を選択。密着度や接触を詳しく見るためContacts / MinDistで利用。

これにより、不要な原子（水やイオン）を計算から外すことで、メモリ消費を抑え、計算を高速化します。

⑤ 重ね合わせ (Alignment)

traj.superpose(traj, 0, atom_indices=protein_ca)役割: 全フレームのタンパク質を第1フレームにピッタリ重ね合わせます。MD中に起きた分子自体の「回転」や「拡散移動」によるノイズを取り除きます。これにより、グラフに現れる変化が「純粋な構造変化」であることを保証します。

⑥ RMSD（安定性）の解析

rmsd_complex = md.rmsd(traj, traj, 0, atom_indices=complex_ca) * 10RMSD: 「初期構造からのズレ」を定量化します。これが一定値で横ばいになれば、構造が安定した（平衡化した）と判断できます。複合体全体、タンパク質単体、ペプチド単体の3つを算出します。Ca原子のみで計算します。

単位変換: * 10 をすることで、ナノメートルから一般的な単位であるÅ(オングストローム )に変換しています。

⑦ RMSF（柔軟性）の解析

rmsf_protein = md.rmsf(traj, traj[0], atom_indices=protein_ca) * 10役割: 残基ごとの「揺れ」の平均を算出します。ペプチドとの結合部位が固定されているかを確認するのに有効です。Ca原子のみで計算します。

⑧ H-bonds（相互作用）の解析

hbonds_raw = md.wernet_nilsson(traj, periodic=True)

H-bonds: 経過時間ごとのペプチドとタンパク間の水素結合数をカウントします。ペプチドとタンパクの全原子を対象に計算します。

⑨ 接触と距離の解析 (Heavy Atom Min Distance & Contacts)distances = md.compute_distances(traj, heavy_pairs, periodic=True) min_dist = distances.min(axis=1) * 10 contact_count = (distances < CONTACT_CUTOFF).sum(axis=1)

MinDist: 分子間の最短距離。ペプチドがポケットから離れていないか、あるいは衝突（貫通）していないかを確認します。

Contacts: 分子間で4.0 Å 以内に接近した原子ペアの数を経過時間ごとにカウントします。ペプチドがどれだけ「面」でタンパク質を捉えているかを示します。ペプチドとタンパクの重原子間のペアのみで計算を行います。

⑩ 構造のコンパクトさの解析 (Radius of Gyration)

rg = md.compute_rg(protein_traj) * 10

Rg (回転半径): 「分子の広がり具合」。タンパク質がまとまっているか、あるいは広がっているかを数値化します。構造の崩壊などをチェックできます。複合体の重原子を対象に計算。

以上を踏まえて、今回作成されたプロットを確認していきます。

• RMSD（構造のずれ）

rmsd_ca_10ns.pngを開くと以下の様になっていました。

見方：初期構造からどれだけ構造が変化したかを時間で追跡しています。値が小さいほど初期構造に近く、安定しています。一般には振幅が 0.5Å 以内に収まっていれば「安定（Stable）」と記述できます。

今回の解釈：

-Protein (青): 1.2Å 程度で完全に一定です。これは GABARAP タンパク質自体が計算中に壊れず、安定していたことを意味します。

-Peptide (オレンジ): 7ns 付近で「跳ね」がありますが、その後すぐに 1.0Å 前後に戻っています。これは**「ポケットの中で少し動いたが、外れずに安定な位置に収まり直した」**ことを示しており、結合が強固であることを示唆します。

-Complex (黒): 全体として 1.5Å 以下に収まっており、複合体としての一体感が非常に高いです。

• RMSF（残基ごとの揺れ）

rmsd_ca_10ns.pngを開くと以下の様になっていました。

見方: 各残基が平均構造からどれだけ揺れたかを棒グラフで示しています。値が高いほどその残基は柔軟に動いています。赤い点線がタンパク質とペプチドの境界です。

今回の解釈：

-Protein (青): 低い値で静止しています。

-Peptide (オレンジ): 境界線のすぐ右側（ペプチドの端）にある 40Å を超える巨大なスパイクがある。

このスパイクは「ペプチドの特定の場所（おそらく端の数残基）」が激しく動いていることを示しています。しかし、その後の残基は 2Å 以下で安定しています。ペプチドの『核』となる部分はガッチリ固定されているが、端っこの部分だけが自由奔放に動いているという、結合モデルに見えます。しかし、40Å 越えはかなり高い印象です。

• 水素結合解析

hbonds_10nsを開くと以下の様になっていました。

見方: タンパク質とペプチドを繋ぐ架け橋となる水素結合の数を経過時間ごとにプロットしています。水素結合が多いと両者の結合は強固であり、数やその時間当たりの変化は結合強度の指標になります。今回の解釈: 常時 6〜10本 という、非常に多い数の水素結合が維持されています。特に 8ns 以降で数が安定して増えているように見えます。

• 最小距離&コンタクト解析

mindist_heavey_10ns.pngを開くと以下の様になっていました。

見方: 両分子の原子が最も近づいている距離（最小距離）です。2.5～3.2Å 程度:だと安定した水素結合や強固な塩橋が形成されている可能性が高い。

今回の解釈: 常に 2.5Å 〜 2.9Å 付近を推移しています。これは水素結合の理想的な距離であり、10ns の間、ペプチドがポケットから離れていない（浮いていない）ことを示しています。

cantacts_heavey_10ns.pngを開くと以下の様になっていました。

見方: 0.4nm 以内に接近している原子ペア(コンタクト)の数です。密着度を表します。一定であると結合が継続しているとみなせます。

今回の解釈: 平均して 70〜90 個程度の接触を維持しているように見えます。7.5ns 付近で一時的に下がっていますが（RMSD の跳ねと連動）、その後すぐに回復しています。

• 回転半径（Radius of Gyration）

rg_complex_10ns.pngを開くと以下の様になっていました。

見方: 複合体の「コンパクトさ（凝縮度）」です。シミュレーション期間を通じて一定、もしくは微減する場合、「コンパクトな複合体を維持している」と解釈します。

今回の解釈: 14.0Å 〜 14.4Å の非常に狭い範囲で上下しています。これは、タンパク質がペプチドを抱え込んだまま、ふらつくことなくガッチリした形を保っている証拠です。

最後に

以上がタンパク質と環状ペプチドとのMDシミュレーションのやり方になります。計算時間の長さや行程の複雑さはかなりヘビーでしたが、いかがでしたでしょうか。基本的にはタンパク質のみのMDと大差ないので、慣れている方は問題なくできたかと思います。

結果としては5つの解析すべてが一貫して、10 ns のシミュレーションを通じてタンパク質-ペプチド複合体は比較的安定に結合を維持していることを示していました。ペプチドはタンパク質より柔軟に動いていますが、水素結合・コンタクト数・最小距離のいずれも解離を示唆する変化はなく、安定した複合体として振る舞っています。

今回はMDの長さは10nsでしたが、論文などでは100ns以上で行う場合も多く、シミュレーションの長さや溶媒の種類、温度の条件などは目的に合わせて調節してみてください。また平衡化にももう少し時間をかけてもいいかもしれません。

ぜひマスターしてより高度なin silco創薬をマスターしてみてください！

参考文献

Eastman, P., et al. OpenMM 7: Rapid development of high performance algorithms for molecular dynamics. PLoS Computational Biology (2017). https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1005659

OpenMM公式サイト:　https://openmm.org/

GitHub repository:　https://github.com/openmm/openmm

License: MIT License https://github.com/openmm/openmm/blob/master/docs-source/licenses/Licenses.txt

【この記事のまとめ】

創薬研究者やバイオインフォマティクスエンジニアに向けた、ペプチド医薬品の課題（膜透過性・代謝安定性）を克服し、AIを用いて低分子（ペプチドミメティクス）へ変換・設計するための自動化パイプラインの構築手法を解説します。

• PDB1つで完結する自動設計ワークフロー: ペプチド-タンパク質複合体の構造データから、相互作用解析、ファーマコフォア抽出、ドッキング評価、さらにはAI逆合成解析までをPythonで一気通貫に実行可能。
• 実績あるオープンソースツールの統合: 分子計算の「RDKit」、ドッキングエンジンの「smina」、AI逆合成の「AiZynthFinder」を組み合わせ、客観的な数値（SA ScoreやQED等）に基づいた候補分子の選別を実現。
• 多様な分子設計戦略の提示: 単純なフラグメント化だけでなく、1,400種類のリンカーDBを用いた「リンカーベース設計」や、剛直な骨格を用いる「スキャフォールド設計」により、元の活性を維持した低分子化を提案。

この記事を読むことで、属人的な経験則に頼っていたペプチドミメティクス設計を体系化し、代謝安定性や経口投与の可能性を高めた次世代の低分子候補探索を大幅に効率化できます。

ペプチド医薬品の課題とペプチドミメティクス

ペプチド医薬品は、標的タンパク質に対して高い選択性と結合親和性を示すことで、近年注目を集めています。しかし、実用化にあたっては以下のような課題が存在します：

• 分子サイズが大きい：細胞膜透過性が低く、経口投与が困難
• 代謝安定性が低い：ペプチダーゼによる分解を受けやすい
• 製造コストが高い：合成が複雑で大量生産が困難

これらの課題を解決するアプローチの一つがペプチドミメティクスの設計です。ペプチドミメティクスとは、ペプチドの生物活性を模倣する低分子化合物のことで、ペプチドと同等の結合親和性を持ちながら、**低分子の利点（膜透過性、代謝安定性、経口投与可能性）**を兼ね備えています。

従来のペプチドミメティクス設計では、構造活性相関の解析や化学者の経験と直感に大きく依存していましたが、近年の構造生物学とAI技術の進歩により、より体系的かつ効率的なアプローチが可能になりました。

ペプチド→低分子変換アプローチ

この課題に対して有効なのが、構造情報とAI技術を組み合わせたペプチドミメティクス設計です。本手法では、以下の戦略を採用しています：

1. 相互作用解析：ペプチド-タンパク質複合体から重要な相互作用を特定
2. ファーマコフォアモデリング：薬理活性に必須な化学的特徴を抽出
3. フラグメントベース設計：重要残基のフラグメント化と最適な結合戦略
4. AI逆合成解析：設計分子の合成可能性評価と合成ルート提案

従来の経験ベースの設計とは異なり、構造情報に基づいた系統的なアプローチにより、効率的なペプチドミメティクス探索が可能になります。

これまでペプチドミメティクス設計は専門的な知識と経験を要する複雑なプロセスでしたが、本パイプラインを使用することで、PDBファイル1つから自動的に低分子候補を生成し、合成可能性まで評価することができます。

環境構築

基本環境のセットアップ

こちらに開発したコードを記載しています。

以下を行い、Peptide-to-Small-Molecule環境をセットアップしてください。

# githubレポジトリのダウンロード
git clone https://github.com/Barashin/Peptide_to_small_molecule.git
# Peptide_to_small_moleculeフォルダへ移動
cd Peptide_to_small_molecule
# conda環境の作成
conda create -n peptide_pipeline python=3.11 rdkit -c conda-forge -y
conda activate peptide_pipeline
# 必要パッケージのインストール
pip install biopython numpy scipy matplotlib pillow
# ドッキングエンジン (smina) のインストール
conda install -c conda-forge smina -y

オプション: AI逆合成解析 (AiZynthFinder)

より正確な合成ルートを提案させたい場合は、以下も実行してください：

# AiZynthFinderのインストール
pip install aizynthfinder[all]
conda install -c conda-forge pytables -y
# 公開データのダウンロード
download_public_data aizynthfinder_data

パイプライン全体概要

パイプライン概要

1. 構造入力: ペプチド-タンパク質複合体のPDBファイルを入力。

2. 相互作用解析: 距離ベース接触解析により、重要な相互作用を特定。

3. ファーマコフォア抽出: 薬理活性に必須な化学的特徴（水素結合、疎水性相互作用等）を抽出。

4. 分子設計: 重要残基のフラグメント化と、複数の結合戦略による低分子設計。

5. ドッキング評価: 設計された低分子の結合親和性をsminaドッキングにより評価。

6. 多面的評価: Ligand Efficiency、薬剤らしさ(QED)、合成容易性(SA Score)による総合評価。

7. 逆合成解析: AiZynthFinderによる合成ルート提案と合成可能性評価。

使用ツールとライブラリ

主要ツール

アルゴリズム専用ライブラリ

分子記述子・評価指標

コードの実行

基本的な実行

# サンプルデータで実行
python pipeline.py Protein_Peptide.pdb
# 独自のPDBファイルで実行（チェーン指定）
python pipeline.py your_complex.pdb --protein-chain A --peptide-chain B
# AI逆合成解析を含めた実行
python pipeline.py your_complex.pdb --use-aizynthfinder

パラメータのカスタマイズ

以下のような引数で、様々なパラメータを設定できます：

結果の選抜と可視化

パイプライン完了後、上位候補の選抜と合成スキーム図を生成：

python collect_best.py

結果

相互作用解析

まず、ペプチド-タンパク質複合体から重要な相互作用が自動で特定されます。

相互作用解析

各ペプチド残基の重要度がスコア化され、設計に使用する上位残基が選択されます。

ファーマコフォアモデリング

重要残基から薬理活性に必須な化学的特徴が抽出されます。

ファーマコフォア

水素結合ドナー・アクセプター、疎水性相互作用、芳香環スタッキングなどの特徴が3D空間にマッピングされます。

分子設計戦略

以下の戦略で低分子が設計されます：

1. フラグメントベース設計

• 重要残基の側鎖を直接フラグメント化
• 薬理活性に必須な部分構造を保持

1の後に、以下の２か３の設計が行われます。

2. リンカーベース設計

• 複数フラグメントを様々なリンカーで結合
• 剛直性と柔軟性のバランスを最適化

3. スキャフォールド設計

• 剛直なスキャフォールド（ベンゼン、ピペラジン等）上にフラグメントを配置
• 立体配座の制御と結合親和性の向上

ドッキング評価結果

設計された低分子候補のドッキングスコア分布です。

ドッキングスコア

原子数が約1/3の低分子でありながら、**高い結合親和性(-7.40kcal/mol)**を示す候補が特定されています。

(分子ドッキングでは、大体-7.0 kcal/molだと結合活性があるといわれています）

上位5候補の詳細評価

LE (Ligand Efficiency) = |スコア| / 重原子数。0.3以上が良好。SA Score = 合成容易性。1 (容易) 〜 10 (困難)。6以下が推奨。QED = 薬剤らしさ。0.5以上が推奨。

可視化

だいたいInputの環状ペプチド（緑）と設計されたTop1の低分子（水色）が大体同じところに結合しているのがわかります。タンパク表面上のものなので、相互作用面を多くしたりするともっと結合力が上がると思われます。

AI逆合成解析結果

AiZynthFinderによる合成ルート提案の例です（1位の分子、7ステップ）。

合成スキーム

合成成功確率: 85% (AiZynthFinder予測)推定合成工程: 7ステップ出発物質: 市販化合物からスタート可能

環状ペプチド vs 設計低分子の比較

smina (AutoDock Vina) による比較の制限

結合親和性比較

重要な注意事項: sminaは定性的な評価ツールであり、厳密な結合親和性の定量比較には限界があります。

上図は傾向の把握のためのものであり、設計された低分子が元の環状ペプチドの約1/3の分子サイズでありながら匹敵する結合スコアを示すことを定性的に示しています。

より厳密な結合親和性評価手法

本プロジェクトでは、sminaの制限を補完する追加の評価手法も実装しています。必要に応じて実行してみてください

1. AutoDock CrankPep (ADCP) – 環状ペプチド専用評価

# 環状ペプチドの結合親和性を専用手法で評価
python dock_cyclic_adcp.py

特徴:

• 環状ペプチド専用のモンテカルロ法
• 暗黙的溶媒モデル (implicit solvation) 使用
• より現実的なペプチド結合親和性評価 (典型的範囲: -10〜-35 kcal/mol)
• smina (-5〜-10 kcal/mol) とはスコアスケールが異なるため直接比較不可

2. PRODIGY法 – 界面接触に基づく結合自由エネルギー予測

# 構造ベース結合親和性予測
python analyze_prodigy.py

アルゴリズム:

• タンパク質-ペプチド界面の接触パターン解析
• 残基タイプ別接触数 (荷電性/極性/疎水性) をカウント
• 線形回帰による ΔG 予測 (Vangone & Bonvin, eLife 2015)
• 実験値との相関係数 r = 0.73 (文献値)

3. 統合的評価アプローチ

推奨される評価戦略:

1. 初期スクリーニング: smina による相対順位付け
2. 詳細評価: ADCP (ペプチド) + PRODIGY (複合体) による多角的評価
3. 最終検証: IC50、SPR、ITC等の実験的手法

この多段階評価により、設計された低分子の結合親和性をより信頼性の高い形で評価できます。

活用事例と展望

創薬への応用

本パイプラインは以下のような創薬場面で活用できます：

1. ペプチド医薬品の低分子化：既存のペプチド医薬品をより薬剤らしい低分子に変換
2. PPI阻害剤の設計：タンパク質間相互作用を阻害する低分子の設計
3. アロステリック調節剤の開発：ペプチドベースのアロステリックモジュレーターの低分子化

最後に

本記事では、ペプチド→低分子変換パイプラインを紹介しました。

従来は専門家の経験と直感に依存していたペプチドミメティクス設計を、構造情報ベースの系統的アプローチにより自動化することで、より効率的な創薬研究が可能になります。

特に、PDBファイル1つから合成可能な低分子候補までを一貫して生成できる点は、創薬初期段階での意思決定を大きく加速すると期待されます。

本ツールがペプチド医薬品の課題解決と、より良い医薬品の創出に貢献することを願っています。ぜひ皆さんの研究にもご活用ください！

リポジトリ: https://github.com/Barashin/Peptide_to_small_moleculeライセンス: MIT License

【この記事のまとめ】

In silico創薬に取り組む研究者や学生が、ColabFold等で予測したタンパク質-ペプチド複合体を用いて、GROMACSで分子動力学（MD）シミュレーションを実行する全工程を習得できます。

• 予測構造の欠損修復: PDBFixerを用いて予測構造にありがちな側鎖の欠損原子を自動補完し、AMBER99SB-ILDN力場とTIP3P水モデルを適用する前処理手順を詳説。
• システムの構築と中性化: シミュレーションボックス内への水分子の充填（溶媒和）と、0.15 M NaClによる系の電気的中性化を行う具体的なフローを提示。
• 安定化から本番実行まで: エネルギー最小化（EM）、温度（NVT）・圧力（NPT）の平衡化を経て、10 nsの本番MDを実行するための設定ファイル（mdp）とコマンドを網羅。

読者が得られるメリット：予測された静止構造の不完全さを解消し、信頼性の高いシミュレーション環境でペプチドとタンパク質の相互作用を動的に解析する実践的な技術が身につきます。

環境構築

環境構築はこちらを参考にしてください。

初めての方はこちらの第15章 MD simulationを用いたタンパク質の安定化でＭＤにいったん慣れた方がスムーズになるかと思います。

MDの実行

１．コードの流れ

このコードは、タンパク質-ペプチド複合体の分子動力学（MD）シミュレーションを行うための一連の準備と実行の手順です。ColabFoldなどで予測した構造はしばしば側鎖が不完全なため、PDBFixerでの修復が重要です。

全体は大きく４つのフェーズに分けられます。

1. 初期構造の準備: PDBFixerでPDBファイルの欠損原子を補完し、GROMACS形式に変換し、シミュレーション空間（ボックス）を準備します。
2. システム構築: ボックス内に水を充填して溶媒和を行い、イオンを追加して系を電気的に中性にします。
3. システムの安定化（平衡化）: システムの構造的な不安定性を解消する**エネルギー最小化（EM）**を行い、さらに温度（NVT）と圧力（NPT）を安定化させます。
4. 本番MDの実行: 安定化されたシステムで、実際に分子の動きを追跡するメインのシミュレーションを実行します。

今回は以下の記事で生成した環状ペプチドのMDを行ってみます。

【環状ペプチド】Bolzgenを使ったDe novo環状ペプチドの生成【In silico創薬】 – LabCode

以下のfinal_2_designの中にあるPDBファイルをProtein_Peptide.pdb　とした後にコードを実行してください。

2．コードの全体

mdpファイルが適宜必要なので、先に4.mdpファイルを作成してみてください。

# === 0. 環境のアクティベート ===
eval "$(micromamba shell hook --shell bash)"
micromamba activate gromacs_env
# === 1. 初期構造の準備 (PDBFixer と GROMACSでの前処理) ===
# PDBFixerを実行し、欠損アトム（特に側鎖）を補完
pdbfixer Protein_Peptide.pdb --add-atoms=all --add-residues --output=fixed_complex.pdb
# 修正済みのPDBをGROMACS形式に変換（力場と水モデルを指定）
gmx_mpi pdb2gmx -f fixed_complex.pdb -o complex.gro -p topol.top -ignh -ff amber99sb-ildn -water tip3p
# 構造をシミュレーションボックスの中心に配置（1.0 nm余裕）
gmx_mpi editconf -f complex.gro -o boxed.gro -c -d 1.0 -bt cubic
# === 2. システム構築 (水・イオンの追加) ===
# 水分子を充填
gmx_mpi solvate -cp boxed.gro -cs spc216.gro -o solvated.gro -p topol.top
# イオン追加のための実行ファイルを生成
gmx_mpi grompp -f ions.mdp -c solvated.gro -p topol.top -o ions.tpr
# イオンを追加して系を中和（0.15 M NaCl）
echo "13" | gmx_mpi genion -s ions.tpr -o ionized.gro -p topol.top -pname NA -nname CL -neutral -conc 0.15
# === 3. システムの安定化（エネルギー最小化と平衡化） ===
# [エネルギー最小化 (EM)]
gmx_mpi grompp -f em.mdp -c ionized.gro -p topol.top -o em.tpr
gmx_mpi mdrun -v -deffnm em
# インデックスファイルの作成（温度カップリンググループ用）
#　ここでは選んだ1|2で1(タンパク質)と同じものが作られます。一見意味なさそうですが、index.ndxファイルがあると楽なので、いったんここで作成しています。
echo -e "1 | 2\nq" | gmx_mpi make_ndx -f em.gro -o index.ndx
# [NVT平衡化（温度一定）]
gmx_mpi grompp -f nvt.mdp -c em.gro -r em.gro -p topol.top -n index.ndx -o nvt.tpr
gmx_mpi mdrun -v -deffnm nvt
# [NPT平衡化（圧力一定）]
gmx_mpi grompp -f npt.mdp -c nvt.gro -r nvt.gro -t nvt.cpt -p topol.top -n index.ndx -o npt.tpr
gmx_mpi mdrun -v -deffnm npt
# === 4. 本番MDの実行 ===
# 本番MDのための実行ファイルを生成
gmx_mpi grompp -f md.mdp -c npt.gro -t npt.cpt -p topol.top -n index.ndx -o md.tpr
# 本番の分子動力学シミュレーションを実行（バックグラウンド実行推奨）
nohup gmx_mpi mdrun -deffnm md > md.log 2>&1 &

３．コードの詳細説明

1. 初期構造の準備（PDBFixerとGROMACSでの前処理）

ColabFoldなどで予測された構造は、側鎖の一部が欠損していることがあります（例：LYSのCD, CE, NZ原子など）。この段階でこれらを修復します。

• pdbfixer Protein_Peptide.pdb --add-atoms=all --add-residues --output=fixed_complex.pdb◦ pdbfixerはOpenMMに付属するツールで、欠損している原子や残基を自動で補完します。-add-atoms=allオプションで全ての欠損原子を追加します。
• gmx_mpi pdb2gmx -f fixed_complex.pdb -o complex.gro -p topol.top -ignh -ff amber99sb-ildn -water tip3p◦ GROMACSの**pdb2gmxコマンドで、PDBファイルをGROMACS形式（.gro）に変換します。 ◦ ff amber99sb-ildnでAMBER99SB-ILDN力場を指定し、water tip3pでTIP3P水モデル**を使用します。 ◦ ignhオプションで既存の水素原子を無視し、力場に従って再構築します。 ◦ マルチチェーン（タンパク質+ペプチド）の場合、各チェーンごとにトポロジーファイル（topol_Protein_chain_A.itp, topol_Protein_chain_B.itp）が生成されます。
• gmx_mpi editconf -f complex.gro -o boxed.gro -c -d 1.0 -bt cubic◦ シミュレーションボックスを設定します。d 1.0で分子端からボックス境界まで1.0 nmの余裕を持たせます。

2. システム構築（水・イオンの追加）

• gmx_mpi solvate -cp boxed.gro -cs spc216.gro -o solvated.gro -p topol.top◦ ボックス内を水分子で充填します（溶媒和）。topol.topに水分子数が自動追記されます。
• gmx_mpi grompp -f ions.mdp -c solvated.gro -p topol.top -o ions.tpr◦ イオン追加のための実行ファイルを生成します。
• echo "13" | gmx_mpi genion -s ions.tpr -o ionized.gro -p topol.top -pname NA -nname CL -neutral -conc 0.15◦ **gmx genion**で系を電気的に中和し、生理的塩濃度（0.15 M NaCl）になるようイオンを追加します。 ◦ echo "13"は水分子グループ（SOL）を選択するための入力です。

3. システムの安定化（エネルギー最小化と平衡化）

• エネルギー最小化（EM）◦ 原子間の不自然な近接や角度を解消し、安定した出発構造を得ます。 ◦ 収束条件：最大力 < 1000 kJ/mol/nm
• NVT平衡化（100 ps）◦ 温度を300 Kに安定化させます。 ◦ タンパク質に位置拘束（DPOSRES）を適用して構造を維持します。
• NPT平衡化（100 ps）◦ 圧力を1 barに安定化させ、系の密度を調整します。 ◦ C-rescale圧力カップリングを使用します（位置拘束との組み合わせで安定）。

4. 本番MDの実行

• 10 nsのシミュレーションを実行します。 • nohup ... &でバックグラウンド実行すれば、ターミナルを閉じても継続します。

４．mdpファイル

以下のmdpファイルを作成してください。

ions.mdp

; ions.mdp - used for adding ions
integrator = steep
emtol = 1000.0
emstep = 0.01
nsteps = 50000
nstlist = 1
cutoff-scheme = Verlet
ns_type = grid
coulombtype = cutoff
rcoulomb = 1.0
rvdw = 1.0
pbc = xyz

em.mdp

; em.mdp - Energy Minimization
integrator = steep
emtol = 1000.0
emstep = 0.01
nsteps = 50000
nstlist = 1
cutoff-scheme = Verlet
ns_type = grid
coulombtype = PME
rcoulomb = 1.0
rvdw = 1.0
pbc = xyz

nvt.mdp

; nvt.mdp - NVT equilibration
define = -DPOSRES
integrator = md
nsteps = 50000 ; 100 ps
dt = 0.002
nstxout = 500
nstvout = 500
nstenergy = 500
nstlog = 500
continuation = no
constraint_algorithm = lincs
constraints = h-bonds
lincs_iter = 1
lincs_order = 4
cutoff-scheme = Verlet
ns_type = grid
nstlist = 10
rcoulomb = 1.0
rvdw = 1.0
coulombtype = PME
pme_order = 4
fourierspacing = 0.16
tcoupl = V-rescale
tc-grps = Protein Non-Protein
tau_t = 0.1 0.1
ref_t = 300 300
pcoupl = no
pbc = xyz
gen_vel = yes
gen_temp = 300
gen_seed = -1

npt.mdp

; npt.mdp - NPT equilibration
define = -DPOSRES
integrator = md
nsteps = 50000 ; 100 ps
dt = 0.002
nstxout = 500
nstvout = 500
nstenergy = 500
nstlog = 500
continuation = yes
constraint_algorithm = lincs
constraints = h-bonds
lincs_iter = 1
lincs_order = 4
cutoff-scheme = Verlet
ns_type = grid
nstlist = 10
rcoulomb = 1.0
rvdw = 1.0
coulombtype = PME
pme_order = 4
fourierspacing = 0.16
tcoupl = V-rescale
tc-grps = Protein Non-Protein
tau_t = 0.1 0.1
ref_t = 300 300
pcoupl = C-rescale
pcoupltype = isotropic
tau_p = 2.0
ref_p = 1.0
compressibility = 4.5e-5
refcoord_scaling = com
pbc = xyz
gen_vel = no

md.mdp

長さを変更したい場合は、nsteps = 5000000 ; 10 nsの部分を変更してみてください。

; md.mdp - Production MD (10 ns)
integrator = md
nsteps = 5000000 ; 10 ns
dt = 0.002
nstxout = 0
nstvout = 0
nstfout = 0
nstenergy = 5000
nstlog = 5000
nstxout-compressed = 5000
compressed-x-grps = System
continuation = yes
constraint_algorithm = lincs
constraints = h-bonds
lincs_iter = 1
lincs_order = 4
cutoff-scheme = Verlet
ns_type = grid
nstlist = 10
rcoulomb = 1.0
rvdw = 1.0
coulombtype = PME
pme_order = 4
fourierspacing = 0.16
tcoupl = V-rescale
tc-grps = Protein Non-Protein
tau_t = 0.1 0.1
ref_t = 300 300
pcoupl = Parrinello-Rahman
pcoupltype = isotropic
tau_p = 2.0
ref_p = 1.0
compressibility = 4.5e-5
pbc = xyz
DispCorr = EnerPres
gen_vel = no

５．生成されるファイル一覧

後処理

MDシミュレーション後、解析・可視化のためにトラジェクトリのPBC（周期的境界条件）補正を行います。シミュレーション中にタンパク質がボックス境界を越えて「ジャンプ」したり、分子が分断されて見えるアーティファクトを除去します。

1. 後処理の流れ

後処理は以下の3段階で行います。1回のtrjconv呼び出しで全てを処理することはできないため、段階的に処理します。

1. 分子のwhole化: PBC境界で分断された分子を修復する
2. センタリング: タンパク質をボックスの中心に配置し、PBCアーティファクトを除去する
3. フィッティング: タンパク質の回転・並進を除去し、初期構造に重ね合わせる

2. 後処理コマンド

# === 0. 環境のアクティベート ===
eval "$(micromamba shell hook --shell bash)"
micromamba activate gromacs_env
# === 1. 分子をwhole（完全な形）にする ===
# PBC境界で分断された分子を修復する
# 入力: 0 (System) を出力グループとして選択
printf "0\n" > /tmp/gmx_input.txt
gmx_mpi trjconv -s md.tpr -f md.xtc -o md_whole.xtc -pbc whole -n index.ndx < /tmp/gmx_input.txt
# === 2. タンパク質をボックス中央に配置 ===
# 入力: 1 (Protein) でセンタリング、0 (System) を出力
printf "1\n0\n" > /tmp/gmx_input.txt
gmx_mpi trjconv -s md.tpr -f md_whole.xtc -o md_center.xtc -center -pbc mol -ur compact -n index.ndx < /tmp/gmx_input.txt
# === 3. 回転・並進のフィッティング ===
# 入力: 1 (Protein) でフィッティング、0 (System) を出力
printf "1\n0\n" > /tmp/gmx_input.txt
gmx_mpi trjconv -s md.tpr -f md_center.xtc -o md_fit.xtc -fit rot+trans -n index.ndx < /tmp/gmx_input.txt
# === 4. 中間ファイルの削除 ===
rm -f md_whole.xtc md_center.xtc
# === 5. 最終構造（GRO）のPBC補正（可視化用） ===
printf "1\n0\n" > /tmp/gmx_input.txt
gmx_mpi trjconv -s md.tpr -f md.gro -o md_final.gro -center -pbc mol -ur compact -n index.ndx < /tmp/gmx_input.txt

3. 各コマンドの詳細説明

Step 1: -pbc whole

シミュレーション中に分子がPBC境界をまたいで分断されることがあります。-pbc wholeは、分子の結合情報（トポロジー）を基に、分断された分子を1つのまとまりとして復元します。

Step 2: -center -pbc mol -ur compact

• center：指定したグループ（Protein）をボックスの中心に再配置します。
• pbc mol：各分子をユニットセル内に「ラップ」し、分子がボックス境界を越えて見えるのを防ぎます。
• ur compact：出力されるユニットセルの表現をコンパクト（菱形十二面体に近い形）にします。

Step 3: -fit rot+trans

タンパク質の回転と並進を除去し、リファレンス構造（tprファイルの初期構造）に最小二乗フィッティングします。これにより、RMSD解析やトラジェクトリの可視化が容易になります。

Step 5: 最終構造の補正

md.gro（最終フレームの構造）に対しても同様のセンタリング処理を行い、PyMOLやVMDでの可視化に適したクリーンな構造ファイルmd_final.groを生成します。

Note: MPI版GROMACS（gmx_mpi）はパイプ入力（echo "0" | gmx_mpi ...）が動作しないことがあります。printf でファイルに書き出し、リダイレクト（< /tmp/gmx_input.txt）で入力してください。

4. 生成されるファイル一覧

参考

• 失敗しないGROMACSトラジェクトリの変換方法（Qiita）
• GROMACS公式チュートリアル
• gmx trjconv マニュアル

解析

タンパク質-ペプチド複合体のMDシミュレーション解析では、以下の5つの主要な解析を行います。全て後処理済みのmd_fit.xtcを使用します。

0. 解析用インデックスグループの作成

Chain A（タンパク質）とChain B（ペプチド）を分離したインデックスグループを作成します。

# === 環境のアクティベート ===
eval "$(micromamba shell hook --shell bash)"
micromamba activate gromacs_env
# チェーンごとのグループを作成
printf "splitch 1\nname 18 Protein_A\nname 19 Peptide_B\n18 & 4\nname 20 Protein_A_Backbone\n19 & 4\nname 21 Peptide_B_Backbone\n18 & 3\nname 22 Protein_A_Calpha\n19 & 3\nname 23 Peptide_B_Calpha\nq\n" > /tmp/gmx_input.txt
gmx_mpi make_ndx -f md.tpr -n index.ndx -o index.ndx < /tmp/gmx_input.txt

作成されるグループ:

1. RMSD解析

RMSD（Root Mean Square Deviation）は、初期構造からの構造変化を定量化します。複合体全体、タンパク質単体、ペプチド単体の3つを算出します。このRMSD値はBackboneを使用していますが、Ｃαの原子を使うことの方が多い印象です。

# 複合体全体（Backbone）
# fit: 4 (Backbone), RMSD: 4 (Backbone)
printf "4\n4\n" > /tmp/gmx_input.txt
gmx_mpi rms -s md.tpr -f md_fit.xtc -o rmsd_complex.xvg -n index.ndx -tu ns < /tmp/gmx_input.txt
# タンパク質（Chain A Backbone）
# fit: 20 (Protein_A_Backbone), RMSD: 20 (Protein_A_Backbone)
printf "20\n20\n" > /tmp/gmx_input.txt
gmx_mpi rms -s md.tpr -f md_fit.xtc -o rmsd_protein.xvg -n index.ndx -tu ns < /tmp/gmx_input.txt
# ペプチド（Chain B Backbone）
# fit: 21 (Peptide_B_Backbone), RMSD: 21 (Peptide_B_Backbone)
printf "21\n21\n" > /tmp/gmx_input.txt
gmx_mpi rms -s md.tpr -f md_fit.xtc -o rmsd_peptide.xvg -n index.ndx -tu ns < /tmp/gmx_input.txt

• RMSDが収束（プラトー到達） → システムが平衡に達したことを示す
• ペプチドのRMSDがタンパク質より大きい → ペプチドがより大きく動いている（結合部位で柔軟に揺らいでいる可能性）

後述のプロットのスクリプトをrunさせると以下のようなグラフがでます。

このグラフの見方: 初期構造からどれだけ構造が変化したかを時間で追跡しています。値が小さいほど初期構造に近く、安定しています。

読み取り結果:

• タンパク質（Chain A, オレンジ）: 約 0.8〜1.0 Å で安定。最も変動が小さい
• 複合体全体（Backbone, 青）: 約 1.0〜1.5 Å で推移
• ペプチド（Chain B, 緑）: 約 1.5〜2.2 Å と最も大きく揺らいでいる

解釈: タンパク質は構造が安定している一方、ペプチドはより大きく動いています。これはペプチドがタンパク質表面で柔軟に揺ら いでいることを示します。3つとも開始直後（〜1 ns）に急上昇した後、大きなトレンド変化なく推移しているため、系は概ね平衡に達していると判断できます。

2. RMSF解析

RMSF（Root Mean Square Fluctuation）は、各残基の揺らぎ（柔軟性）を定量化します。

# Cα原子の残基ごとのRMSF
# 3 (C-alpha) を選択
printf "3\n" > /tmp/gmx_input.txt
gmx_mpi rmsf -s md.tpr -f md_fit.xtc -o rmsf_calpha.xvg -n index.ndx -res < /tmp/gmx_input.txt

• RMSFが高い残基 → 柔軟性が高い（ループ領域や末端に多い）
• RMSFが低い残基 → 構造が安定（二次構造のコア部分）
• ペプチド結合界面の残基のRMSF → 結合の安定性に関する示唆

このグラフの見方: 各残基が平均構造からどれだけ揺れたかを棒グラフで示しています。値が高いほどその残基は柔軟に動いています。赤い点線がタンパク質とペプチドの境界です。

読み取り結果:

• タンパク質（青）: 大部分が 0.3〜0.8 Å と安定。ただし、残基 70〜75 付近（約 1.3〜1.7 Å）とC末端付近の残基 110〜115（約 1.7 Å）に高いピークがある
• ペプチド（オレンジ）: 残基 10 付近で最大約 1.85 Å と非常に高い揺らぎを示す

解釈: タンパク質のコア部分（残基 20、60 付近）は RMSFが低く構造的に安定しています。一方、高ピークの箇所はループ領域や末端で、構造的に自由度が高い部分です。ペプチドは特にC末端側（このペプチドでは相互作用していないアミノ酸）で大きく揺れており、結合部位から離れた末端が溶媒中で自由に動いていると考えられます。

3. 水素結合解析

タンパク質-ペプチド間の水素結合数の時間変化を解析します。

# タンパク質(18)-ペプチド(19)間の水素結合
printf "18\n19\n" > /tmp/gmx_input.txt
gmx_mpi hbond -s md.tpr -f md_fit.xtc -num hbond_protein_peptide.xvg -n index.ndx -tu ns < /tmp/gmx_input.txt

• 水素結合数が安定 → ペプチドがしっかり結合している

• 水素結合数が減少 → ペプチドが解離傾向にある

• 水素結合数の揺らぎが大きい → 結合が動的に変化している

  

  このグラフの見方: タンパク質とペプチドの間に形成されている水素結合の数を時間で追跡しています。赤線は50フレームの移動平均です。

  読み取り結果:

  • 瞬間値（緑）は約 4〜12 本の間で変動
  • 移動平均（赤）は序盤 7〜8 本、後半にかけてやや減少し 6〜7 本程度で推移

  解釈: 常に 6〜8 本程度の水素結合が維持されており、ペプチドはタンパク質にしっかり結合した状態を保っていると言えます。水素結合数がゼロに近づいたり急激に減少する様子はないため、シミュレーション中にペプチドが解離する兆候は見られません。ただし後半にかけてわずかに減少傾向があるため、より長い時間スケールでの変化には注意が必要です。

4. 最小距離・コンタクト数解析

タンパク質-ペプチド間の最小原子間距離と、閾値距離（0.4 nm）以内のコンタクト数を解析します。

# 最小距離 (-od) とコンタクト数 (-on)
# 18 (Protein_A), 19 (Peptide_B)
printf "18\n19\n" > /tmp/gmx_input.txt
gmx_mpi mindist -s md.tpr -f md_fit.xtc \ -od mindist_protein_peptide.xvg \ -on numcont_protein_peptide.xvg \ -n index.ndx -tu ns -d 0.4 < /tmp/gmx_input.txt

• 最小距離が常に小さい → ペプチドがタンパク質に密着している

• コンタクト数が安定 → 結合界面の接触が維持されている

• 最小距離が増大 / コンタクト数が減少 → ペプチドの解離を示唆

  

  このグラフの見方: 上段はタンパク質-ペプチド間の最も近い原子対の距離、下段は 0.4 nm 以内にある原子対の数（接触数）を示しています。

  読み取り結果:

  • 最小距離（上段）: 約 1.5〜1.9 Å の範囲で安定。大きな離脱なし
  • コンタクト数（下段）: 約 450〜600 個で変動。中心は約 500 個付近

  解釈: 最小距離が常に約 1.7 Å 付近と非常に近く、タンパク質とペプチドが密着した状態が10 ns を通じて維持されていることを示しています。コンタクト数も大きな減少がないため、結合界面は安定です。もし解離が起こっていれば、最小距離が急増しコンタクト数が急減するはずですが、そのような変化は見られません。

5. 回転半径（Rg）解析

回転半径は、複合体全体のコンパクトさを評価します。

# Protein全体 (1) の回転半径
printf "1\n" > /tmp/gmx_input.txt
gmx_mpi gyrate -s md.tpr -f md_fit.xtc -o gyrate.xvg -n index.ndx < /tmp/gmx_input.txt

• Rgが安定 → 複合体の全体構造が維持されている

• Rgが増大 → 複合体が広がっている（アンフォールディングや解離の可能性）

  

  このグラフの見方: 複合体全体のコンパクトさを示す指標です。値が小さいほど構造がコンパクトにまとまっています。

  読み取り結果:

  • 約 1.41〜1.46 nm の範囲で変動
  • 中心値は約 1.43 nm で、大きなトレンド変化なし

  解釈: Rg が 10 ns を通じてほぼ一定であり、複合体全体の形状が維持されていることを示します。Rgが時間とともに増大する場合はアンフォールディング（構造のほどけ）や複合体の解離を示唆しますが、今回のシミュレーションではそのような兆候はありません。

6. プロットスクリプト

以下のplot_analysis.pyで全解析結果をプロットします。

#!/usr/bin/env python3
"""
タンパク質-ペプチド複合体 MD解析プロットスクリプト
RMSD, RMSF, 水素結合, 最小距離/コンタクト数, 回転半径 を一括プロット
"""
import re
import numpy as np
import matplotlib.pyplot as plt
def parse_xvg(path): """GROMACS .xvg ファイルを読み込み、データ・メタ情報を返す""" meta = {"title": None, "xlabel": None, "ylabel": None, "legends": []} rows = [] with open(path, "r", encoding="utf-8", errors="ignore") as f: for line in f: s = line.strip() if not s: continue if s.startswith(("@", "#")): m = re.search(r'@.*title\s+"([^"]+)"', s) if m: meta["title"] = m.group(1) m = re.search(r'@.*xaxis\s+label\s+"([^"]+)"', s) if m: meta["xlabel"] = m.group(1) m = re.search(r'@.*yaxis\s+label\s+"([^"]+)"', s) if m: meta["ylabel"] = m.group(1) m = re.search(r'legend\s+"([^"]+)"', s) if m: meta["legends"].append(m.group(1)) continue parts = s.split() if len(parts) >= 2: try: row = [float(p) for p in parts] rows.append(row) except ValueError: pass return np.array(rows), meta
def ps_to_ns(t): """ps を ns に変換（1000以上ならpsと判定）""" if len(t) > 1 and t[-1] > 100: return t / 1000.0 return t
# === 1. RMSD ===
fig, ax = plt.subplots(figsize=(8, 5))
for fname, label in [ ("rmsd_complex.xvg", "Complex (Backbone)"), ("rmsd_protein.xvg", "Protein (Chain A)"), ("rmsd_peptide.xvg", "Peptide (Chain B)"),
]: data, meta = parse_xvg(fname) t = data[:, 0] rmsd_nm = data[:, 1] ax.plot(t, rmsd_nm * 10, label=label) # nm -> Å
ax.set_xlabel("Time (ns)")
ax.set_ylabel("RMSD (Å)")
ax.set_title("RMSD - Protein-Peptide Complex")
ax.legend()
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig("rmsd_analysis.png", dpi=200)
print("Saved: rmsd_analysis.png")
# === 2. RMSF ===
fig, ax = plt.subplots(figsize=(10, 5))
data, meta = parse_xvg("rmsf_calpha.xvg")
residues = data[:, 0]
rmsf_nm = data[:, 1]
# チェーン境界を特定（残基番号からProteinとPeptideを判別）
# ※ n_protein はシステムに応じて変更してください
n_protein = 115
colors = ["#1f77b4"] * n_protein + ["#ff7f0e"] * (len(residues) - n_protein)
ax.bar(residues, rmsf_nm * 10, color=colors, width=1.0, edgecolor="none") # nm -> Å
ax.axvline(x=residues[n_protein - 1] + 0.5, color="red", linestyle="--", alpha=0.7)
ax.set_xlabel("Residue Number")
ax.set_ylabel("RMSF (Å)")
ax.set_title("RMSF per Residue (C-alpha)")
from matplotlib.patches import Patch
legend_elements = [ Patch(facecolor="#1f77b4", label="Protein (Chain A)"), Patch(facecolor="#ff7f0e", label="Peptide (Chain B)"),
]
ax.legend(handles=legend_elements)
ax.grid(True, alpha=0.3, axis="y")
plt.tight_layout()
plt.savefig("rmsf_analysis.png", dpi=200)
print("Saved: rmsf_analysis.png")
# === 3. 水素結合 ===
fig, ax = plt.subplots(figsize=(8, 5))
data, meta = parse_xvg("hbond_protein_peptide.xvg")
t = data[:, 0]
hbonds = data[:, 1]
ax.plot(t, hbonds, color="#2ca02c", alpha=0.5, linewidth=0.5)
window = 50
if len(hbonds) > window: hb_smooth = np.convolve(hbonds, np.ones(window) / window, mode="valid") t_smooth = t[window // 2 : window // 2 + len(hb_smooth)] ax.plot(t_smooth, hb_smooth, color="#d62728", linewidth=2, label=f"Moving avg ({window} frames)")
ax.set_xlabel("Time (ns)")
ax.set_ylabel("Number of Hydrogen Bonds")
ax.set_title("Hydrogen Bonds: Protein - Peptide")
ax.legend()
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig("hbond_analysis.png", dpi=200)
print("Saved: hbond_analysis.png")
# === 4. 最小距離 & コンタクト数 ===
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(8, 8), sharex=True)
data_md, _ = parse_xvg("mindist_protein_peptide.xvg")
t_md = data_md[:, 0]
mindist = data_md[:, 1]
ax1.plot(t_md, mindist * 10, color="#9467bd") # nm -> Å
ax1.set_ylabel("Minimum Distance (Å)")
ax1.set_title("Minimum Distance: Protein - Peptide")
ax1.grid(True, alpha=0.3)
data_nc, _ = parse_xvg("numcont_protein_peptide.xvg")
t_nc = data_nc[:, 0]
ncont = data_nc[:, 1]
ax2.plot(t_nc, ncont, color="#8c564b")
ax2.set_xlabel("Time (ns)")
ax2.set_ylabel("Number of Contacts (< 0.4 nm)")
ax2.set_title("Contact Number: Protein - Peptide")
ax2.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig("mindist_analysis.png", dpi=200)
print("Saved: mindist_analysis.png")
# === 5. 回転半径 ===
fig, ax = plt.subplots(figsize=(8, 5))
data, meta = parse_xvg("gyrate.xvg")
t = ps_to_ns(data[:, 0])
rg = data[:, 1]
ax.plot(t, rg, color="#17becf")
ax.set_xlabel("Time (ns)")
ax.set_ylabel("Radius of Gyration (nm)")
ax.set_title("Radius of Gyration - Protein-Peptide Complex")
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig("gyrate_analysis.png", dpi=200)
print("Saved: gyrate_analysis.png")
plt.close("all")
print("\nAll analysis plots generated successfully.")

実行:

python plot_analysis.py

7. 生成されるファイル一覧

最後に

5つの解析すべてが一貫して、10 ns のシミュレーションを通じてタンパク質-ペプチド複合体は安定に結合を維持していることを示しています。ペプチドはタンパク質より柔軟に動いていますが、水素結合・コンタクト数・最小距離のいずれも解離を示唆する変化はなく、安定した複合体として振る舞っています。

以上タンパク質とペプチドリガンドとのMDでした。今回はMDの長さは10nsですが、状況に応じて変えてみてください。基本的には複合体といえど、タンパク質のみのMDとあまり設定上は大差がなかったので、慣れている人は簡単にできた思います。ぜひいろいろな複合体にMDをやってみてください！

参考

• GROMACS公式チュートリアル
• GROMACS Manual – gmx rms
• GROMACS Manual – gmx rmsf
• GROMACS Manual – gmx hbond
• GROMACS Manual – gmx mindist
• GROMACS Manual – gmx gyrate
• GROMACS Tutorials
• GROMACS Manual

【この記事のまとめ】

本記事は、創薬研究やバイオインフォマティクスに携わる方へ向けて、生成AI（潜在拡散モデル）を活用して標的タンパク質に結合する環状ペプチドをゼロから設計する革新的手法「BOLZGEN」 の仕組みと有用性を解説しています。

• 潜在拡散モデル（LDM）とRosettaの融合: 幾何学的な拡散モデルを用いてペプチドのバックボーンを生成し、物理ベースのRosettaで配列設計とエネルギー最適化を行うことで、高精度な設計を実現しています。
• 難関ターゲットでの実証: MDM2やIL-17といった重要な創薬標的に対し、既存手法を上回る設計成功率と、実験的に裏付けられた高い結合親和性（K_D値）を示しています。
• 高い安定性と多様な設計: 生成される環状ペプチドは熱安定性に優れ、多様な構造サンプリングが可能なため、従来の設計手法では到達できなかった新しい阻害剤の探索が可能です。

この記事を読むことで、AIがどのように環状ペプチドの複雑な構造を学習し、実用レベルの創薬候補へと昇華させるかの具体的なプロセスを把握できます。

Bolzgenとは？

Bolzgenとは、タンパク質の立体構造のデザインから、配列のデザイン、その親和性の予測といった構造の評価までを一貫して行えるde novoタンパク質デザインツールのことです。様々なタイプの立体構造のデザインに対応しており、環状ペプチドのデザインにも利用することができます。

同じく拡散モデルを利用する環状ペプチドデザインツールとしてはRFPeptideが挙げられますが、BolzgenはRFPeptideと比較して、一つのツールでより多くのステップを一気通貫で完結させられます。具体的には、RFPeptideの場合では立体構造のデザインからその構造の評価までを行うために、立体構造のデザインにRFPeptide、配列予測にProteinMPNN、構造の評価にAlphaHoldというように3つのツールを使う必要がありましたが、BolzgenではこれらのステップをBolzgenのみで行うことが可能です。

また、RFPeptideでは、立体構造のデザインとアミノ酸配列の構築という2つのステップが段階的に行われる為に、立体構造のデザインの際にアミノ酸配列では物理的に構築不可能な構造がデザインされてしまう可能性がありましたが、今回紹介するBolzgenでは立体構造のデザインと配列予測が統合的に行われるため、アミノ酸で構成可能な立体構造のみをデザインできる様になっています。

Bolzgenの原理

以下でツールの原理をもう少し詳しく説明します。(以下は、専門的なので読み飛ばしても大丈夫です。)

Bolzgenは、all-atom diffusion modelと呼ばれる拡散モデルを利用しています。このモデルによって、Bolzgenは構造デザインとアミノ酸配列の構築を同時に行うことができます。このモデルを簡単に説明すると、アミノ酸の形やその特徴(疎水性残基は内部に配置されやすいや、極性残基は表面に出やすいなど)を理解できるようになった立体構造生成モデル(diffusion model)です。

diffusion modelとは、特定の条件(例：たんぱく質Aに結合する)を満たす立体構造を生成するためのモデルでRFPeptideにも利用されていますが、RFPeptideのモデルは主に「骨格構造（backbone）」のみを対象としていました。つまり、主鎖原子の構造を生成することはできても、側鎖を含めた原子レベルでの精密な構造までは同時に扱えないという制約があり、この制約から上述のように生成された構造と残基の整合性が必ずしも保証されていませんでした。

Bolzgenのall-atom diffusion modelでは、残基タイプの幾何学的エンコーディングという方法を利用して、この制約を突破しています。残基タイプの幾何学的エンコーディングとは、アミノ酸の種類ごとの①形状と分子組成、②立体構造の自由度、③残基の化学的な性質(電荷や水素結合のしやすさなど)、④タンパク質立体構造下での特徴（内部に埋もれやすいか、表面に出やすか）などの特徴を機械学習モデルが扱える形に変換することです。

all-atom diffusion modelはこれを行うことにより、立体構造を生成する機械学習モデルでありながら、アミノ酸の形と特徴を理解できるようになっており、従来のモデルの様に、単に主鎖原子の座標情報だけを扱うのではなく、「その原子がどのアミノ酸残基に属しているのか、そしてそのアミノ酸はどのような特徴をもっているのか」という化学的な情報を、幾何学的な特徴として同時にモデルへ組み込むことが出来るのです。

この特徴によりBolzgenでは、構造デザインの段階で既に「この配列で折りたたみ可能か」「結合界面が安定か」といった情報を考慮した生成が行われます。結果として、従来のように構造生成後に別ツールで配列を当てはめ、さらに別ツールで評価するといった段階的プロセスに比べて、より整合性の取れたデザインが可能になります。

またBolzgenは、単なる構造生成にとどまらず、生成した候補に対して結合親和性や安定性をスコアリングする仕組みも組み込まれているため、設計から評価までを一つのフレームワークで完結させることができます。

このようにBolzgenは、環状ペプチドを含むde novoタンパク質デザインにおいて、従来よりも統合的かつ実用的なワークフローを提供するツールとして注目されています。

Bolzgenの環境構築

では早速、Bolzgenを利用して見ましょう。

まずはこちらを参考に環境構築から行っていきます。今回もWindowsのWSLを利用していきます。WSLの利用方法はこちらの記事に記載してあるので、そちらを参考にしてください。

今回のツールはGPUを利用するツールのため、まずはこちらのサイトでお使いのPCに搭載されているGPUに 対応したドライバ（Windows11用。Linux用ではありません）をDLして、Windows 上でインストーラを実行し、再起動して有効化してください。また、どのドライバーが良いのか分からない場合は、こちらのNDIVIA appをインストールすると最適なドライバーをインストールしてくれるようです（既にインストール済みの場合は不要です。）

次に、WSLのターミナルで以下のコードを実行して、環境構築をしていきます。

ターミナルを開き、以下を実行してください。途中で3回ほどEnterキーの入力を求められますので、入力することを忘れないようにしてください。

# miniconbaがインストールしていない場合は、以下を実効
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash ~/Miniconda3-latest-Linux-x86_64.sh
# 途中で3回ほどEnterキーの入力を求められますので、入力してインストールを続行してください
# 以下で初期化し、minicondaを有効にします
source ~/.bashrc
# ここまでminicondaのインストール
# condaでbgという環境を作り、pythonをインストール
conda create -n bg python=3.12 -y
conda activate bg
# boltzgenをインストール
pip install boltzgen

Bolzgenの実行

これで準備が整いました。Bolzgenを利用して行きます。

まずは、作業したいフォルダを決めます（私はWindowsのdocuments下に作ったbolzgenというフォルダで作業します）。

次に、Bolzgenに渡すターゲットタンパクの立体構造のPDBファイルを用意します。利用する立体構造はご興味に合わせてどのようなものでも良いですが、私はRFPeptideの解説の際に利用したタンパクファイル（7zkr_GABARAP.pdb）をダウンロードして、ターゲットタンパクとしました。

（既に目的のタンパク構造ファイルがある方も同様に、ここで立体構造ファイルをコピペで作業フォルダ内に置いておきましょう）。

7zkr_GABARAP.pdbのファイルはこちらからダウンロードできます。ダウンロードしたファイル(rfd_macro.tar.gz)のexamples>input_pdbs内にあるので、こちらのPDBファイルを作業フォルダ内に移動しておきましょう。

そして、以下のコマンドで作業したいフォルダに移動します

# 作業フォルダへ移動
cd /mnt/c/users/(あなたのWondowsのユーザー名)/documents/bolzgen

/documents/RFPeptideは、ご自身が作業したいフォルダの名前に合わせて変更して下さい。そして、作りたい環状ペプチドの構造を指定するためのYAML(ヤムル)ファイルを準備します。

まずは、WSLで以下を実行して下さい。nanoというツールを起動して、こちらでYAMLファイルを作成します。

nano cyclic_cs_binding.yaml

そして、開いたwindowに以下をコピペ。

entities: - file: path: /mnt/c/users/(あなたのWondowsのユーザー名）/Documents/bolzgen/7zkr_GABARAP.pdb include: - chain: { id: A } - protein: id: CP sequence: 10..20 cyclic: true
binding_types: - chain: id: A binding: 163..181

その後、キーボード入力で Ctrl + O でファイルを保存。その際、ファイル名の確認を求められるので、問題なければEnterで決定し、Ctrl + X でnanoを終了してください。

このYAMLファイルはいわば環状ペプチドの設計仕様書のようなもので、どのように環状にするかや、結合したいタンパク質やその結合部位を指定することができます。

あとは以下のコマンドでbolzgenを実行します。実行の終了まで時間がかかりますが、問題がなければこれで環状ペプチドのデザインが出力されているはずです。

boltzgen run cyclic_cs_binding.yaml \ --protocol peptide-anything \ --output ./output_run1 \ --num_designs 5 \ --budget 2

実行結果

作業フォルダにoutput_run1というフォルダが出来、中身が以下の様になっていれば成功です。

configフォルダには、今回のデザイン設定の詳細が、final_ranked_designsフォルダには、最終的にbolzgenで選ばれたデザインが、intermediate_designsフォルダには、立体構造と配列の決定の途中経過の詳細が、intermediate_designs_inverse_foldedフォルダには、配列が決定した後の途中経過の詳細が入っています。cyclic_cs_binding.cifは生成前のスタート時点の構造が、steps.yamlには今回の実行でどのような計算を行ったのかの説明が記されています。

final_ranked_designsフォルダの中身は以下の様になっています。

final_2_designsフォルダには、最終的に選ばれた2つの環状ペプチドデザインが、intermediate_ranked_10_designsフォルダには、上位10位までのデザインが、2つのCSVファイルにはそれぞれのデザインのスコアが、pdfファイルには、スコアやフィルタリング基準がグラフ化された今回の結果のレポートが出力されています。

2つのCSVファイルのうち、final_designs_metrics_2.csvの中には、以下の様に上位2つのデザインのスコアが入っています（CSVファイルはエクセルなどで開くと表形式で見やすく表示できます）。

実際のCSVには100種類を超える様々なスコアが並んでいますが、特に重要なスコアは以下の4つのようです（以下では、実際のCSVファイルの中身を省略して、一部を示しています。）。

• design_to_target_iptm　設計したペプチドがターゲット（GABARAP）にどれくらい強く結合しそうか。一般に0.7以上はまずまず。0.8以上だと良い。
• min_design_to_target_pae　結合位置の誤差（不確かさ）です。　低いほどよく、一般に2以下なら良い。5以上は信頼性が低い。
• filter_rmsd　立体的に無理がないか（衝突や崩れ）を見る指標です。低いほどよく、一般に2以下なら良い。5以上は信頼性が低い。
• liability_violations_summary　分解されやすい構造があれば記載される。今回はAspCleave(pos1,sev10); ProtTryp(pos10,sev10) などの記載があり、ASP部位やトリプシン切断部位があるとのこと。

モデルの性質上、完全に同じ結果とはなっていないはずですが、皆様はどの程度のスコアとなっていたでしょうか。

最後に、Mol* Viewerで先ほどのfinal_2_designsフォルダの中からrank1_cyclic_cs_binding_0.cifの構造を視覚的に確認してみましょう！

上記のリンクからビューワーを開き、Open fileからrank1_cyclic_cs_binding_0.cifをアップロードして、Applyをしてください。アップロードしたcifファイルが開き、bolzgenで作成した環状ペプチドと目的タンパク質の構造が確認できます。（以下の画像を参考に進めてください。）

ファイルが開くと、以下の様になっていました。生成された環状ペプチド(下の赤枠で囲った部分)が目的タンパク質の指定した箇所に結合していそうなことが確認できました。

コードの解説

上に書いたソースコードの解説をしていきます。 以下は、BoltzGen を動かすためのPython環境を作ることを目的としたコードです。

# miniconbaがインストールしていない場合は、以下を実効
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash ~/Miniconda3-latest-Linux-x86_64.sh
# 途中で3回ほどEnterキーの入力を求められますので、入力してインストールを続行してください
# 以下で初期化し、minicondaを有効にします
source ~/.bashrc
# ここまでminicondaのインストール

ここまでは、minicondaというツールをインストールするためのコマンドです。minicondaを利用して、環境構築をすることで簡単にPython環境を用意することが出来ます。すでにインストールしている場合は、不要です。

# condaでbgという環境を作り、pythonをインストール
conda create -n bg python=3.12 -y
conda activate bg
# boltzgenをインストール
pip install boltzgen

conda create -n bg python=3.12 -y これは、bgという名前の環境をconda createで作成し、Python3.12をインストールするというコマンドです。Bolzgenはpython3.12に対応しているので、このバージョンのpythonをインストールします。-yというオプションでインストール時の確認を省略しています。

conda activate bg で、作成したbg環境を有効化しています。

pip install boltzgen で、先ほどの環境内にbolzgenをインストールしています。

以下は、ymlファイルの解説です。

entities: - file: path: /mnt/c/users/(あなたのWondowsのユーザー名）/Documents/bolzgen/7zkr_GABARAP.pdb include: - chain: { id: A } - protein: id: CP sequence: 10..20 cyclic: true
binding_types: - chain: id: A binding: 163..181

まず、以下のパートは結合させるタンパク質を指定しています。path: /mnt/c/users/(あなたのWondowsのユーザー名）/Documents/bolzgen/7zkr_GABARAP.pdbでタンパク質の立体構造ファイルを指定し、- chain: { id: A } でタンパク質の鎖を指定しています。今回のタンパク質ファイル内にはA鎖のみですが、複数の鎖があった場合にはここで指定が可能です。

- protein: これは新しく作成するペプチドに関する条件を指定します。id:でペプチドの名前を指定し、sequence:で長さを指定できます。sequence: 10..20は10~20残基の長さを指定しています。cyclic: trueで環状ペプチド(C-N接続)を指定しています。

binding_types: では、結合させたい箇所を指定できます。id: AでA鎖の、binding: 163..181で163~181残基に結合するように指定しています。

ちなみに今回は、N末端とC末端をつなげて「環状ペプチド」にするように指定しましたが、以下のyamlの様に書くことで、Cys–Cys disulfide結合による環状ペプチドをしてすることが出来ます。

entities: - file: path: /mnt/c/users/(あなたのWondowsのユーザー名）/Documents/bolzgen/7zkr_GABARAP.pdb include: - chain: { id: A } - protein: id: C sequence: 1..5C6C1..5
constraints: - bond: atom1: [C, 2, SG] atom2: [C, 9, SG]
binding_types: - chain: id: A binding: 163..181

この場合は、cyclic: true を使わずに、constraints: の-bond:で結合させたいCys残基を指定して下さい。また、この時に、- protein: のsequence:でC(Cys)が配列のどこかに二か所に必ず含まれるように指定しておくことを忘れないでください。

また、今回は利用しませんでしたが、以下のstructure_groups:オプションで結合させたいタンパク質の一部が可変する場合の設定も可能なようです。

 structure_groups: - group: id: A visibility: 1 - group: id: A visibility: 0 res_index: 32..42

最初にA鎖全体をvisibility: 1で可変構造にしないとしてした後に、再度 - group: して、res_index: でA鎖の一部(今回は32~42)を visibility: 0 で可変可能な構造として指定できます。結合で形が変わる場所や、もともと柔軟に動く場所があるタンパク質の場合はこちらのオプションを使うこともよいかもしれません。

以下は、bolzgenの実行コードです。

boltzgen run cyclic_cs_binding.yaml \ --protocol peptide-anything \ --output ./output_run1 \ --num_designs 5 \ --budget 2

これは、boltzgenの実行コマンドです。

• boltzgen→ BoltzGen の実行コマンド（本体）
• run → 設計を開始する命令
• cyclic_cs_binding.yaml → 設計のルールを書いた設定ファイルを指定
• -protocol → どんな設計モードで動かすか指定するオプション。今回は、peptide-anything

という ペプチド設計用のプロトコルを指定。

• -output→ 結果を保存する場所を指定するオプション。今回は、./output_run1を指定し、今いるフォルダの中に output_run1 を作ってそこに保存させた。
• -num_designs→ 何個の設計を作るかを指定するオプション。今回は5個を指定。実際は、論文によると1~6万個ほどを指定し、そこから最適なものを探すのが良いそう。
• -budget → 計算の強さ（探索の回数やコスト）を指定するオプション。今回は、テスト用に2を指定。大きくすると精度が上がるが、計算時間が増える。

最後に

皆様、いかがだったでしょうか。BolzgenはYAMLファイルの書き方に癖があるものの非常に多彩な設計やスコア評価を、一つのツールで一貫してできることが分かったかと思います。

RFPeptideと比較してどちらが高性能かは議論の余地があるものの、一つで構造生成、配列決定、評価までが出来るこのツールの便利さが実感できたかと思います。

これからの創薬でも利用されていきそうなこのツールを、ぜひ、皆様も実際に動かしてみてください！

【この記事のまとめ】

創薬研究者やバイオインフォマティクスに関心がある方に向けて、機械学習（ML）による活性予測と強化学習（RL）を組み合わせ、膨大な探索空間から「高活性な環状ペプチド」を自律的に効率よく特定する手法を解説します。

• 強化学習による知的探索の自動化：単なるランダムスクリーニングではなく、強化学習エージェントが「より高い報酬（活性）」を求めて配列を最適化する高度な探索プロセスを学べます。
• ML代理モデルによる高速評価：ドッキングシミュレーション等の重い計算を機械学習モデルで近似（代替）し、計算コストを抑えつつ膨大な数の配列をスクリーニングするパイプラインを構築します。
• Pythonによる実践的ワークフロー：環境構築から報酬設計（Reward Design）、学習曲線の可視化まで、実際のコードを交えてハンズオン形式で紹介しています。

この記事を読むことで、AIが自ら「最適な配列」を学習・提案する次世代のスクリーニング環境を、自身のPCやクラウド環境に構築できるようになります。

分子ドッキングを使ったIn silico screening

インシリコスクリーニングとは、コンピューター上で多数の化合物を扱い、標的となるタンパク質などに結合しそうな分子を効率よく探し出す手法です。実験を行う前段階として用いられ、創薬研究における探索工程を大幅に高速化できる点が特徴です。

その代表的な方法の一つが分子ドッキングを用いたインシリコスクリーニングです。分子ドッキングでは、化合物が標的分子のどこに、どのような姿勢で結合するかを計算機上で予測し、その結合の強さをスコアとして評価します。

このスコアを指標にすることで、数万〜数百万といった膨大な化合物の中から、標的に対して結合力が高いと予測される候補分子を効率的に絞り込むことが可能になります。分子ドッキングを用いたインシリコスクリーニングは、「まず当たりをつける」ための手法として、現在の創薬研究において欠かせないアプローチとなっています。

分子ドッキングを用いたインシリコスクリーニングは強力な手法ですが、一方で課題も存在します。特に、スクリーニングに用いる化合物がランダムに生成されたものである場合、膨大な候補の中から高い結合力を持つ化合物に到達するまでに多くの計算資源と時間を要します。つまり、「当たり」を引くまでの効率が必ずしも高くないという問題があります。

機械学習、強化学習を使ったIn silico screening

この課題に対して有効なのが、機械学習や強化学習を用いたインシリコスクリーニングです。これらの手法では、過去の評価結果（例えば分子ドッキングスコア）をもとに学習を行い、「次に高い結合力を示しそうな化合物」や「有望な配列」を意図的に提案することができます。

さらに、機械学習や強化学習によって提案された化合物を分子ドッキングで評価することで、計算機上での予測と実測（ドッキング評価）を組み合わせた効率的な探索が可能になります。

これまで環状ペプチドの機械学習・強化学習には Mobiusというパッケージを紹介してきましたが、実運用の面では扱いづらい点もありました。そこで本記事では、環状ペプチドのインシリコスクリーニングをより直感的かつ柔軟に行えるよう、新たに一から開発した手法を紹介します。

この手法を用いることで、読者の皆さんが興味を持つ環状ペプチドと標的分子の組み合わせに対して、機械学習・強化学習と分子ドッキングを組み合わせたスクリーニングを実践し、結合力の高い候補分子を効率よく見つけることが可能になります。

環境構築

仮想環境の構築

こちらに開発したコードを記載しています。

以下を行い、In_silico_screening環境をセットアップしてみてください。

#githubレポジトリのダウンロード
git clone https://github.com/Barashin/In_silico_screening_of_macrocyclic_peptides.git
#In_silico_screening_of_macrocyclic_peptidesフォルダへ
cd /home/shizuku/In_silico_screening_of_macrocyclic_peptides
#GNN + Active Learning環境の設定
bash setup_in_silico_screening.sh
# AutoDock CrankPep環境の設定
bash adcpsuite_micromamba.sh

また以下でテストを行なってください。

#環境のアクティベート
micromamba activate in_silico_screening
#環境テスト
python test_environment.py

インプットファイルの設定

以下のディレクトリ構造を参考に

Inputフォルダ：標的タンパク質（例：1O6K_noligand.pdb)、結合ペプチド（例：Peptideligand.pdbqt)

docking_setupフォルダ：結合場所の内容が入ったファイル（例：1O6K.trg）

を作成してください。

Research_Linux/
├── Research/ # Pythonモジュール（必須）
│ ├── active_learning_gnn.py
│ ├── transformer_models.py
│ └── adcp_interface.py
│
├── Input/ # 入力ファイル（.trg作成時に必要）
│ ├── 1O6K_noligand.pdb
│ └── Peptideligand.pdbqt
│
├── docking_setup/ # ターゲットファイル（必須）
│ └── 1O6K.trg
│
├── result/ # 初期ドッキング結果（自動作成）
├── result_active_learning/ # AL結果（自動作成）
└── al_output/ # 最終出力（自動作成）

全実装概要

1. リード入力: 最適化の起点となる親配列を決定する。

2. データ洗浄: 既存ファイルを走査し、外れ値を自動除外する。

3. 初期収集: 有効データが50件（変更可能）に達するまで、自動変異とドッキング(Autodock CrankPep)を繰り返す。

4. モデル選定: 9種類のアルゴリズムを比較し、最も予測精度の高いモデルを採用する。

5. 能動学習: AIが選んだ有望候補をドッキングし、10回ループで精度と活性を磨き上げる。

6. 結果出力: 改良されたTop 10配列と、進捗を可視化した最終レポートを生成する。

コードの実行

コードは以下で実行できる

python active_learning_from_lead.py --lead "htihswqmhfkin"

デフォルト設定だと、50個の環状ペプチドを—lead に記入した配列から自動生成し、その後の分子ドッキング→機械学習→強化学習へと進む

以下のような引数で、いろいろなパラメータを設定できる。

| 引数 | 短縮 | デフォルト | 説明 |
|------|------|-----------|------|
| `--lead` | `-l` | (必須) | リード配列 |
| `--existing-dir` | | result/ | 既存結果のディレクトリ |
| `--iterations` | `-i` | 10 | ALイテレーション数 |
| `--batch-size` | `-b` | 5 | 各イテレーションの配列数 |
| `--runs` | `-N` | 5 | MC探索回数 |
| `--evals` | `-e` | 100000 | 評価ステップ数 |
| `--timeout` | | 600 | ドッキングタイムアウト（秒） |
| `--acquisition` | | EI | 獲得関数 (EI/UCB/PI) |
| `--min-usable-samples` | | 50 | 学習に必要な最小サンプル数（外れ値除く） |
| `--auto-select-model` | | False | 最良モデルを自動選択 |
| `--production` | | | 本番設定 (timeout=1200) |
| `--quick` | | | クイックテスト (N=1, n=5000, min_usable=20) |
| `--no-confirm` | | | 確認スキップ |

結果

ペプチドライブラリの生成

まずleadの配列をランダムに変異させた50個（デフォルト値変更可能）の配列が生成する

モデルの比較

次にその配列と結合力を使用し、様々な機械学習モデルが作成され、比較される。

評価指標(R2)を用いて、Bestなものが自動的に選ばれるが、ぜひ目で見て確認してほしい。(CatBoostが過学習気味ではあるが、結構良さそうな感じでもある）

1. グラフニューラルネットワーク (GNN) 系化合物を「原子＝ノード」「結合＝エッジ」とするグラフ構造として捉えるモデル群です。

• GIN / GCN / GAT: グラフ上のノード情報を近傍から集約する標準的な手法。画像ではGATの精度が低く、このタスクへの適性は慎重な判断が必要です。
• GraphSAGE: 近傍ノードのサンプリングと集約を行う手法。
• MPNN (Message Passing Neural Network): 原子間のメッセージ伝達を模した、化学分野で非常に強力なモデルです。

2. トランスフォーマー (Transformer) 系自然言語処理で使われる「注目機構（Attention）」を応用したモデルです。

• SeqTransformer: ペプチドのアミノ酸配列（文字列情報）をシーケンスとして処理します。
• GraphTransformer: グラフ構造にAttention機構を導入し、原子同士の遠距離の相関も考慮します。

3. その他（CNN・勾配ブースティング）

• CNN1D: 1次元の畳み込みニューラルネットワーク。主に配列情報の局所的なパターン抽出に使用されます。
• CatBoost: 決定木ベースの勾配ブースティングアルゴリズム。Train $R^2 = 0.998$ と非常に高いですが、Testスコアとの乖離が大きく、過学習（Overfitting）の傾向が見て取れます。

ペプチドの探索

モデルを選ぶと、

1. さらに結合力が高い配列が提案(5個)
2. 実際に分子ドッキング
3. モデルの学習へ
4. 1-4のループ

がなされる。最終的に結合力の高い配列が提案されます。

最終結果で結合力が高すぎるものはFalse positiveな感じもしますが、出てきたものについては、PRODIGYや実験でValidationするとよいでしょう。

最後に

以前紹介したRFPeptide→ProteinMPNNでDe novo環状ペプチドの合成した後の配列を使用すれば、

さらなる結合力の向上も可能です。ぜひ試してみてください！

今後は非天然アミノ酸の導入や膜透過性の指標も入れて、様々な指標でよい結果がなるような環状ペプチドの合成を試そうと思います！

【この記事のまとめ】

本記事では、創薬研究者やバイオインフォマティクス初学者に向けて、最先端の配列設計AI「ProteinMPNN」を駆使して、高い構造安定性を持つ環状ペプチドの配列を精密にデザインする方法を解説します。

• 高精度な配列最適化：骨格構造（バックボーン）に最適なアミノ酸配列を数秒で生成し、設計の成功率を従来の物理化学的手法よりも大幅に向上させます。
• 環状構造への特化設定：N末端とC末端を連結させる環状ペプチド特有のパラメータ設定や、計算を効率化するための「タイリング（Tying）」の手法を習得できます。
• 実践的な実行フロー：Google Colab等での環境構築から、実際のコマンド入力、設計結果の評価まで、ステップバイステップで詳しくガイドします。

この記事を読むことで、最新のAI技術を自身の研究に取り入れ、標的タンパク質に強く結合する「次世代の環状ペプチド候補」を効率的に創出できるようになります。

ProteinMPNNとは？

ProteinMPNN は、タンパク質の立体構造（バックボーン座標）からアミノ酸配列を設計するための深層学習モデルです。簡単に言うと、「構造からその構造にマッチする最適な配列を予測するAI」です。

Message Passing Neural Network (MPNN)を用いることで、従来法(Rosetta Design等)に比べ、速く、正確で、構造に忠実な配列設計ができる可能性があるツールです。こちらも前回のRFPeptide同様GPUを利用するツールです。もしもGPUドライバーがインストールされていない場合は、前回の記事を参考にインストールしておきましょう。

以下で、少しだけこのツールの仕組みを深堀します。MPNNとはグラフ構造データを扱うためのニューラルネットワークの一種で、簡単に言うと、ノード（点）とエッジ（線）で表される構造情報をもとに、各ノードの状態を更新して特徴を学習する仕組みです。 このMPNNで、ノードをアミノ酸、エッジを残基間の距離や結合に見立てて、グラフ構造としてタンパク質の立体構造を扱うことで、遠くのアミノ酸から付近のアミノ酸までを自然な形で重みをつけて考慮することが可能になっています。

ProteinMPNNでは、このMPNNによってアミノ酸配列と立体構造の関係が学習されており、これをタンパク質設計に応用しています。

ProteinMPNNの実装方法

では早速、ProteinMPNNでこちらの記事で作成した環状ペプチド骨格に最適なアミノ酸配列を予測していきます。

こちらを参考に環境構築から行っていきます。今回もWindowsのWSLを利用していきます。WSLの利用方法がわからない場合は、こちらの記事に記載してあるのでそちらを参考にしてください。

前回の記事と同様に、環境構築はmicromambaで行います。WSLで以下を実行してください。途中で [Y/n] の入力を求められたら、Yを入力してください。

# GitHub から ProteinMPNN をクローン
git clone https://github.com/dauparas/ProteinMPNN.git
cd ProteinMPNN
# micromambaで環境を用意
micromamba create -n mlfold python=3.10 -y
# 環境の有効化
micromamba activate mlfold
# 必要なパッケージをインストール
micromamba install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch
# 学習済みのモデルをダウンロード
wget https://github.com/dauparas/ProteinMPNN/blob/main/vanilla_model_weights/v_48_002.pt
wget https://github.com/dauparas/ProteinMPNN/blob/main/vanilla_model_weights/v_48_010.pt
wget https://github.com/dauparas/ProteinMPNN/blob/main/vanilla_model_weights/v_48_020.pt
wget https://github.com/dauparas/ProteinMPNN/blob/main/vanilla_model_weights/v_48_030.pt

プログラムを実行する

これでProteinMPNNを実行する用意が整いました。実際にこれから実行をしていきます。

私は前回の記事で作成したdesign_0.pdbファイルの構造に対して、ProteinMPNNを実行します。そのため、pdbファイルを保存していたフォルダ内にMPNNoutputというフォルダを作成し、そのフォルダにProteinMPNNの結果が保存されるように指定して実行しました。もしも、別のファイルを対象にProteinMPNNを実行したい場合や、別の保存場所を利用したい場合は、--pdb_pathと--out_folder に関して、ご自身の保存場所や指定したいファイルに合わせて変更してください。

前回の記事を参考に進めていただいている場合は、上記のパス設定はそのままで、アウトプットの保存先として、/Documents/RFPeptide/samplesフォルダ内にMPNNoutputという名前のフォルダを作成してから、以下を実行してください。

# ProteinMPNNを実行
python ProteinMPNN/protein_mpnn_run.py \ --pdb_path documents/RFdiffusion/samples/design_0.pdb \ --pdb_path_chains "B" \ --out_folder /documents/RFdiffusion/samples/MPNNoutput \ --model_name v_48_020 \ --num_seq_per_target 2 \ --sampling_temp 0.1 \ --seed 42 \ --batch_size 1

実行結果

MPNNoutputフォルダに/documents/RFPeptide/samples/MPNNoutputdesign_0.faseqsというフォルダが出来、その中にdesign_0.faというファイルができてその中身がいれば成功です！

このファイルはメモ帳などで開くことができます。実際に確認してみると以下の様になっていました。指定通りに、“ESGIIDIETGERIP”と“ESGIIDIETGEKIP”の2種類のアミノ酸配列が予想されたことが分かります。ESGIIDIETGERIPこのファイルをメモ帳などで開くと以下の様になっているはずです。この3行目以降がProteinMPNNで予測された、骨格構造に沿ったアミノ酸配列です。指定通りに2種類の配列が予測されました。

design_0, score=3.7456, global_score=1.9113, fixed_chains=['B'], designed_chains=['A'], model_name=v_48_020, git_hash=8907e6671bfbfc92303b5f79c4b5e6ce47cdef57, seed=42
GGGGGGGGGGGGGG
T=0.1, sample=1, score=0.8211, global_score=1.6212, seq_recovery=0.1429
ESGIIDIETGERIP
T=0.1, sample=2, score=0.7738, global_score=1.6172, seq_recovery=0.1429
ESGIIDIETGEKIP

AlphaFold2での実行結果の確認

では、ここからAlphaFold2でのMPNNの出力物の確認を行っていきます。AlphaFold2を自身のPCで実行するのは要求されるPCスペックが非常に高いことから現実的ではないのですが、今回はブラウザ環境でAlphaFold2が実行できるGoogleColab環境を利用することで実行していきます。また、通常のAlphaFoldは環状ペプチドの構造予測には対応していないので、GoogleColabを使って環状ペプチドの構造予測にAlphaFoldを対応させてあるこちらで公開されているツールを利用していきます。

先ずはこちらのリンクへ移動してください。ここから先ほどのツールによるGoogleColabでのAlphaFold2による環状ペプチドの構造予測を簡単に行うことが出来ます。リンク先のブラウザ画面からは環状ペプチドの構造予測の設定をいじることが出来ますが、今回変更が必要なのは3か所のみです。

先ずは、①**query_sequence:** のカラム内に今回ProteinMPNNで作成した配列を入力してください。さらに②**jobname:** カラム内はアウトプットファイルの名前を指定できるので、お好きな名前を入力してください。

私は**query_sequence:** にはMPNNが予測した１番目の配列”ESGIIDIETGERIP”を、jobname: には”Sample1”と入力しておきました。

最後に、③ページを下にスクロールしたところにある**Save settings**のチェックボックスにチェックをつけて、実行結果を保存できるようにしておきましょう。（上記の設定箇所はスクリーンショット内に赤枠でマークしてありますので、見つかりにくい場合の参考にしてください。）

上記の設定が終わったらページ左上の”全てのセルを実行”(スクリーンショット1枚目の赤枠)をクリックすると、AlphaFold2が実行できます。この時に以下の警告が表示されると思いますが、気にせず実行してしまって構いません。

すると、しばらくするとページをスクロールした先に、このように予測された立体構造が表示されます。

今回のアミノ酸配列がplDDTが90–100という高い精度で、狙い通りの環状ペプチド構造を形造ることが確認できました。

上記は切れているように見えますが、Pymolで読み込み、Sticksで表示すると、きちんとした環状ペプチドになっています！

コードの解説

上に書いたソースコードの解説をしていきます。

# GitHub から ProteinMPNN をクローン
git clone https://github.com/dauparas/ProteinMPNN.git
cd ProteinMPNN
# micromambaで環境を用意
micromamba create -n mlfold python=3.10 -y
# 環境の有効化
micromamba activate mlfold
# 必要なパッケージをインストール
micromamba install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch
# 学習済みのモデルをダウンロード
wget https://github.com/dauparas/ProteinMPNN/blob/main/vanilla_model_weights/v_48_002.pt
wget https://github.com/dauparas/ProteinMPNN/blob/main/vanilla_model_weights/v_48_010.pt
wget https://github.com/dauparas/ProteinMPNN/blob/main/vanilla_model_weights/v_48_020.pt

• git clone は、GitHub にあるプロジェクト（この場合は ProteinMPNN）を自分のパソコンにコピーするコマンドです。

• https://github.com/dauoaras/ProteinMPNN.git はコピー元の URL です。

  実行すると、カレントディレクトリ（今いるフォルダ）に ProteinMPNN という名前のフォルダが作られ、その中にプロジェクトのファイルが全部入ります。

  イメージ: 「インターネット上の本棚(GitHub)から、本を丸ごと借りて自分の机に置く」ような感じです。

• cd ProteinMPNN で先ほどクローンしたディレクトリへ移動します。

• micromamba create -n mlfold python=3.10 -y では、micromambaを使って、mfoldという名前の環境を作成し、pythonをインストールしています。環境の名前はなんでもOKです。

• micromamba activate mlfold で先ほど作った環境を有効化します。これで先ほどインストールしたpythonが入っている環境が立ち上がりました。

• micromamba install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch で、立ち上がった環境内にさらに必要なパッケージをインストールしていきます。

• wget はオンライン上のファイルをダウンロードするコマンドです。ここではGitHub上にある、ProteinMPNNで利用する学習済みモデルの重みを3種類ダウンロードしています。これでProtein MPNNが利用可能になりました。

# ProteinMPNNを実行
python ProteinMPNN/protein_mpnn_run.py \ --pdb_path documents/RFdiffusion/samples/design_0.pdb \ --pdb_path_chains "B" \ --out_folder /documents/RFdiffusion/samples/MPNNoutput \ --model_name v_48_020 \ --num_seq_per_target 2 \ --sampling_temp 0.1 \ --seed 42 \ --batch_size 1

• このコードで実際にProteinMPNNを実行しています。各オプションの意味は以下の通りです。

-pdb_path：デザインの元になるタンパク質構造（PDBファイル）の場所を指定。

-pdb_path_chains "B" ：PDBの中のどのチェーンをデザイン対象にするか指定。

今回のファイルには、環状ペプチドと結合ターゲットとなるタンパク質の2種類の鎖が含まれているため、環状ペプチドのチェーンの方（私のファイルの場合はB）を指定した。

-out_folder ：MPNN が生成した配列をどこに保存するかを指定。

-model_name ：使いたい学習済みモデルの重みを指定。

• ProteinMPNN には複数モデルがあり、どのモデルを利用するかを指定できる。

今回はvanilla_model_weights/v_48_020.ptで一般的な ProteinMPNN の基本モデルを利用。その他には、水溶性の大型タンパク質のためのモデルや、より簡易的な予測をするための軽量モデルなどが選択できる。

-num_seq_per_target 2 ：1つの構造に対して何本のアミノ酸配列を生成するかを指定。今回は、簡易に2本の配列を予測するように指定。多すぎても、計算に時間がかかる為、10本ほど予測させておくと良いかもしれない。

-sampling_temp 0.1 ：生成モデルの温度パラメーターを指定する。温度パラメーターとは、“ランダム性（探索の広さ）” を決めるパラメータ。

• 0.1：保守的（モデルがアミノ酸配列を1アミノ酸ずつ予測する際に、より確率の高いもアミノ酸候補の中から選択する）
• 1.0：ランダム性高い（比較的確率が低いアミノ酸も選択肢に入れて、アミノ酸候補を選択する。予想されるアミノ酸配列に多様な配列が生まれる。）

最適な数値は、実際に試しながら探っていく必要があるが、今回の用途で使い場合は0.1~0.3ぐらいの保守的な予測が適切な可能性が高い。

-seed 42 ：実行ごとのランダム性を固定するためのシード設定。今回のような生成モデルは、たとえ同様のpdbファイルを対象にした場合でも実行するごとに予測結果が変動する。シード設定として適当な値を設定しておくことで、再度プログラムを実行したときに前回と同様のシード値を設定することで、前回と同じ結果を予測することができる。予測ファイルを誤って消去してしまった際などや、結果の再現性を確保したい際のために設定しておくと便利。

-batch_size 1 ：一度にいくつの構造を処理するかを指定する。余程の高性能マシンでない限り、 1 のままでOK。

最後に

ProteinMPNNの解説は以上になります。相変わらずGPUは必要ですが、ツール自体は意外と簡単に利用できたのではないでしょうか。AlphaFoldも加えて、構造もきちんと確認できるととても面白いですね！

参考文献

Protein MPNN

https://github.com/dauparas/ProteinMPNN?tab=MIT-1-ov-file MIT License

AlphaFold2

https://github.com/google-deepmind/alphafold?tab=Apache-2.0-1-ov-file Apache License

環状ペプチド用のAlphaFold2

くろたんくLab様より開発

くろたんくLab

https://colab.research.google.com/github/blacktanktoplab/ColabFold/blob/cyclic/AlphaFold2.ipynb

【この記事のまとめ】

創薬研究者やバイオインフォマティクスに関心がある方に向けて、拡散モデル（Diffusion Model）を活用して高精度な環状ペプチドを新規設計（De novo生成）できるツール「RFPeptide」の使い方を解説します。

• 拡散モデルによる高度な構造最適化：ノイズ除去のプロセスを通じて、ターゲットタンパク質に最適に結合するペプチド骨格を、従来の物理シミュレーションより高速かつ高精度に生成します。
• 環状ペプチドに特化した設計：創薬において安定性が高く重要な「環状構造」の生成にフォーカスし、具体的なパラメータ設定や実行手順を詳しく紹介します。
• WSL2/GPU環境での実践ガイド：環境構築から実際のPDBファイルを用いた実行、結果の確認まで、ハンズオン形式で迷わず進められるワークフローを網羅しています。

この記事を読むことで、最先端の生成AI技術を創薬ワークフローに取り入れ、PC一台で独自の高品質なペプチドライブラリを創出するスキルが身につきます。

RFPeptideとは？

RFPeptideとは、ディープラーニングを用いてペプチドの立体構造や結合を設計・予測するためのツールです。ターゲットタンパクの構造を渡すと、その構造に対して結合する最適化されたペプチド骨格を生成してくれます。

以下でもう少し詳しく説明します。

RFPeptideは、拡散モデル（diffusion model）に基づく生成技術を利用して開発された手法で、ペプチドの構造最適化(標的タンパク質に対する結合ペプチドの構造設計)を目的としています。

従来の物理シミュレーションやランダム探索に比べ、拡散モデルを活用することで高速かつ高精度に候補を生成できる点が特徴であり、このRFPeptideはペプチドに特化（短いアミノ酸配列の立体構造予測・最適化）しています。

仕組みについて（より詳しく知りたい方向け）

先ほどの説明では物足りなかった方向けにこのツールの内部をより詳しくご説明します。

RFPeptideは、拡散モデル（diffusion model）に基づく生成技術を利用する手法と言いましたが、拡散モデルという言葉は初めて聞いた方も多いのではないでしょうか。

拡散モデルとは、確率的なノイズ除去の過程を利用してデータを生成する深層生成モデルです。

もう少し詳しく説明すると、拡散モデルは、以下の2stepに分けられます。

1. 前向き過程（noising process）
   • 元のデータ（例：ランダムなペプチド構造）に少しずつガウスノイズを加えていき、最終的に「純粋なノイズ」に変換するステップ。
2. 逆過程（denoising process）
   • 学習済みのニューラルネットワーク（NN）を用いて、ノイズから徐々に元のデータを復元していくステップ。（この過程で多様な復元像が生成されうる。）

RFPeptideではこの「ノイズを段階的に入れて壊してから、逆に段階的に直す」プロセスを利用し、ノイズから無数の新しいペプチド構造（ペプチドライブラリ）が生み出され、その中からより最適な立体構造に収束する形でノイズが除去されていきます。

拡散モデルを利用することのはメリットは、

①破壊と修復を段階的に行う点と、②ライブラリ生成に学習済みNNを用いる点です。

まず、1stepではなく段階的に破壊と修復を行うことで、より安定的に多様なペプチドライブラリを探索できます。さらに、逆過程において既存のペプチド構造を学習したNNモデルを利用することで、物理的に妥当で自然なペプチドライブラリを探索でき、またNNでの条件付き生成という形でユーザーが指定した条件（ターゲットタンパクに結合しやすい様にや、特定構造を含む様になど）を自然とライブラリ探索に活かせるために、より高品質なライブラリを高速で探索できるというメリットがあります（ランダム変異のような形でペプチドライブラリを生成する場合と比較して）。

RFPeptideはこれらのメリットから、最近注目されるペプチド構造探索法となっています。

RFPeptideの実装方法

では早速、注目のペプチド骨格構造探索法であるRFPeptideを動かしていきます。

こちらを参考に環境構築から行っていきます。今回もWindowsのWSLを利用していきます。WSLの利用方法はこちらの記事に記載してあるので、そちらを参考にしてください。

今回のRFPeptideはGPUを利用するツールのため、まずはこちらのサイトでお使いのPCに搭載されているGPUに 対応したドライバ（Windows11用・Linux用ではありません）をDLして、Windows 上でインストーラを実行し、再起動して有効化してください。また、どのドライバーが良いのか分からない場合は、こちらのNDIVIA appをインストールすると最適なドライバーをインストールしてくれるようです（既にインストール済みの場合は不要です。）

次に、WSLのターミナルで以下のコードを実行して、環境構築をしていきます。

# micromamba をインストールするディレクトリを作成
mkdir -p ~/micromamba_env
# micromamba をインストール（-b: バッチモード, -p: インストール先指定）
curl -Ls https://micro.mamba.pm/install.sh | bash -s -- -b -p ~/micromamba_env
# bash 設定ファイルを読み込み直す（PATH 設定などを反映）
source ~/.bashrc
# GitHub から RFPeptide をクローン
git clone https://github.com/RosettaCommons/RFdiffusion.git
# 学習済みモデルの重みをダウンロード
cd RFdiffusion/scripts
bash download_models.sh ../models
# フォルダを移動
cd ~/RFdiffusion
# micromambaで環境を用意
micromamba env create -f env/SE3nv.yml --channel-priority flexible
# 環境の有効化
micromamba activate SE3nv
# GPU利用に必要なパッケージをインストール
micromamba install -c nvidia -c pytorch -c conda-forge pytorch torchvision torchaudio pytorch-cuda=12.1 -y
# SE3Transformer のインストール
cd env/SE3Transformer
pip install --no-cache-dir -r requirements.txt
python setup.py install
cd ../..
# RFPeptide のインストール
pip install -e .

プログラムを実行する

まずは、作業したいフォルダを決めます（私はWindowsのdocuments下に作ったRFPeptideというフォルダで作業します）。

次に、RFPeptideに渡すターゲットタンパクの立体構造のPDBファイルを用意します。利用する立体構造はご興味に合わせてどのようなものでも良いですが、私はこちらの論文内で利用されていたタンパクファイル（7zkr_GABARAP.pdb）をダウンロードして、ターゲットタンパクとしました。 （既に目的のタンパク構造ファイルがある方も同様に、ここで立体構造ファイルをコピペで作業フォルダ内に置いておきましょう）。

7zkr_GABARAP.pdbのファイルはこちらからダウンロードできます。ダウンロードしたファイル(rfd_macro.tar.gz)のexamples>input_pdbs内にあるので、こちらを作業フォルダ内に移動しておきましょう。

次は、以下のコマンドで作業したいフォルダに移動します

# 作業フォルダへ移動
cd /mnt/c/users/(あなたのWondowsのユーザー名）/documents/RFPeptide

/documents/RFPeptideは、ご自身が作業したいフォルダの名前に合わせて変更して下さい。あとは以下のコマンドを実行するだけです。

/home/(あなたのWSLのユーザー名)/RFdiffusion/scripts/run_inference.py\ inference.input_pdb=7zkr_GABARAP.pdb\ 'contigmap.contigs=[12-18 A3-117/0]'\ inference.num_designs=5\ inference.cyclic=true\ diffuser.T=25

実行結果

作業していたフォルダにoutputとsampleというフォルダが出来ているはずです。

outputには実行時のログが入っており、生成された環状ペプチドはsamplesに保存されています。

samplesフォルダ内はこのようになっていますdesign_0から4までの5種類の立体構造ファイル(pdb)と生成条件に関するファイル(trb)、生成過程の様子に関するファイルが入っているフォルダ(traj)が作成されています。

この様にオプションで指定した通りに、5つの環状ペプチド構造を作成することに成功しました！

早速、Mol* Viewerを利用してdesign_0と標的タンパク質を可視化してみましょう！

Mol*Viewerを開き、以下からdesign_0.pdbを開いてみてください。

茶色の受容体タンパクと緑の環状ぺプチドが、確かに結合されていることがわかりますね！

これら立体構造ファイルをこちらで紹介したAutoDockなどの結合評価ツールで利用すれば、そのデザインの性能を評価出来るでしょう。

また、今回作成した環状ペプチドの配列自体は全てグリシンから構成されていることもわかるかと思います。これは、あくまでRFeptideは立体構造のみを生成するツールであり、配列までは決定できないためです。配列の決定自体は別のツール(ProteinMPNN)を利用してやる必要があります(配列の決定に関しては、次回の記事で解説していきます）。

コードの解説

上に書いたソースコードの解説をしていきます。

# micromamba をインストールするディレクトリを作成
mkdir -p ~/micromamba_env
# micromamba をインストール（-b: バッチモード, -p: インストール先指定）
curl -Ls https://micro.mamba.pm/install.sh | bash -s -- -b -p ~/micromamba_env
# bash 設定ファイルを読み込み直す（PATH 設定などを反映）
source ~/.bashrc

今回もmicromambaを使った環境構築をしました。こちらはそのmicromambaをインストールするコマンドです。すでにインストールしている場合は、不要です。

# GitHub から RFPeptide をクローン
git clone https://github.com/RosettaCommons/RFdiffusion.git
# 学習済みモデルの重みをダウンロード
cd RFdiffusion/scripts
bash download_models.sh ../models

• git clone は、GitHub にあるプロジェクト（この場合は RFdiffusion(RFpeptideのもとになるツールです)）を自分のパソコンにコピーするコマンドです。

• https://github.com/RosettaCommons/RFdiffusion.git はコピー元の URL です。

  実行すると、カレントディレクトリ（今いるフォルダ）に RFdiffusion という名前のフォルダが作られ、その中にプロジェクトのファイルが全部入ります。

  イメージ: 「インターネット上の本棚(GitHub)から、本を丸ごと借りて自分の机に置く」ような感じです。

• cd は「Change Directory（ディレクトリを移動）」の略です。

• RFdiffusion/scripts は、先ほどクローンしたフォルダの中の scripts というサブフォルダに移動します。

• bash は Linux/Mac の「シェル」というコマンド実行環境でスクリプトを動かす命令です。

• download_models.sh は、学習済みのモデルの重み（RFPeptide のニューラルネットが計算に使うデータ）をダウンロードするためのスクリプトです。

• ../models は「1つ上のフォルダに models という名前で保存してね」という意味です。

  .. は「1つ上の階層」を指します。なので RFdiffusion/scripts の上の階層（つまり RFdiffusion フォルダ）に models フォルダが作られます。

# フォルダを移動
cd ~/RFdiffusion
# micromambaで環境を用意
micromamba env create -f env/SE3nv.yml --channel-priority flexible
# 環境の有効化
micromamba activate SE3nv
# GPU利用に必要なパッケージをインストール
micromamba install -c nvidia -c pytorch -c conda-forge pytorch torchvision torchaudio pytorch-cuda=12.1 -y
# SE3Transformer のインストール
cd env/SE3Transformer
pip install --no-cache-dir -r requirements.txt
python setup.py install
cd ../..
# RFPeptide のインストール
pip install -e .

ここでは、RFPeptide用の環境を作成し、その中に必要なパッケージやライブラリをインストールしています。

• micromanmba env create は新しい仮想環境を作るコマンドです。

• f env/SE3nv.yml は、先ほどGitHubからコピーしたプロジェクトの中に用意されていた「env/SE3nv.yml という設定ファイル」を使って環境を作るという意味です。

  この yml ファイルには、必要な Python のバージョンやライブラリが書かれています。

• -channel-priority flexible は「依存関係を柔軟に解決してくれる」という意味です。

  イメージとしては「RFPeptide 専用の別の作業部屋（環境）を作って、その中に必要な道具（ライブラリ）を揃える」感じです。

• micromamba install -c nvidia -c pytorch -c conda-forge pytorch torchvision torchaudio pytorch-cuda=12.1 -yこちらは、GPU を使って計算するために必要なパッケージをインストールします。

  これらのパッケージは、通常は先ほどのenv/SE3nv.ymlからの環境構築でインストールされているはずですが、私の場合なぜか上手くいっていなかったので、こちらでやり直しています。皆様も念のためやり直しておくとよいと思います。

• -c は「このチャンネルからライブラリを取ってきてね」という意味です。

  nvidia → GPU 関連

  pytorch → PyTorch（ディープラーニング用ライブラリ）

  conda-forge → その他便利ライブラリ

• pytorch torchvision torchaudio pytorch-cuda=12.1 はインストールするライブラリです。

  pytorch-cuda=12.1 は CUDA 12.1 という GPU 計算用のバージョンを指定しています。

• -y は「途中で確認しなくても自動で Yes にする」という意味です。

• cd env/SE3Transformer

  これは RFPeptide が使う特別なモジュールです。

  SE3Transformer というサブフォルダに移動します。

• pip install --no-cache-dir -r requirements.txt

  requirements.txt に書かれた必要な Python ライブラリをインストールします。

  -no-cache-dir は「古いキャッシュを使わずに新しくインストールする」という意味です。

• python setup.py install

  SE3Transformer モジュールを Python 環境にインストールします。

• cd ../..

  元の RFdiffusion フォルダに戻ります。

• pip install -e .

  -e は editable（編集可能）モード の意味です。

  このモードでインストールすると、フォルダ内のファイルを直接編集しても、そのまま環境に反映されます。

  . は「今いるフォルダ（RFdiffusion）をインストール対象にする」という意味です。

  つまり、RFPeptide 自体を installして、利用できるように読み込んでいます。

# 作業ファルダへ移動
cd /mnt/c/users/(あなたのWondowsのユーザー名）/documents/RFPeptide

ここのコードでは、実際に作業したいWindows上のフォルダ（私の場合はdocuments/RFPeptide）に移動しています。

/home/(あなたのWSLのユーザー名)/RFdiffusion/scripts/run_inference.py\ inference.input_pdb=7zkr_GABARAP.pdb\ 'contigmap.contigs=[12-18 A3-117/0]'\ inference.num_designs=5\ inference.cyclic=true\ diffuser.T=25

先ほどインストールしたRFPeptideのメインスクリプトであるrun_inference.pyを呼び出して、構造生成を行っています。

• inference.input_pdb=7zkr_GABARAP.pdb

  設計対象の タンパク質構造ファイル を指定しています。

  7zkr_GABARAP.pdbは先ほどダウンロードした PDB ファイルです。ここで指定したタンパク質構造に対してペプチド結合設計が行われます。

• 'contigmap.contigs=[12-18 A3-117/0]’ターゲットタンパクのうちのどのアミノ酸領域に、何塩基のペプチドを結合させたいかを指定しています。

  意味: [結合させたい部分のペプチドの塩基数の範囲/ターゲットタンパク上の結合させたい場所/結合させない部分のペプチドの塩基数の範囲]

  [12-18 A3-117/0] は:ターゲットタンパク質の A鎖の3〜117番目残基に対して長さ12〜18のペプチドを設計するという意味です。

• inference.num_designs=5

  作成するペプチドデザインの数を指定しています。この場合 5種類のペプチドデザイン が出力されます。

• inference.cyclic=true設計するペプチドを 環状（ループ状）にするかどうか を指定しています。

  true → 環状ペプチドを設計、false → 直鎖ペプチドを設計

• diffuser.T=25ペプチド設計の際に使われる 拡散モデルのステップ数 を指定しています。数字が大きいほど設計精度が上がる場合がありますが、計算時間も長くなります。

  環状ペプチドの場合は25スッテプが良いとの論文もありますが、調整の余地があると思われます。

その他には設計に関わる以下のようなオプションが存在し、細かく指定することでより詳細な構造探索が行えます。

最後に

今回は、最新の強力なペプチド構造探索法である RFPeptide を利用しました。GPU前提の計算量を必要とするツールですが、使用するとより大規模かつ多様なペプチドライブラリから高速かつ高精度な探索が可能です。

実践的には、よくあるのがタンパク質ータンパク質相互作用面に結合するペプチドをデザインし、その相互作用を阻害する利用法です。その際はターゲット部位を見つけることがミソになりそうです。

今後より一層使われていくであろうツールの一つだと思いますので、ぜひ一度お試しください。

参考文献

RF Peptide

https://github.com/RosettaCommons/RFdiffusion?tab=readme-ov-file BSD License

【この記事のまとめ】

創薬研究やバイオインフォマティクスに従事する方に向けて、HELM形式を活用してin silicoスクリーニング用の「環状ペプチドライブラリ」を効率的に構築・可視化する方法を解説します。

• HELM形式による複雑な構造記述：非天然アミノ酸や環状構造を機械可読な形式で表現する標準フォーマット「HELM」の基礎と、Pythonでの変換手法を習得できます。
• 変異体生成の自動化：アラニンスキャニングやホモログスキャニングを実装し、リード配列から多様なライブラリを自動生成するワークフローを紹介します。
• 3D可視化からドッキング準備まで：RDKitやpy3Dmolを用いた3D構造の生成・確認、さらにAutoDock等のシミュレーションに不可欠なPDBQT形式への保存手順までを網羅しています。

この記事を読むことで、手間のかかる環状ペプチドのライブラリ作成を自動化し、より高度なin silico創薬シミュレーションへスムーズに移行できるようになります。

ライブラリとは？

ペプチドライブラリは、さまざまな配列を持つペプチドの集合で、in silico創薬においては特定の標的タンパク質に対する結合能を評価するために使用されます。スクリーニングでは、各ペプチドの3D構造を予測し、ドッキングや分子動力学シミュレーションを用いて、結合エネルギーや安定性を比較します。多様な配列を効率的に評価するため、バッチ処理・自動化が重要です。

HELM形式とは？

HELM（Hierarchical Editing Language for Macromolecules）は、ペプチド、核酸、糖鎖などの複雑な生体高分子を機械可読な形式で表現するための標準フォーマットです。特にin silico創薬やバイオライブラリのデータ管理で重要な役割を担います。

特徴：

• モノマー単位で階層的に記述（アミノ酸やヌクレオチドが基本単位）
• 非天然アミノ酸・化学修飾・分岐構造も記述可能
• 構造の一貫性や相互運用性を保ちながら、データベースやツール間で利用可能

ペプチドの基本構文

PEPTIDE1{A.C.G.Y.R}$$$$

• PEPTIDE1: 分子の種類（ここではペプチド）
• {}: アミノ酸配列（モノマーコード）
• $$$$: 接続や末端の情報がない場合の終端記号

非天然アミノ酸の表現

HELMでは、非天然アミノ酸もカスタムモノマーとして表現できます。モノマー辞書に登録すれば自由な名前で記述可能です。

PEPTIDE1{A.Dap.Cit.Nle}$$$$

• Dap: 2,3-ジアミノプロピオン酸
• Cit: シトルリン
• Nle: ノルロイシン

これらはすべて非天然（standard amino acid ではない）ですが、辞書に定義しておけば扱えます。こちらを使った方法についてはまた別記事で書きます。今回は天然アミノ酸に絞ります。

環状ペプチドの記述

環状構造は末端をリンクで接続することで表現します。たとえば、1番目と5番目をペプチド結合で環化する場合：

PEPTIDE1{A.C.G.D.E}$$$V2.0$$$PEPTIDE1,1:R3-5:R2$$

• PEPTIDE1,1:R3-5:R2: モノマー1のR3とモノマー5のR2を結合（N-C末端環化など）

この記述により、主鎖環状ペプチド（例：シクロスポリンなど）も構造的に正確に表現できます。

アラニンスキャニング、ホモログスキャニングとは？

アラニンスキャニング（Alanine Scanning）

アラニンスキャニングは、タンパク質やペプチドの特定残基をアラニンに一つずつ置換し、その機能や結合能への影響を評価する手法です。アラニンは小さく中性なため、置換によって立体構造の変化を最小限に抑えつつ、その残基の役割を明らかにできます。in silicoでは、各変異体の結合エネルギー（ΔΔG）を計算することで、重要な結合残基（ホットスポット）を同定できます。M

ホモログスキャニング（Homologue Scanning）

ホモログスキャニングは、特定の残基をアミノ酸の中で物理化学的に近い他の残基に置換し、機能や安定性への影響を調べる方法です。たとえばリジンをアルギニンやヒスチジンに、フェニルアラニンをチロシンに変えるなど、類似性を保った変異を試みます。アラニンスキャニングよりもより自然に近い変異探索ができるため、機能改変や最適化設計に適しています。

どちらもin silicoでのスクリーニングにより、実験前の候補絞り込みやタンパク質改変戦略の立案に活用されます。

環境構築

今回のコードはGoogle Colabで実装しました！

こちらから実行してみてください。環境構築は不要です。

上のランタイム→すべてのセルを実行で実行できます

実装コード

全コードはこちら

!pip install rdkit py3Dmol
!pip install meeko
!pip install gemmi
import rdkit
from rdkit import Chem
from rdkit.Chem import AllChem
import py3Dmol
from typing import List
import re
# 必要なライブラリをインポートしています
# rdkit: 化学構造の操作や3D生成を行うためのライブラリ
# py3Dmol: 分子の3D構造をブラウザ上で可視化するためのライブラリ
# re: 正規表現を使って文字列処理を行うための標準ライブラリ
# --- Helper Functions (補助関数) ---
def convert_FASTA_to_HELM(seq: str, cyclic: bool = True) -> List[str]: """ FASTA形式の配列（例: 'ACDEF'）をHELM形式（階層的編集言語）に変換する関数です。 cyclic=True の場合、先頭と末尾を結合して環状ペプチドにします（バックボーン環化）。 """ # 1. 配列の文字をドット区切りにします（例: H.M.T...） polymer = ".".join(list(seq)) # PEPTIDE1という名前のポリマーとして定義します helm = f"PEPTIDE1{{{polymer}}}" if cyclic: # 2. 環状化の処理 # N末端（R1）とC末端（R2）を結合させる記述を追加します n = len(seq) # 接続の構文: SourcePoly,TargetPoly,SourceAtom:Att-TargetAtom:Att connection = f"PEPTIDE1,PEPTIDE1,1:R1-{n}:R2" helm += f"${connection}$$$$" else: # 環状化しない場合は終了記号のみ追加 helm += "$$$$" return [helm]
def parse_helm_to_seq(helm: str) -> str: """HELM文字列からアミノ酸配列のみを抽出する関数です。""" # 正規表現を使って PEPTIDE1{...} の中身を取り出します match = re.search(r'PEPTIDE1\{(.*?)\}', helm) if match: # ドットを取り除いて文字列として返します（例: H.M.T -> HMT） return match.group(1).replace('.', '') return ""
def alanine_scanning(helm_str: str) -> List[str]: """ アラニンスキャニングを行う関数です。 ペプチドの各アミノ酸を1つずつアラニン（A）に置換した変異体を作成します。 特定のアミノ酸が活性に重要かどうかを調べるためによく使われます。 """ seq = parse_helm_to_seq(helm_str) variants = [] for i in range(len(seq)): # 元々がアラニンの場合はスキップ if seq[i] == 'A': continue # i番目のアミノ酸を'A'に置き換えた新しい配列を作成 new_seq = seq[:i] + 'A' + seq[i+1:] # HELM形式に変換してリストに追加 variants.append(convert_FASTA_to_HELM(new_seq)[0]) return variants
def homolog_scanning(helm_str: str) -> List[str]: """ ホモログスキャニングを行う関数です。 各アミノ酸を、性質が似ている別のアミノ酸（ホモログ）に置換した変異体を作成します。 """ seq = parse_helm_to_seq(helm_str) # 置換ルール（辞書）: キーのアミノ酸を、値のリストにあるアミノ酸に置換します homologs = { 'H': ['K', 'R'], 'K': ['R', 'H'], 'R': ['K', 'H'], # 塩基性アミノ酸間での置換 'D': ['E'], 'E': ['D'], # 酸性アミノ酸間 'N': ['Q'], 'Q': ['N'], # アミド基を持つもの同士 'S': ['T'], 'T': ['S'], # 水酸基を持つもの同士 'V': ['I', 'L'], 'L': ['I', 'V'], 'I': ['L', 'V'], # 疎水性アミノ酸間 'F': ['Y'], 'Y': ['F'], # 芳香族アミノ酸間 'A': ['G'], 'G': ['A'], # 小さいアミノ酸間 'M': ['L'] } variants = [] for i in range(len(seq)): aa = seq[i] # そのアミノ酸に対する置換ルールが存在する場合 if aa in homologs: for sub in homologs[aa]: # 置換して新しい配列を作成 new_seq = seq[:i] + sub + seq[i+1:] variants.append(convert_FASTA_to_HELM(new_seq)[0]) return variants
def helm_to_3d_mol(helm_str: str): """ HELM文字列をRDKitの分子オブジェクト（3D構造込み）に変換する関数です。 RDKitを使って直鎖ペプチドを作成し、化学的に結合させて環状にします。 """ # 1. 配列情報を取得 seq = parse_helm_to_seq(helm_str) if not seq: return None # 2. 配列から直鎖状のペプチド分子を作成 mol = Chem.MolFromSequence(seq) if mol is None: return None # 3. 環状化（Head-to-Tail cyclization）の処理 # 分子を編集可能な状態（RWMol）にします rwmol = Chem.RWMol(mol) # N末端（アミノ基）とC末端（カルボキシ基）の原子を探します # SMARTS記法というパターンマッチングを使っています n_matches = rwmol.GetSubstructMatches(Chem.MolFromSmarts("[NH2,NH3]")) # N末端 c_matches = rwmol.GetSubstructMatches(Chem.MolFromSmarts("C(=O)[OH]")) # C末端 if not n_matches or not c_matches: print(f"Could not identify termini for {seq}") return None # N末端の窒素原子のインデックス n_atom_idx = n_matches[0][0] # C末端の炭素原子と、脱離するOH基の酸素原子を特定します c_term_indices = c_matches[-1] # 最後に見つかったものをC末端と仮定 c_atom_idx = -1 leaving_o_idx = -1 for idx in c_term_indices: atom = rwmol.GetAtomWithIdx(idx) if atom.GetSymbol() == 'C': # 炭素に結合している酸素（OH）を探す for bond in atom.GetBonds(): neighbor = bond.GetOtherAtom(atom) if neighbor.GetSymbol() == 'O' and bond.GetBondType() == Chem.BondType.SINGLE: c_atom_idx = idx leaving_o_idx = neighbor.GetIdx() break if c_atom_idx != -1: break # ペプチド結合の形成（脱水縮合のシミュレーション） if c_atom_idx != -1 and leaving_o_idx != -1: # OH基を削除 rwmol.RemoveAtom(leaving_o_idx) # N末端のNとC末端のCを単結合でつなぐ rwmol.AddBond(n_atom_idx, c_atom_idx, Chem.BondType.SINGLE) # 編集を確定して通常の分子オブジェクトに戻す mol_cyclic = rwmol.GetMol() try: # 化学的な整合性をチェック Chem.SanitizeMol(mol_cyclic) # 水素原子を付加（3D構造生成に必要） mol_h = Chem.AddHs(mol_cyclic) # 4. 3Dコンフォマー（立体構造）の生成 # ETKDGというアルゴリズムを使って3D座標を計算します AllChem.EmbedMolecule(mol_h, AllChem.ETKDG()) return mol_h except Exception as e: print(f"Error generating 3D for {seq}: {e}") return None return None
# ----------------------------------------------------
# STEP 1: リードペプチドの定義
# ----------------------------------------------------
# ここでは探索の起点となるペプチド配列（リードペプチド）を定義します。
# FASTA形式（'HMTEVVRRC'）からツールで扱いやすいHELM形式に変換しています。
lead_peptide = convert_FASTA_to_HELM('HMTEVVRRC')[0]
print(f"リードペプチド（HELM形式）: {lead_peptide}")
# ----------------------------------------------------
# STEP 2: シードライブラリの生成
# ----------------------------------------------------
# リードペプチドを元に、少しだけ配列を変えたペプチド群（ライブラリ）を作ります。
seed_library = [lead_peptide]
# アラニンスキャニング: 各アミノ酸をアラニンに変えたものを作成
for seq in alanine_scanning(lead_peptide): seed_library.append(seq)
# ホモログスキャニング: 各アミノ酸を似た性質のアミノ酸に変えたものを作成
for seq in homolog_scanning(lead_peptide): seed_library.append(seq) # デモ用に数を制限しています（最大10個追加でストップ） if len(seed_library) >= 10: print('Reach max. number of peptides allowed.') break
print(f"Total peptides generated: {len(seed_library)}")
print("First 5 peptides:")
for p in seed_library[:5]: print(p)
# ----------------------------------------------------
# STEP 3: 3D Visualization (3D可視化)
# ----------------------------------------------------
print("Generating 3D structures for the first 3 peptides...")
# 生成したライブラリの最初の3つだけを可視化してみます
for i, helm in enumerate(seed_library[:3]): print(f"\nPeptide {i+1}: {helm}") # 定義した関数を使ってHELM文字列から3D構造データを生成 mol = helm_to_3d_mol(helm) if mol: # py3Dmolを使ってブラウザ上で分子を表示 view = py3Dmol.view(width=400, height=300) # 分子データを渡す view.addModel(Chem.MolToMolBlock(mol), 'mol') # 表示スタイルをスティック（棒）モデルに設定 view.setStyle({'stick': {}}) # 分子が画面に収まるようにズーム view.zoomTo() view.show() else: print("Failed to create 3D structure.")
# ----------------------------------------------------
# STEP 4: PDBQTファイルの保存
# ----------------------------------------------------
from google.colab import drive
import os
# Google Driveをマウント（接続）します。
# これにより、作成したデータを自分のDriveに保存できるようになります。
drive.mount('/content/drive')
# 出力先のディレクトリ（フォルダ）パスを定義します
output_dir = '/content/drive/MyDrive/Cyclic_peptide_screening'
# ディレクトリが存在しない場合は作成します（exist_ok=Trueで既存の場合のエラーを回避）
os.makedirs(output_dir, exist_ok=True)
print(f"Output directory created/verified at: {output_dir}")
from meeko import MoleculePreparation
from rdkit import Chem
import requests
def save_mol_to_pdbqt(mol, name, output_dir): """ RDKitの分子オブジェクトをPDBQT形式で保存する関数です。 PDBQTはドッキングシミュレーション（AutoDockなど）で使われる形式です。 """ try: # Meekoを使って分子の前処理（プレパレーション）を行います # これにより、結合の回転などを設定したPDBQTデータが作られます preparator = MoleculePreparation() preparator.prepare(mol) pdbqt_string = preparator.write_pdbqt_string() # ファイルとして保存 filename = os.path.join(output_dir, f"{name}.pdbqt") with open(filename, 'w') as f: f.write(pdbqt_string) return True except Exception as e: print(f"Error converting {name}: {e}") return False
print("Starting PDBQT conversion for peptide library...")
success_count = 0
# ライブラリ内の全ペプチドについて処理を実行します
for i, helm in enumerate(seed_library): # ファイル名用に配列を取得 seq_name = parse_helm_to_seq(helm) base_name = seq_name if seq_name else f"peptide_{i+1:03d}" name = f"Cyclic_{base_name}" # 3D構造を生成 mol = helm_to_3d_mol(helm) if mol: # 分子に名前プロパティを追加 mol.SetProp("_Name", name) # PDBQT形式で保存 if save_mol_to_pdbqt(mol, name, output_dir): success_count += 1 else: print(f"Failed to save {name}") else: print(f"Failed to generate 3D for {name} ({helm})")
print(f"\nSuccessfully saved {success_count}/{len(seed_library)} peptides to {output_dir}") 

コード詳細解説

!pip install rdkit py3Dmol
!pip install meeko
!pip install gemmi
import rdkit
from rdkit import Chem
from rdkit.Chem import AllChem
import py3Dmol
from typing import List
import re

まずは、以下のように必要なライブラリをインストールします。

!pip install rdkit py3Dmol

• rdkit：分子構造の読み込み、編集、描画、化学構造に基づく演算（化学フラグメント検索、構造変換など）を行う強力なライブラリ。
• py3Dmol：3D分子構造をWebベースで可視化するためのインターフェース。3Dmol.js というJavaScriptライブラリをPythonから操作できるようにしたもの。

rdkit は in silico創薬やQSAR解析で頻繁に使われる定番ライブラリです。

!pip install meeko

• meeko：AutoDock Vinaの前処理ツールである prepare_ligand を Python で扱うためのラッパー。
• リガンドのフォーマット変換やプロトン化状態の調整、トーションの指定など、分子ドッキング前の処理が行えます。

!pip install gemmi

• gemmi：結晶構造（PDB / mmCIF）ファイルを高速かつ正確に読み書きできるバイオインフォマティクスライブラリ。
• pdb構造の取り扱いや電子密度マップとの連携にも強く、研究現場での使い勝手が高いです。

モジュールのインポート

次に、インストールしたライブラリをインポートしていきます。

import rdkit
from rdkitimport Chem
from rdkit.Chemimport AllChem

• rdkit: ライブラリ全体のベース。
• Chem: 分子（Molオブジェクト）の読み書き、構造の基本操作に使います。
• AllChem: 3D座標の付加（構造最適化や立体構造生成）や部分構造検索、化学反応の定義など、より高度な機能を提供。

import py3Dmol

• py3Dmol: 3D構造をWeb上でインタラクティブに可視化するためのライブラリ。

from typingimportList

• typing モジュールの List は、関数やクラスで**リストの型注釈（型ヒント）**を与えるために使います。

  defprocess_molecules(mols: List[str]):

import re

• re は **正規表現（regex）**モジュールで、文字列の検索・抽出・置換などができます。
  • 例えば、分子名からIDや化合物情報を抽出する場面で活躍します。

関数の定義

# --- Helper Functions (補助関数) ---
def convert_FASTA_to_HELM(seq: str, cyclic: bool = True) -> List[str]: """ FASTA形式の配列（例: 'ACDEF'）をHELM形式（階層的編集言語）に変換する関数です。 cyclic=True の場合、先頭と末尾を結合して環状ペプチドにします（バックボーン環化）。 """ # 1. 配列の文字をドット区切りにします（例: H.M.T...） polymer = ".".join(list(seq)) # PEPTIDE1という名前のポリマーとして定義します helm = f"PEPTIDE1{{{polymer}}}" if cyclic: # 2. 環状化の処理 # N末端（R1）とC末端（R2）を結合させる記述を追加します n = len(seq) # 接続の構文: SourcePoly,TargetPoly,SourceAtom:Att-TargetAtom:Att connection = f"PEPTIDE1,PEPTIDE1,1:R1-{n}:R2" helm += f"${connection}$$$$" else: # 環状化しない場合は終了記号のみ追加 helm += "$$$$" return [helm]
def parse_helm_to_seq(helm: str) -> str: """HELM文字列からアミノ酸配列のみを抽出する関数です。""" # 正規表現を使って PEPTIDE1{...} の中身を取り出します match = re.search(r'PEPTIDE1\{(.*?)\}', helm) if match: # ドットを取り除いて文字列として返します（例: H.M.T -> HMT） return match.group(1).replace('.', '') return ""
def alanine_scanning(helm_str: str) -> List[str]: """ アラニンスキャニングを行う関数です。 ペプチドの各アミノ酸を1つずつアラニン（A）に置換した変異体を作成します。 特定のアミノ酸が活性に重要かどうかを調べるためによく使われます。 """ seq = parse_helm_to_seq(helm_str) variants = [] for i in range(len(seq)): # 元々がアラニンの場合はスキップ if seq[i] == 'A': continue # i番目のアミノ酸を'A'に置き換えた新しい配列を作成 new_seq = seq[:i] + 'A' + seq[i+1:] # HELM形式に変換してリストに追加 variants.append(convert_FASTA_to_HELM(new_seq)[0]) return variants
def homolog_scanning(helm_str: str) -> List[str]: """ ホモログスキャニングを行う関数です。 各アミノ酸を、性質が似ている別のアミノ酸（ホモログ）に置換した変異体を作成します。 """ seq = parse_helm_to_seq(helm_str) # 置換ルール（辞書）: キーのアミノ酸を、値のリストにあるアミノ酸に置換します homologs = { 'H': ['K', 'R'], 'K': ['R', 'H'], 'R': ['K', 'H'], # 塩基性アミノ酸間での置換 'D': ['E'], 'E': ['D'], # 酸性アミノ酸間 'N': ['Q'], 'Q': ['N'], # アミド基を持つもの同士 'S': ['T'], 'T': ['S'], # 水酸基を持つもの同士 'V': ['I', 'L'], 'L': ['I', 'V'], 'I': ['L', 'V'], # 疎水性アミノ酸間 'F': ['Y'], 'Y': ['F'], # 芳香族アミノ酸間 'A': ['G'], 'G': ['A'], # 小さいアミノ酸間 'M': ['L'] } variants = [] for i in range(len(seq)): aa = seq[i] # そのアミノ酸に対する置換ルールが存在する場合 if aa in homologs: for sub in homologs[aa]: # 置換して新しい配列を作成 new_seq = seq[:i] + sub + seq[i+1:] variants.append(convert_FASTA_to_HELM(new_seq)[0]) return variants
def helm_to_3d_mol(helm_str: str): """ HELM文字列をRDKitの分子オブジェクト（3D構造込み）に変換する関数です。 RDKitを使って直鎖ペプチドを作成し、化学的に結合させて環状にします。 """ # 1. 配列情報を取得 seq = parse_helm_to_seq(helm_str) if not seq: return None # 2. 配列から直鎖状のペプチド分子を作成 mol = Chem.MolFromSequence(seq) if mol is None: return None # 3. 環状化（Head-to-Tail cyclization）の処理 # 分子を編集可能な状態（RWMol）にします rwmol = Chem.RWMol(mol) # N末端（アミノ基）とC末端（カルボキシ基）の原子を探します # SMARTS記法というパターンマッチングを使っています n_matches = rwmol.GetSubstructMatches(Chem.MolFromSmarts("[NH2,NH3]")) # N末端 c_matches = rwmol.GetSubstructMatches(Chem.MolFromSmarts("C(=O)[OH]")) # C末端 if not n_matches or not c_matches: print(f"Could not identify termini for {seq}") return None # N末端の窒素原子のインデックス n_atom_idx = n_matches[0][0] # C末端の炭素原子と、脱離するOH基の酸素原子を特定します c_term_indices = c_matches[-1] # 最後に見つかったものをC末端と仮定 c_atom_idx = -1 leaving_o_idx = -1 for idx in c_term_indices: atom = rwmol.GetAtomWithIdx(idx) if atom.GetSymbol() == 'C': # 炭素に結合している酸素（OH）を探す for bond in atom.GetBonds(): neighbor = bond.GetOtherAtom(atom) if neighbor.GetSymbol() == 'O' and bond.GetBondType() == Chem.BondType.SINGLE: c_atom_idx = idx leaving_o_idx = neighbor.GetIdx() break if c_atom_idx != -1: break # ペプチド結合の形成（脱水縮合のシミュレーション） if c_atom_idx != -1 and leaving_o_idx != -1: # OH基を削除 rwmol.RemoveAtom(leaving_o_idx) # N末端のNとC末端のCを単結合でつなぐ rwmol.AddBond(n_atom_idx, c_atom_idx, Chem.BondType.SINGLE) # 編集を確定して通常の分子オブジェクトに戻す mol_cyclic = rwmol.GetMol() try: # 化学的な整合性をチェック Chem.SanitizeMol(mol_cyclic) # 水素原子を付加（3D構造生成に必要） mol_h = Chem.AddHs(mol_cyclic) # 4. 3Dコンフォマー（立体構造）の生成 # ETKDGというアルゴリズムを使って3D座標を計算します AllChem.EmbedMolecule(mol_h, AllChem.ETKDG()) return mol_h except Exception as e: print(f"Error generating 3D for {seq}: {e}") return None return None

ぺプチドライブラリのスクリーニングや構造最適化でよく使われる補助関数群を紹介します。特に以下のような作業を自動化できます：

• FASTA形式のアミノ酸配列 → HELM形式への変換
• アラニンスキャニング・ホモログスキャニングの自動化
• HELM構造からの3D分子生成（RDKit使用）

in silico 創薬やペプチド設計の現場で、高速にスクリーニング候補を生成・検討するための便利ツール群です。

1. convert_FASTA_to_HELM: FASTA配列 → HELM形式へ変換

def　convert_FASTA_to_HELM(seq: str, cyclic:bool =True) ->List[str]:

• FASTA形式（例: "ACDEFGHIK"）を、HELM形式（例: PEPTIDE1{A.C.D.E.F.G.H.I.K}$PEPTIDE1,PEPTIDE1,1:R1-9:R2$$$$）に変換する関数です。
• cyclic=True にすると、**環状ペプチド（ヘッド・トゥ・テール環化）**になります。

2. parse_helm_to_seq: HELM文字列 → アミノ酸配列抽出

def　parse_helm_to_seq(helm: str) ->str:

• HELM形式の中身から、アミノ酸配列部分（例: "ACD"）だけを取り出す関数です。
• 正規表現で PEPTIDE1{...} の中身を抽出 → "A.C.D" → "ACD" に変換します。

3. alanine_scanning: アラニンスキャニング

def　alanine_scanning(helm_str: str) ->List[str]:

• 各アミノ酸を アラニン（A）に1つずつ置換 した HELM 配列のリストを生成します。
• アラニンスキャニングは、活性に重要な残基の特定に有効です（SAR解析など）。

例：

元:HELM(ACD) →[A→A, C→A, D→A]
結果:[AAD, AAD, ACA]

4. homolog_scanning: ホモログスキャニング

def　homolog_scanning(helm_str: str) ->List[str]:

• 各アミノ酸を**性質の似たアミノ酸（ホモログ）**に置き換えたバリエーションを生成します。
• 例えば、K（リジン） → R（アルギニン） に置換、といった操作です。

置換辞書は生理化学的性質に基づいています：

'K': ['R','H'],# 塩基性アミノ酸間
'F': ['Y'],# 芳香族アミノ酸間
...

5. helm_to_3d_mol: HELM文字列 → RDKitで3D構造生成

defhelm_to_3d_mol(helm_str: str):

この関数は、次の処理をステップバイステップで行います：

処理の流れ

1. HELM → アミノ酸配列抽出
2. 配列から直鎖ペプチドを生成（Chem.MolFromSequence）
3. N末端とC末端の原子を検出
4. 脱水縮合（OH削除＋N-C結合）により環化
5. Sanitize（分子構造チェック）＋水素追加
6. 3D構造生成（ETKDGアルゴリズム使用）

出力

• 成功すれば Mol オブジェクト（3D座標付き）
• 可視化には py3Dmol や rdkit.Chem.Draw.MolToImage が使えます。

STEP 1: リードペプチドの定義

# ----------------------------------------------------
# STEP 1: リードペプチドの定義
# ----------------------------------------------------
# ここでは探索の起点となるペプチド配列（リードペプチド）を定義します。
# FASTA形式（'HMTEVVRRC'）からツールで扱いやすいHELM形式に変換しています。
lead_peptide = convert_FASTA_to_HELM('HMTEVVRRC')[0]
print(f"リードペプチド（HELM形式）: {lead_peptide}")

このステップでやっていること

• 入力：リードペプチドの配列 'HMTEVVRRC'（FASTA形式）
• 処理：convert_FASTA_to_HELM 関数を使って、HELM形式 に変換
• 出力：環状ペプチドを表す HELM 文字列

なぜHELM形式に変換するのか？

HELM（Hierarchical Editing Language for Macromolecules）は、以下の理由でペプチドや核酸の表現に適した形式です：

• 修飾残基や環状構造を正確に記述できる
• 分子設計ツール（Schrödinger、BioViaなど）と互換性が高い
• 配列ベースと構造ベースを統合した記述が可能

変換の例

FASTA:'HMTEVVRRC'
↓
HELM: PEPTIDE1{H.M.T.E.V.V.R.R.C}$PEPTIDE1,PEPTIDE1,1:R1-9:R2$$$$

• .join(list(seq)) により、アミノ酸がドット（.）で区切られる
• 1:R1-9:R2 は、1番目と9番目の残基の末端（R1, R2）を結合 → 環状ペプチド化

STEP 2: シードライブラリの生成

# ----------------------------------------------------
# STEP 2: シードライブラリの生成
# ----------------------------------------------------
# リードペプチドを元に、少しだけ配列を変えたペプチド群（ライブラリ）を作ります。
seed_library = [lead_peptide]
# アラニンスキャニング: 各アミノ酸をアラニンに変えたものを作成
for seq in alanine_scanning(lead_peptide): seed_library.append(seq)
# ホモログスキャニング: 各アミノ酸を似た性質のアミノ酸に変えたものを作成
for seq in homolog_scanning(lead_peptide): seed_library.append(seq) # デモ用に数を制限しています（最大10個追加でストップ） if len(seed_library) >= 10: print('Reach max. number of peptides allowed.') break
print(f"Total peptides generated: {len(seed_library)}")
print("First 5 peptides:")
for p in seed_library[:5]: print(p)

このステップでは、STEP 1 で定義したリードペプチドを基にして、構造が少しだけ異なるペプチド群（変異体）を自動で生成します。

seed_library = [lead_peptide]

• seed_library というリストを作成し、まずは元のリードペプチド（HELM形式）を追加します。

アラニンスキャニング（alanine_scanning）

for seqin alanine_scanning(lead_peptide): seed_library.append(seq)

• 各アミノ酸を1つずつ アラニン（A） に置換して、活性に重要な残基を探索するための変異体を生成します。
• 例えば、HMTEVVRRC の中で M → A となると、HATEVVRRC のような変異が作られます。

研究応用：

アラニンスキャニングは、機能性アミノ酸（酵素活性部位や結合ポケットなど）を特定するための標準的な手法です。

ホモログスキャニング（homolog_scanning）

for seqin homolog_scanning(lead_peptide): seed_library.append(seq)
iflen(seed_library) >=10:
print('Reach max. number of peptides allowed.')
break

• 各アミノ酸を、性質が似ている別のアミノ酸に置換します（例：H → K や F → Y）。
• 生理化学的性質が近いので、構造や機能を大きく損なわずにバリエーションを広げられます。
• このコードでは、生成する変異体の数を最大10個に制限しています（チュートリアル用の簡易実装）。

研究応用：

ホモログスキャニングは、構造保存的な最適化や進化的な置換可能性の評価に役立ちます。

結果の確認

print(f"Total peptides generated: {len(seed_library)}")
print("First 5 peptides:")
for pin seed_library[:5]:
print(p)

• 作成したペプチドライブラリの個数を出力し、先頭5件の HELM 表現を表示します。

実行例（出力）

Total peptidesgenerated:10
First5peptides:
PEPTIDE1{H.M.T.E.V.V.R.R.C}$PEPTIDE1,PEPTIDE1,1:R1-9:R2$$$$
PEPTIDE1{A.M.T.E.V.V.R.R.C}$PEPTIDE1,PEPTIDE1,1:R1-9:R2$$$$
PEPTIDE1{H.A.T.E.V.V.R.R.C}$PEPTIDE1,PEPTIDE1,1:R1-9:R2$$$$
PEPTIDE1{H.M.A.E.V.V.R.R.C}$PEPTIDE1,PEPTIDE1,1:R1-9:R2$$$$
PEPTIDE1{H.M.T.A.V.V.R.R.C}$PEPTIDE1,PEPTIDE1,1:R1-9:R2$$$$

STEP 3: 3D Visualization (3D可視化)

# ----------------------------------------------------
# STEP 3: 3D Visualization (3D可視化)
# ----------------------------------------------------
print("Generating 3D structures for the first 3 peptides...")
# 生成したライブラリの最初の3つだけを可視化してみます
for i, helm in enumerate(seed_library[:3]): print(f"\nPeptide {i+1}: {helm}") # 定義した関数を使ってHELM文字列から3D構造データを生成 mol = helm_to_3d_mol(helm) if mol: # py3Dmolを使ってブラウザ上で分子を表示 view = py3Dmol.view(width=400, height=300) # 分子データを渡す view.addModel(Chem.MolToMolBlock(mol), 'mol') # 表示スタイルをスティック（棒）モデルに設定 view.setStyle({'stick': {}}) # 分子が画面に収まるようにズーム view.zoomTo() view.show() else: print("Failed to create 3D structure.")

STEP 3：ペプチドの3D構造を可視化する（py3Dmol）

このステップでは、STEP 2で作成したペプチドライブラリのうち、最初の3つのペプチドについて、立体構造（3D構造）を自動生成し、インタラクティブに可視化します。

print("Generating 3D structures for the first 3 peptides...")

処理の流れ

for i, helminenumerate(seed_library[:3]):

• 生成済みのペプチドライブラリの先頭3つを対象にループ処理します。

3D構造の生成：helm_to_3d_mol

mol = helm_to_3d_mol(helm)

この関数では以下の処理が行われています：

1. HELM文字列からアミノ酸配列を抽出（例：H.M.T... → HMTEVVRRC）
2. RDKit で直鎖ペプチドを生成
3. N末端とC末端の結合を模倣して環状構造化
4. ETKDGアルゴリズムを用いた3D座標生成

ETKDGアルゴリズムとは、分子の3次元構造（3Dコンフォメーション）を生成するための、RDKitで実装された手法のひとつです。正式には「Experimental-Torsion Knowledge Distance Geometry」の略で、距離幾何法（Distance Geometry）をベースに、以下の3要素を統合して高精度な構造生成を実現しています：

1. 距離幾何法（DG）：原子間の距離制約から3D構造を組み立てる数学的手法。
2. 実験トーション角データ（ET）：X線結晶構造などから得られた実験値を学習し、現実的な回転角（torsion angles）を生成に反映。
3. 立体障害の回避（KDG）：原子間の衝突を避け、化学的に自然な配置を目指す。

ETKDGは、SMILESやHELMのような2D構造情報しか持たない分子に、高速かつ現実的な3D構造を付与するための事実上の標準手法です。特に創薬や分子ドッキング、MDシミュレーションの初期構造生成によく用いられます。

1. 分子の整合性（Sanitize）と水素の付加

出力：mol は3D構造を持つ RDKit の Mol オブジェクト

3D可視化：py3Dmol

view = py3Dmol.view(width=400, height=300)
view.addModel(Chem.MolToMolBlock(mol),'mol')
view.setStyle({'stick': {}})
view.zoomTo()
view.show()

• py3Dmol は Webベースの3D分子可視化ライブラリ（3Dmol.jsのPythonラッパー）
• 分子の表示スタイル（スティックモデルなど）を簡単に切り替え可能
• Google Colab や Jupyter Notebook 上で インタラクティブに操作可能

分子の回転・拡大・色変更など、構造理解が格段にしやすくなります

エラーハンドリング

ifnot mol:
print("Failed to create 3D structure.")

• 環状構造の結合エラーや構造生成に失敗した場合でも、スクリプトが止まらずにエラーメッセージを表示します。
• 複雑な構造や端の修飾がある場合は、helm_to_3d_mol が失敗することがあります。

実行結果（例）

以下のような環状ペプチドが生成されます！

STEP 4: PDBQTファイルの保存

# ----------------------------------------------------
# STEP 4: PDBQTファイルの保存
# ----------------------------------------------------
from google.colab import drive
import os
# Google Driveをマウント（接続）します。
# これにより、作成したデータを自分のDriveに保存できるようになります。
drive.mount('/content/drive')
# 出力先のディレクトリ（フォルダ）パスを定義します
output_dir = '/content/drive/MyDrive/Cyclic_peptide_screening'
# ディレクトリが存在しない場合は作成します（exist_ok=Trueで既存の場合のエラーを回避）
os.makedirs(output_dir, exist_ok=True)
print(f"Output directory created/verified at: {output_dir}")
from meeko import MoleculePreparation
from rdkit import Chem
import requests
def save_mol_to_pdbqt(mol, name, output_dir): """ RDKitの分子オブジェクトをPDBQT形式で保存する関数です。 PDBQTはドッキングシミュレーション（AutoDockなど）で使われる形式です。 """ try: # Meekoを使って分子の前処理（プレパレーション）を行います # これにより、結合の回転などを設定したPDBQTデータが作られます preparator = MoleculePreparation() preparator.prepare(mol) pdbqt_string = preparator.write_pdbqt_string() # ファイルとして保存 filename = os.path.join(output_dir, f"{name}.pdbqt") with open(filename, 'w') as f: f.write(pdbqt_string) return True except Exception as e: print(f"Error converting {name}: {e}") return False
print("Starting PDBQT conversion for peptide library...")
success_count = 0
# ライブラリ内の全ペプチドについて処理を実行します
for i, helm in enumerate(seed_library): # ファイル名用に配列を取得 seq_name = parse_helm_to_seq(helm) base_name = seq_name if seq_name else f"peptide_{i+1:03d}" name = f"Cyclic_{base_name}" # 3D構造を生成 mol = helm_to_3d_mol(helm) if mol: # 分子に名前プロパティを追加 mol.SetProp("_Name", name) # PDBQT形式で保存 if save_mol_to_pdbqt(mol, name, output_dir): success_count += 1 else: print(f"Failed to save {name}") else: print(f"Failed to generate 3D for {name} ({helm})")
print(f"\nSuccessfully saved {success_count}/{len(seed_library)} peptides to {output_dir}") 

STEP 4：PDBQTファイルの保存（AutoDock用）

このステップでは、STEP 3で生成したペプチドの3D構造を、AutoDock や AutoDock Vina で使える PDBQT形式 に変換し、Google Drive に保存します。

Google Driveとの接続と出力先の設定

from google.colabimport drive
import os
drive.mount('/content/drive')
output_dir ='/content/drive/MyDrive/Cyclic_peptide_screening'
os.makedirs(output_dir, exist_ok=True)

• drive.mount：Colab と Google Drive を接続します。
• os.makedirs(..., exist_ok=True)：出力フォルダを作成（既にあってもOK）

これで、変換したファイルを 自分のDriveに自動保存できるようになります。

Meeko を使った PDBQT 変換関数の定義

from meekoimport MoleculePreparation
from rdkitimport Chem
def　save_mol_to_pdbqt(mol, name, output_dir):

この関数は次の処理を自動で行います：

1. Meeko を使って RDKit 分子をプレパレーション
2. 回転可能な結合情報などを含む PDBQT文字列を生成
3. 指定フォルダに .pdbqt ファイルとして保存

例：

save_mol_to_pdbqt(mol,"Cyclic_HMTEVVRRC","/content/drive/MyDrive/...")

ライブラリ全体のバッチ変換処理

for i, helminenumerate(seed_library): mol = helm_to_3d_mol(helm) ... save_mol_to_pdbqt(mol, name, output_dir)

• すべてのペプチドに対して helm_to_3d_mol() を使って 3D構造を生成
• Meeko に渡して .pdbqt 形式で保存

ファイル名は次のようになります：

Cyclic_HMTEVVRRC.pdbqt
Cyclic_AMTEVVRRC.pdbqt
Cyclic_HATEVVRRC.pdbqt
...

実行結果のログ出力

print(f"\nSuccessfully saved {success_count}/{len(seed_library)} peptides to{output_dir}")

例：

Successfully saved10/10 peptidesto /content/drive/MyDrive/Cyclic_peptide_screening

• 保存に成功した数を表示してくれるため、エラー検出や進捗確認が容易です。

結果

上記のコードが全てrunされると、設定したoutputディレクトリに環状ペプチドライブラリが出力されます!

最後に

今日はHELM形式という形式を使って、環状ペプチドライブラリの作成を行いました!

非天然アミノ酸も設定により、構築可能なので、あらゆるライブラリに対応可能です。

ぜひお望みのライブラリを設定してみてください！次は本ライブラリを使って、スクリーニングを実行します！

【この記事のまとめ】

バイオインフォマティクスや創薬研究に携わるエンジニア・研究者に向けて、Pythonパッケージ「mobius」とベイズ最適化を活用し、標的タンパク質に対して高い結合親和性を持つペプチド配列を効率的に探索・設計する手法を解説します。

• 膨大な探索空間の克服：5000億通り以上（9残基の場合）存在するペプチド配列の組み合わせから、ベイズ最適化（BO）を用いて「賢く」次候補を選別し、実験・計算コストを劇的に削減する方法を習得できます。
• 実践的なモデリングフロー：アミノ酸変異による結合力予測（PSSM）とmobiusを組み合わせ、初期ライブラリの生成（アラニンスキャニング等）からDMTサイクル（設計・作成・試験）の自動化までのプロセスを詳述。
• 高度なカスタマイズ性：HELM記法によるエンコード、分子フィンガープリント（MAP4）を用いたガウス過程モデルの構築など、非標準アミノ酸や複雑な構造制約にも対応可能な最新の設計プロトコルを紹介。

この記事を読むことで、限られたリソースで最適解にたどり着く「データ駆動型ペプチド創薬」の具体的な実装スキルを身につけることができます。

mobiusとは？

mobiusは、ベイズ最適化（Bayesian Optimization, BO）を用いてペプチド配列を最適化するためのPythonパッケージです。完全自動化されたDesign-Make-Test（DMT）サイクルの中で、ペプチドの設計と最適化を支援します。

mobiusの主な特徴は以下の通りです。

• 単一または複数の目的関数の最適化（制約条件付き）
• 線形および非線形ペプチド配列のサポート（マクロ環状、ラッソ、分岐など）
• 非標準アミノ酸残基と修飾のサポート
• デザインプロトコルによる配列最適化のカスタマイズ
• 独自の分子表現（フィンガープリント、グラフカーネル、GNNなど）の拡張が容易
• 他のツールとの統合（ドッキング、pyRosetta、Damietta、AlphaFoldなど）

今回は、mobiusのチュートリアルを参考にしつつ、PSSMマトリックスを使用した高速な評価を行う実装を行います。

MHCクラスI（HLA-A*02:01）に対する結合親和性を最適化するペプチド配列を、初期のリードペプチドからアラニンスキャニングとホモログスキャニングで96個のペプチドを生成し、それぞれをPSSMマトリックスで評価した後、ベイズ最適化を設定してDMTサイクルを実行し、最も結合親和性の高いペプチド配列とその結合スコアを見つけ出す過程を追っていきます。

ベイズ最適化（Bayesian Optimization）とは？

ベイズ最適化（BO）は、機械学習の一種で、「評価コストが高い関数（実験やシミュレーション）において、どの入力（今回はペプチド配列）を優先的に評価すれば、最も効率よく最適解にたどり着けるか？」を自律的に判断する手法です。

問題設定

ペプチド配列は20種類のアミノ酸から構成され、9残基のペプチドの場合、理論上は20^9 = 5120億通りもの組み合わせがあります。すべてを実験で評価するのは不可能です。

ベイズ最適化の考え方

「賢く選んで、少ない実験回数で最適解を見つける」手法です。

1. 探索と活用のバランス

• 探索（Exploration）: まだ試していない領域を調べる
• 活用（Exploitation）: これまでに良い結果が出た領域を詳しく調べる
• この2つをバランスよく行うことで、効率的に最適解に近づきます

2. 予測モデル（ガウス過程）

• 既に評価したペプチドのデータから、未評価のペプチドのスコアを予測します
• 「このペプチドは良いスコアが出そう」という予測値と、「この予測はどれくらい確実か」という不確実性の両方を提供します

3. 獲得関数（次に何を試すか決める）

• 予測値が良いペプチド → 試す価値がある
• 不確実性が高いペプチド → もしかしたら良い結果が出るかもしれない
• この2つを組み合わせて、次に評価すべきペプチドを選びます

具体例で理解する

従来の方法（ランダム探索）:

1. ランダムに100個のペプチドを選ぶ
2. 全部評価する
3. 最良のものを選ぶ
→ 運が良ければ良い結果、運が悪ければ無駄が多い

ベイズ最適化:

1. 初期に少数（96個）のペプチドを評価
2. データから「良いペプチドの特徴」を学習
3. 学習結果を基に、次に試すべき96個を賢く選ぶ
4. 評価して、さらに学習を更新
5. これを繰り返す
→ 少ない評価回数で、より良い結果に到達

BOの役割は以下の通りです。

1. 初期評価（シードライブラリの生成）: まず少数のペプチドを配列ベースの戦略（アラニンスキャニング、ホモログスキャニングなど）で選び、PSSMマトリックスによりその結合親和性（pIC50スコア）を計算（評価）します。
2. 代理モデルの構築: 評価結果を基に、未評価のペプチド群のスコア（結合親和性）を予測する機械学習モデル（ガウス過程など）を構築します。
3. 獲得関数に基づく選択: 代理モデルの予測結果から、「最もスコアが良さそう（pIC50スコアが低そう）」または「予測の不確実性が高く、評価すればモデルが大きく改善しそう」なペプチドを、獲得関数（Acquisition Function）を使って優先的に選択します。
4. 再評価と学習: 選択したペプチドをPSSMマトリックスで実際に評価し、その結果（pIC50スコア）を代理モデルにフィードバック（学習）させることで、モデルの予測精度を向上させます。

このサイクル（Design-Make-Testサイクル）を繰り返すことで、全ペプチドを評価せずとも、最終的に目的とする高性能なペプチド（高い結合親和性を持つペプチド）に効率よくたどり着くことが可能になります。

mobiusは、このBOの仕組みを、ペプチドの設計・評価プロセスに組み込むことを可能にしています。

環境構築

installationの資料はこちら。

注意: mobiusは、ガウス過程モデルやグラフニューラルネットワークなどの機械学習モデルを使用するため、GPUがあると計算が大幅に高速化されます。本記事ではCPUのみを使用した実装を行いますが、大規模な最適化を行う場合はGPUの使用を推奨します。GPUを使用する場合は、Linux環境でCUDA対応のPyTorchをインストールしてください。

Miniforge3のインストール

まず、Miniforge3をインストールします（既にインストール済みの場合はスキップしてください）。

# Miniforge3インストーラをダウンロード
curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
# Miniforge3をインストール
bash Miniforge3-$(uname)-$(uname -m).sh
# インストール後、新しいターミナルを開くか、以下を実行してcondaを有効化# macOS (zsh) の場合eval "$(~/miniforge3/bin/conda shell.zsh hook)"
conda init zsh
source ~/.zshrc
# Linux (bash) の場合eval "$(~/miniforge3/bin/conda shell.bash hook)"
conda init bash
source ~/.bashrc

mobiusのセットアップ

1. mobiusリポジトリのクローン

git clone https://git.scicore.unibas.ch/schwede/mobius.git
cd mobius

1. 環境ファイルのダウンロード

以下の環境ファイルをダウンロードして、mobiusディレクトリに配置してください。

CPU版（macOS ARM64）: environment_cpu.yaml (クローンしたものの中にあるenvironmental.yamlで環境構築もOKですが、私のPCではうまくいかなかったので、修正してます。）

1. 仮想環境の作成

# CPU版を使用する場合（macOS ARM64 / Apple Silicon）
mamba env create -f environment_cpu.yaml -n mobius

1. 環境のアクティベートとmobiusのインストール

#eval "$(~/miniforge3/bin/mamba shell hook --shell zsh)"
# 環境をアクティベート
mamba activate mobius

注意:

• mambaがインストールされていない場合は、conda install mamba -n base -c conda-forge -yでインストールしてください。
• 新しいターミナルを開いた場合は、mamba activate mobiusの前にeval "$(~/miniforge3/bin/mamba shell hook --shell zsh)"（zshの場合）またはeval "$(~/miniforge3/bin/mamba shell hook --shell bash)"（bashの場合）を実行してください。

データの準備

MHCクラスIのPSSMファイルが必要です。mobiusリポジトリには、IEDB（Immune Epitope Database）から取得したPSSMファイルが含まれています。

PSSMファイルについて:

• PSSM（Position-Specific Scoring Matrix：位置特異的スコアリングマトリックス）は、ペプチドの各位置に各アミノ酸が現れる際のスコアを表すマトリックスです。

以下のような構造をしています。

NumCols:	8
A	-0.055	-0.024	-0.007	-0.261	0.237	-0.045	-0.050	-0.007
C	0.003	0.085	-0.018	-0.371	0.048	0.005	0.009	-0.020
D	-0.006	-0.195	0.029	0.119	-0.494	-0.022	0.017	-0.010
E	-0.015	-0.099	0.009	0.036	-0.098	0.008	0.012	-0.005
F	0.011	0.304	-0.064	-0.506	0.018	0.100	0.104	-0.091
G	0.002	0.036	0.009	0.014	-0.912	-0.010	-0.040	-0.007
H	0.023	-0.052	0.015	0.205	-0.566	-0.034	-0.014	-0.028
I	-0.004	0.146	-0.056	-0.143	0.312	0.122	0.095	0.098
K	0.018	0.084	0.048	0.233	-0.040	-0.014	-0.040	0.058
L	-0.019	0.303	-0.026	-0.218	0.240	0.074	0.057	0.042
M	-0.005	0.127	-0.039	0.067	-0.083	0.039	0.049	0.028
N	-0.002	-0.148	0.039	0.095	0.075	-0.057	-0.032	-0.007
P	-0.015	0.158	0.070	-0.024	0.005	-0.019	-0.139	0.026
Q	-0.003	-0.041	0.031	0.128	-0.040	-0.031	-0.061	0.036
R	0.019	0.107	0.042	0.369	0.236	-0.035	-0.084	0.007
S	0.001	-0.597	0.007	0.350	0.333	-0.101	-0.055	0.020
T	-0.000	-0.411	0.011	0.170	0.201	-0.053	-0.016	0.015
V	-0.006	-0.091	-0.020	-0.085	0.480	0.045	0.045	0.048
W	0.034	0.054	-0.034	-0.130	0.017	0.023	0.057	-0.056
Y	0.020	0.255	-0.047	-0.048	0.032	0.005	0.086	-0.146
Intercept	4.52761

「8つの位置のそれぞれに、どのアミノ酸が好まれるか」を数値化したものです。

行は20種類のアミノ酸、列はペプチドの位置（1〜8）を表します。

各数値は その位置にそのアミノ酸が入ったときの寄与スコア を意味し、

• プラス（+） → 好まれる / 結合に有利
• マイナス（–） → 好まれない / 不利

を示します。

例えば位置5では V(0.480), I(0.312) が高く、

疎水性アミノ酸が強く好まれる位置 と読み取れます。

逆に G(-0.912) は非常に嫌われます。

ペプチド全体のスコアは

各位置のスコアの合計 + 最後の“Intercept(4.52761)”

で計算され、MHC結合予測や免疫原性予測に使われます。

PSSMファイルはmobius/data/IEDB_MHC_I-2.9_matx_smm_smmpmbec/smmpmbec_matrix/ディレクトリに配置されています。

クローンしてきたmobiusのexamplesのhello_world.ipynbを参考に、mobius_test/linear_peptide/linear_peptide.ipynbを作成して実行してください。

cursorでのjupyter環境の設定は以下をご覧ください。

環境構築｜【完全版】In silico創薬実践書 〜おうち創薬で論文を書こう〜

mobiusによるベイズ最適化の実行

全コードはこちらを参考にしています。チュートリアルとほぼ一緒ですが、一部説明を追加しています。

# ----------------------------------------------------
# STEP 1: 準備と環境設定
# ----------------------------------------------------
# 必要なライブラリをインポート
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from gpytorch.priors import NormalPrior
# mobiusの主要なクラスと関数をインポート
from mobius import Planner, SequenceGA # プランナーと遺伝的アルゴリズム最適化器
from mobius import Map4Fingerprint # 分子フィンガープリント（MAP4）
from mobius import GPModel, ExpectedImprovement, TanimotoSimilarityKernel # ガウス過程モデル、獲得関数、カーネル
from mobius import LinearPeptideEmulator # MHCクラスIエミュレーター（PSSMベース）
from mobius import homolog_scanning, alanine_scanning # 配列ベースのスキャニング戦略
from mobius import convert_FASTA_to_HELM # FASTA形式からHELM形式への変換
# ----------------------------------------------------
# STEP 2: LinearPeptideEmulatorの初期化
# ----------------------------------------------------
# MHCクラスI HLA-A*02:01のLinearPeptideEmulatorを初期化
# Position Specific Scoring Matrix (PSSM) ファイルを使用
import os
# PSSMファイルのパス（複数のペプチド長に対応）
pssm_dir = os.path.join('..', '..', 'mobius', 'data', 'IEDB_MHC_I-2.9_matx_smm_smmpmbec', 'smmpmbec_matrix')
pssm_dir = os.path.normpath(os.path.abspath(pssm_dir))
pssm_files = [ os.path.join(pssm_dir, 'HLA-A-02:01-8.txt'), os.path.join(pssm_dir, 'HLA-A-02:01-9.txt'), os.path.join(pssm_dir, 'HLA-A-02:01-10.txt'), os.path.join(pssm_dir, 'HLA-A-02:01-11.txt')
]
# LinearPeptideEmulatorを初期化
# 実際の使用では、このステップを実際のラボ実験に置き換える必要があります
lpe = LinearPeptideEmulator(pssm_files)
# ----------------------------------------------------
# STEP 3: リードペプチドの定義
# ----------------------------------------------------
# 最適化の出発点となるリードペプチドを定義
# FASTA形式（'HMTEVVRRC'）からHELM形式に変換
# mobiusは内部的にHELM記法を使用してペプチド配列をエンコードします
lead_peptide = convert_FASTA_to_HELM('HMTEVVRRC')[0]
print(f"リードペプチド（HELM形式）: {lead_peptide}")
# ----------------------------------------------------
# STEP 4: シードライブラリの生成
# ----------------------------------------------------
# 初期評価用のシードライブラリを生成
# アラニンスキャニングとホモログスキャニングを組み合わせて96個のペプチドを生成
seed_library = [lead_peptide]
# アラニンスキャニング: 各位置をアラニンに置き換えた変異体を生成
for seq in alanine_scanning(lead_peptide): seed_library.append(seq)
# ホモログスキャニング: 各位置を類似アミノ酸に置き換えた変異体を生成
for seq in homolog_scanning(lead_peptide): seed_library.append(seq) if len(seed_library) >= 96: print('Reach max. number of peptides allowed.') break
# ----------------------------------------------------
# STEP 5: シードライブラリの評価
# ----------------------------------------------------
# シードライブラリの各ペプチドをLinearPeptideEmulatorで評価
# HELM形式のペプチドを評価し、pIC50スコアを計算
pic50_seed_library = lpe.score(seed_library)
print(f"評価したペプチド数: {len(seed_library)}")
print(f"平均pIC50スコア: {np.mean(pic50_seed_library):.3f}")
print(f"最良のスコア: {np.min(pic50_seed_library):.3f}")
best_idx = np.argmin(pic50_seed_library)
print(f"最良のペプチド: {seed_library[best_idx]}")
print(f"（スコアが低いほど結合親和性が高い）")
# ----------------------------------------------------
# STEP 6: ベイズ最適化の設定
# ----------------------------------------------------
# 1. 分子フィンガープリント（MAP4）を設定
# HELM形式の入力を受け取り、4096次元のベクトルに変換
# 構造的に類似したペプチドが近いベクトル表現になる
map4 = Map4Fingerprint(input_type='helm', dimensions=4096, radius=1)
# 2. ガウス過程モデルを設定
# Tanimoto類似度カーネルを使用し、MAP4フィンガープリントで変換
# 既に評価したペプチドのデータから、未評価のペプチドのスコアを予測
gpmodel = GPModel(kernel=TanimotoSimilarityKernel(), transform=map4, noise_prior=NormalPrior(loc=0, scale=1))
# 3. 獲得関数（Expected Improvement）を設定
# ガウス過程モデルを使用し、最小化問題（pIC50スコアを小さくする）として設定
# pIC50スコアは低いほど結合親和性が高いため、maximize=False
# 次に評価すべきペプチドを選択するための関数
acq = ExpectedImprovement(gpmodel, maximize=False)
# ----------------------------------------------------
# STEP 7: デザインプロトコルの定義
# ----------------------------------------------------
# YAML形式でデザインプロトコルを定義
# ペプチドの構造制約とフィルター条件を指定
yaml_content = """
design: monomers: default: [A, C, D, E, F, G, H, I, K, L, M, N, P, Q, R, S, T, V, W, Y] APOLAR: [A, F, G, I, L, P, V, W] POLAR: [C, D, E, H, K, N, Q, R, K, S, T, M] AROMATIC: [F, H, W, Y] POS_CHARGED: [K, R] NEG_CHARGED: [D, E] polymers: - PEPTIDE1{X.M.X.X.X.X.X.X.X}$$$$V2.0: PEPTIDE1: 1: [AROMATIC, NEG_CHARGED] 4: POLAR 9: [A, V, I, L, M, T]
filters: - class_path: mobius.PeptideSelfAggregationFilter - class_path: mobius.PeptideSolubilityFilter init_args: hydrophobe_ratio: 0.5 charged_per_amino_acids: 5
"""
# デザインプロトコルをYAMLファイルに保存
with open('design_protocol.yaml', 'w') as f: f.write(yaml_content)
# ----------------------------------------------------
# STEP 8: 最適化器とプランナーの初期化
# ----------------------------------------------------
# 遺伝的アルゴリズム（GA）ベースの最適化器を設定
# period=15: GAの世代数を15に設定
optimizer = SequenceGA(algorithm='GA', period=15, design_protocol_filename='design_protocol.yaml')
# プランナーを初期化（獲得関数と最適化器を組み合わせる）
ps = Planner(acq, optimizer)
# ----------------------------------------------------
# STEP 9: Design-Make-Test（DMT）サイクルの実行
# ----------------------------------------------------
# 評価済みペプチドとスコアを保持するリスト
peptides = seed_library.copy()
pic50_scores = pic50_seed_library.copy()
# 後で分析するためのデータを保存
data = [(0, p, s) for p, s in zip(peptides, pic50_scores)]
# 3回のDMTサイクルを実行
num_cycles = 3
batch_size = 96
for i in range(num_cycles): print(f'\n=== DMTサイクル {i+1}/{num_cycles} ===') # Design: ベイズ最適化に基づいて、次に評価すべきペプチドを推薦 suggested_peptides, _ = ps.recommend(peptides, pic50_scores.reshape(-1, 1), batch_size=batch_size) # Test: 推薦されたペプチドをLinearPeptideEmulatorで評価 # 注意: 実際の使用では、ここで実際のラボ実験を実行します pic50_suggested_peptides = lpe.score(suggested_peptides) # 新しいデータを既存のリストに追加 peptides = np.concatenate([peptides, suggested_peptides]) pic50_scores = np.concatenate((pic50_scores, pic50_suggested_peptides), axis=0) data.extend([(i + 1, p, s) for p, s in zip(suggested_peptides, pic50_suggested_peptides)]) # これまでに見つかった最良のペプチドとそのスコアを表示 best_seq = peptides[np.argmin(pic50_scores)] best_pic50 = np.min(pic50_scores) print(f'\n最良のペプチド: {best_seq}') print(f'最良のスコア: {best_pic50:.3f}') print(f'（スコアが低いほど結合親和性が高い）')
# データをDataFrameに変換（可視化用）
df = pd.DataFrame(data=data, columns=('iter', 'polymer', 'exp_value'))
# ----------------------------------------------------
# STEP 10: 結果の可視化
# ----------------------------------------------------
# 最適化の進行状況を可視化
fig, ax = plt.subplots(figsize=(20, 7.5))
# イテレーション番号を文字列に変換（'Init.'は初期シードライブラリ）
df['iter'] = df['iter'].replace({0: 'Init.', 1: '1', 2: '2', 3: '3'})
# 各イテレーションでのpIC50スコアの平均と95%信頼区間をプロット
sns.lineplot(x='iter', y='exp_value', data=df, ax=ax, errorbar=('ci', 95), err_style='bars', linewidth=3.5, err_kws={'lw': 3.5})
# グラフの設定
ax.set_xlim([-0.9, 3.5])
ax.set_ylim([-2, 4.5])
ax.set_ylabel('pIC50', fontsize=30)
ax.set_xlabel('Generations', fontsize=30)
ax.xaxis.set_tick_params(labelsize=30)
ax.yaxis.set_tick_params(labelsize=30)
# グラフのスタイル調整
sns.despine()
plt.tight_layout()
plt.show()
# 最終結果の表示
print('\n' + '='*60)
print('最適化結果のサマリー')
print('='*60)
best_idx = np.argmin(pic50_scores)
best_peptide = peptides[best_idx]
best_score = pic50_scores[best_idx]
print(f'\n最良のペプチド配列（HELM形式）:')
print(f' {best_peptide}')
print(f'\npIC50スコア: {best_score:.3f}')
print(f'（スコアが低いほど結合親和性が高い）')
print(f'\n評価したペプチドの総数: {len(peptides)}')
print(f'初期シードライブラリ: {len(seed_library)}')
print(f'DMTサイクルで評価したペプチド: {len(peptides) - len(seed_library)}')
print('='*60)

全体の流れ：AIを使った新しいペプチドの探索

このコードは、既存のリードペプチドをベースに、AI（ベイズ最適化）を使って、ターゲットタンパク質（MHCクラスI）に最もよく結合するであろう新しいペプチド配列を効率的に見つけ出すという、創薬研究のプロセスをシミュレーションしています。

プロセスは以下のステップで進行します。

• 準備と初期設定（Step 1〜3）:
  • 必要なツールを準備し、MHCクラスIのPSSMマトリックスを読み込んでLinearPeptideEmulatorを初期化します。
  • 最適化の出発点となるリードペプチドを定義し、HELM形式に変換します。
• シードライブラリの生成と評価（Step 4〜5）:
  • リードペプチドからアラニンスキャニングとホモログスキャニングを用いて96個の変異体を生成します。
  • 生成したペプチドをPSSMマトリックスで評価し、pIC50スコア（結合スコア）を計算します。これはAIが学習するための最初のデータセットとなります。
• ベイズ最適化の設定（Step 6〜8）:
  • 分子フィンガープリント（MAP4）、ガウス過程モデル、**獲得関数（Expected Improvement）**を設定します。
  • デザインプロトコル（YAML形式）で、ペプチドの構造制約とフィルター条件を定義します。
  • 最適化器（遺伝的アルゴリズム）とプランナーを初期化します。
• Design-Make-Testサイクル（Step 9）:
  • AIが学習結果に基づき、「次に計算すれば最も良いスコアが出そう」と予測した最適な96個のペプチドを選び出し、再度PSSMマトリックスで評価します。
  • このサイクルを3回繰り返します。
  • 各サイクル終了時に、これまでに見つかった最良のペプチドとその結合スコアを表示します。
• 結果の可視化（Step 10）:
  • 各イテレーションでのpIC50スコアの分布を可視化し、最適化の進行状況を確認します。
  • 最終的に、最良のペプチド配列とその結合スコアを表示します。

STEP 1: 準備と環境設定

シミュレーションを行うための道具の準備を行います。

• import numpy as np / import pandas as pd / import matplotlib.pyplot as plt / import seaborn as sns: 数値計算のNumPy、データ分析のPandas、可視化のMatplotlibとSeabornという標準的なPythonライブラリをプログラムに組み込んでいます。
• from mobius import Planner, SequenceGA: mobiusから、ベイズ最適化のプランナーと、遺伝的アルゴリズムベースの最適化器を呼び出せるようにしています。
• from mobius import Map4Fingerprint: ペプチド配列を数値ベクトル（フィンガープリント）に変換するMAP4という手法を呼び出しています。
• from mobius import GPModel, ExpectedImprovement, TanimotoSimilarityKernel: ベイズ最適化の核心となるガウス過程モデル、獲得関数、カーネル関数を呼び出しています。
• from mobius import LinearPeptideEmulator: PSSMマトリックスを使用してペプチドの結合親和性を予測するLinearPeptideEmulatorを呼び出しています。
• from mobius.utils import MolFromHELM: HELM形式のペプチドをRDKit分子に変換する関数を呼び出しています。
• from mobius import homolog_scanning, alanine_scanning: 初期ライブラリを生成するための配列ベースのスキャニング戦略を呼び出しています。
• from mobius import convert_FASTA_to_HELM: FASTA形式のペプチド配列を、mobiusが使用するHELM形式に変換する関数を呼び出しています。

STEP 2: LinearPeptideEmulatorの初期化

MHCクラスI（HLA-A*02:01）のPSSMファイルを読み込み、LinearPeptideEmulatorを初期化します。

IEDBデータベースについて

PSSMファイルは、IEDB（Immune Epitope Database）から取得された実験データに基づいて作成されています。

データの取得方法：

1. 文献からの収集: 公開された科学論文から手作業で実験データを収集
2. 実験データ: 実際のMHC結合アッセイで測定された結合親和性（IC50値など）
3. 機械学習モデル: SMM（Stabilized Matrix Method）という機械学習モデルで学習
4. PSSMファイル生成: 学習したモデルからPSSMファイルが生成される

• pssm_files = [...]: 複数のペプチド長（8、9、10、11残基）に対応するPSSMファイルのパスをリストで指定しています。
• lpe = LinearPeptideEmulator(pssm_files): LinearPeptideEmulatorを初期化しています。これにより、ペプチドをMHCクラスIに結合させた際のpIC50スコア（結合スコア）を計算できます。pIC50スコアは低いほど結合親和性が高いことを示します。

STEP 3: リードペプチドの定義

最適化の出発点となるリードペプチドを定義します。

• lead_peptide = convert_FASTA_to_HELM('HMTEVVRRC')[0]: FASTA形式のペプチド配列（'HMTEVVRRC'）を、mobiusが使用するHELM形式に変換しています。HELM（Hierarchical Editing Language for Macromolecules）は、ペプチドやその他の複雑な生体分子を表現するための標準形式です。

HELM形式の表記について

このノートブックでは、ペプチド配列をHELM形式（Hierarchical Editing Language for Macromolecules）で表現しています。

HELM形式の構造:

例: PEPTIDE1{H.M.M.D.F.I.F.E.V}$$$$V2.0

この表記は以下の部分から構成されています：

1. PEPTIDE1: ペプチドのタイプ
   • 線形ペプチドを表す識別子
2. {H.M.M.D.F.I.F.E.V}: アミノ酸配列
   • 各アミノ酸は1文字コードで表される
   • ドット（.）で区切られている
   • 左から右へ、N末端からC末端の順
3. $$$$: セパレーター
   • 複数のポリマーや接続情報を区切る
   • 線形ペプチドの場合は接続情報がないため、$$$$のみ
4. V2.0: HELMのバージョン
   • HELM記法のバージョン番号

STEP 4: シードライブラリの生成

初期評価用のシードライブラリを生成します。

• seed_library = [lead_peptide]: シードライブラリのリストを初期化し、リードペプチドを最初の要素として追加しています。
• for seq in alanine_scanning(lead_peptide):: アラニンスキャニングを実行します。これは、リードペプチドの各位置をアラニン（A）に置き換えた変異体を生成する戦略です。各位置の重要性を評価するために使用されます。
• for seq in homolog_scanning(lead_peptide):: ホモログスキャニングを実行します。これは、リードペプチドの各位置を類似アミノ酸に置き換えた変異体を生成する戦略です。構造的に類似したアミノ酸への置換により、機能を維持しながら多様性を導入します。
• if len(seed_library) >= 96: break: シードライブラリが96個に達したら、ループを終了します。

STEP 5: シードライブラリの評価

生成したシードライブラリの各ペプチドをPSSMマトリックスで評価します。

• pic50_seed_library = lpe.score(seed_library): LinearPeptideEmulatorを使用して、シードライブラリの各ペプチドのpIC50スコアを計算しています。pIC50スコアは低いほど結合親和性が高いことを示します。

このステップでは、96個のペプチドそれぞれに対してPSSMマトリックスによる評価を実行し、MHCクラスIとの結合スコアを取得します。これらのスコアは、ベイズ最適化の学習データとして使用されます。

STEP 6: ベイズ最適化の設定

ベイズ最適化に必要なコンポーネントを設定します。

• map4 = Map4Fingerprint(input_type='helm', dimensions=4096, radius=1): MAP4フィンガープリントを設定しています。これは、HELM形式のペプチド配列を4096次元の数値ベクトルに変換する手法です。radius=1は、原子から1ホップ以内の部分構造を考慮することを意味します。

役割: ペプチド配列を数値ベクトルに変換する「翻訳機」

なぜ必要？

• コンピュータは文字列（ペプチド配列）を直接理解できません
• 数値ベクトルに変換することで、数学的な計算が可能になります

具体例:

ペプチド「HMTEVVRRC」→ [0.23, -0.15, 0.87, ..., 0.42] (4096次元のベクトル)
ペプチド「HMTEVVRRV」→ [0.24, -0.14, 0.86, ..., 0.41] (似た配列なので似たベクトル)

gpmodel = GPModel(kernel=TanimotoSimilarityKernel(), transform=map4, noise_prior=NormalPrior(loc=0, scale=1)): ガウス過程モデルを設定しています。これは、ペプチドのフィンガープリントから結合親和性を予測する代理モデルです。TanimotoSimilarityKernelは、2つのペプチドの類似度を計算するカーネル関数です。noise_priorは、観測ノイズの事前分布を設定しています。

役割: 「予測屋さん」- 未評価のペプチドのスコアを予測する

どのように予測するか？

1. 学習: 既に評価したペプチドのデータを見る

   評価済み: HMTEVVRRC → スコア 2.5
   評価済み: HMTEVVRRV → スコア 2.3
   評価済み: HMTEVVRRA → スコア 2.8

2. パターン発見: 「似た配列は似たスコアになる」というパターンを学習

   「位置9がC, V, Aのとき、スコアは2.3-2.8の範囲」
   「位置8がRのとき、スコアが良くなる傾向」

3. 予測: 未評価のペプチドのスコアを予測

   未評価: HMTEVVRRL → 予測スコア: 2.4 ± 0.3
   （「2.4くらいになりそう。でも、0.3の誤差があるかも」）

• acq = ExpectedImprovement(gpmodel, maximize=False): 獲得関数（Expected Improvement）を設定しています。これは、次に評価すべきペプチドを選ぶための関数です。maximize=Falseは、pIC50スコアを最小化する（結合親和性を最大化する）問題であることを示しています。pIC50スコアは低いほど良いため、最小化問題として設定します。

役割: 「次に何を試すか決める審判員」

判断基準:

1. 予測値が良いペプチド → 試す価値がある

   予測スコア: 1.5（現在の最良: 2.0より良い！）
   → 試してみたい

2. 不確実性が高いペプチド → もしかしたら良い結果が出るかも

   予測スコア: 2.5 ± 1.0（不確実性が大きい）
   → もしかしたら1.5になるかもしれない！

3. バランス: この2つを組み合わせて、期待改善値を計算

   期待改善値 = 「このペプチドを試すことで、どれくらい改善が期待できるか」

STEP 7: デザインプロトコルの定義

ペプチドの構造制約とフィルター条件をYAML形式で定義します。

• yaml_content = """...""": YAML形式の文字列でデザインプロトコルを定義しています。
  • monomers: 各位置で使用可能なアミノ酸のセットを定義しています。defaultは全20種類の標準アミノ酸、APOLARは非極性アミノ酸、POLARは極性アミノ酸など、意味のあるグループに分類されています。
  • polymers: ペプチドのスキャフォールドを定義しています。PEPTIDE1{X.M.X.X.X.X.X.X.X}$$$$V2.0は、9残基の線形ペプチドを表しています。各位置（1, 4, 9）で使用可能なアミノ酸のセットを指定しています。
  • filters: 合成や溶解度に問題がある可能性のあるペプチドを除外するフィルターを定義しています。PeptideSelfAggregationFilterは自己凝集を防ぐフィルター、PeptideSolubilityFilterは溶解度を確保するフィルターです。
• with open('design_protocol.yaml', 'w') as f: f.write(yaml_content): 定義したデザインプロトコルをYAMLファイルに保存しています。

STEP 8: 最適化器とプランナーの初期化

ベイズ最適化を実行するための最適化器とプランナーを初期化します。

• optimizer = SequenceGA(algorithm='GA', period=15, design_protocol_filename='design_protocol.yaml'): 遺伝的アルゴリズム（GA）ベースの最適化器を設定しています。algorithm='GA'は遺伝的アルゴリズムを使用することを指定し、period=15はGAの世代数を15に設定しています。design_protocol_filenameで、先ほど定義したデザインプロトコルファイルを指定しています。
• ps = Planner(acq, optimizer): プランナーを初期化しています。プランナーは、獲得関数（acq）と最適化器（optimizer）を組み合わせて、次に評価すべきペプチドを推薦する役割を担います。

STEP 9: Design-Make-Testサイクルの実行

ベイズ最適化のメインループを実行します。

• peptides = seed_library.copy() / pic50_scores = pic50_seed_library.copy(): 評価済みのペプチドとそのpIC50スコアを保持するリストを初期化しています。
• data = [(0, p, s) for p, s in zip(peptides, pic50_scores)]: 後で可視化するためのデータを保存しています。0は初期シードライブラリを表します。
• for i in range(3):: 3回のDMTサイクルを実行します。
  • suggested_peptides, _ = ps.recommend(peptides, pic50_scores.reshape(-1, 1), batch_size=96): プランナーが、既存のデータ（peptidesとpic50_scores）に基づいて、次に評価すべき96個のペプチドを推薦します。ベイズ最適化のアルゴリズムが、獲得関数と最適化器を使って最適なペプチドを選び出します。
  • pic50_suggested_peptides = lpe.score(suggested_peptides): 推薦された各ペプチドをPSSMマトリックスで評価し、pIC50スコアを計算します。
  • peptides = np.concatenate([peptides, suggested_peptides]) / pic50_scores = np.concatenate(...): 新しいデータを既存のリストに追加します。
  • best_idx = np.argmin(pic50_scores): これまでに見つかった最良のペプチドのインデックスを取得します（スコアが最小のもの）。
  • best_seq = peptides[best_idx] / best_pic50 = pic50_scores[best_idx]: 最良のペプチド配列とその結合スコアを表示します。

DMTサイクルの流れ（詳しく）

1. Design（設計）フェーズ

何をしているか？

• ガウス過程モデルが、これまでに評価した全てのペプチドのデータを分析
• 「どのような特徴を持つペプチドが良いスコアを出すか」を学習
• 獲得関数が、この学習結果を基に「次に試すべき96個のペプチド」を選ぶ

具体例:

学習したパターン:
- 位置1にH（ヒスチジン）があるとスコアが良い
- 位置4にE（グルタミン酸）があるとスコアが良い
- 位置9にV（バリン）があるとスコアが良い
→ これらの特徴を組み合わせたペプチドを推薦

2. Make（生成）フェーズ

何をしているか？

• 推薦されたペプチド配列を準備
• デザインプロトコルに基づいて、化学的に妥当なペプチドのみを生成
• フィルターで、実用的でないペプチドを除外

注意: このノートブックでは、ペプチド配列は既に生成されているため、このステップは自動的に行われます。

3. Test（評価）フェーズ

何をしているか？

• 推薦された96個のペプチドを、LinearPeptideEmulatorで評価
• 各ペプチドの結合スコア（pIC50）を取得

実際の使用では:

• ここで実際のラボ実験を実行します
• 分子ドッキング、結合アッセイなど

4. 更新フェーズ

何をしているか？

• 新しい96個のデータを、既存のデータに追加
• ガウス過程モデルを更新（新しいデータで再学習）
• これまでに見つかった最良のペプチドを記録

学習の進化:

サイクル1: 96個のデータで学習 → 次の96個を選ぶ
サイクル2: 192個のデータで学習（より正確に！） → 次の96個を選ぶ
サイクル3: 288個のデータで学習（さらに正確に！） → 次の96個を選ぶ

STEP 10: 結果の可視化

最適化の進行状況を可視化します。

• df = pd.DataFrame(data=data, columns=('iter', 'polymer', 'exp_value')): 保存したデータをPandasのDataFrameに変換します。
• df['iter'] = df['iter'].replace({0: 'Init.', 1: '1', 2: '2', 3: '3'}): イテレーション番号を文字列に変換します（'Init.'は初期シードライブラリを表します）。
• sns.lineplot(...): 各イテレーションでのpIC50スコアの平均と95%信頼区間を可視化します。これにより、最適化が進行するにつれてpIC50スコアが改善（減少）するかを確認できます。
• 最終結果の表示: 最適化の完了後、最良のペプチド配列（HELM形式）とその結合スコア（pIC50スコア）を表示します。また、評価したペプチドの総数も表示されます。

結果の可視化

実行が完了すると、各イテレーションでのpIC50スコアの分布が可視化されます。グラフから、最適化が進行するにつれてpIC50スコアが改善（減少）していく様子が確認できます。

また、各イテレーションの終了時に、これまでに見つかった最良のペプチドとそのスコアが表示されます。最終結果として、以下のような出力が得られます。

============================================================
最適化結果のサマリー
============================================================
最良のペプチド配列（HELM形式）: PEPTIDE1{F.M.M.E.D.I.F.R.V}$$$$V2.0
pIC50スコア: -0.709
（スコアが低いほど結合親和性が高い）
評価したペプチドの総数: 384
初期シードライブラリ: 96
DMTサイクルで評価したペプチド: 288
============================================================

これは、HELM形式で表現された最良のペプチド配列と、そのpIC50スコア（-0.335）を示しています。pIC50スコアは低いほど結合親和性が高く、初期のリードペプチドから大幅に改善されていることがわかります。

最後に

mobiusとベイズ最適化を活用したペプチド最適化、いかがでしたでしょうか。

数千にも及ぶ大規模な仮想ペプチドライブラリの中から、わずか数回のDMTサイクルで最も結合親和性が高いと予測されるペプチド配列を効率的に見つけ出すことができました。

全ての仮想ライブラリを網羅的に計算することは、膨大な実験リソースと時間が必要となり現実的ではありません。しかし、ベイズ最適化は初期の限られたデータからAIが学習し、次に試すべき最適なペプチドを予測することで、リソースを大幅に節約しながら、有望なペプチドに素早くたどり着くための強力な探索手法となります。

ぜひ皆さんもmobiusとベイズ最適化を組み合わせ、効率的なインシリコ創薬に取り組んでみてください！

参考文献

• mobius Documentation
• mobius GitHub Repository
• Eberhardt, J., Lees, A., Lill, M., & Schwede, T. (2024). Combining Bayesian optimization with sequence- or structure-based strategies for optimization of protein-peptide binding. ChemRxiv. https://doi.org/10.26434/chemrxiv-2023-b7l81-v2

License: Apache-2.0

【この記事のまとめ】

創薬研究者やバイオインフォマティクスエンジニアに向けて、インシリコ創薬ツール「FEgrow」と能動学習（アクティブラーニング）を組み合わせ、膨大な化学空間から有望な化合物を最小限の計算リソースで効率的に探索する手法を解説します。

• FEgrowによる分子設計と評価の自動化：足場分子（スキャフォールド）に対して多様なリンカーや置換基を結合させ、ドッキングシミュレーションを通じて結合親和性を評価するプロセスを習得できます。
• アクティブラーニングによるスクリーニングの高速化：全ての化合物候補を評価するのではなく、機械学習が「次に評価すべき化合物」を自律的に判断することで、計算時間を大幅に短縮しつつ高活性化合物へ到達する方法を紹介します。
• Google Colab/ローカル環境での実践ワークフロー：ライブラリのインストールから、SARS-CoV-2 Mproを標的とした具体的なチュートリアルコードの実行手順まで、即座に業務・研究へ応用できる形で網羅しています。

この記事を読むことで、計算コストの壁を突破し、限られた時間内でより高品質なリード化合物を特定するための高度なスクリーニング戦略を実装できるようになります。

FEgrowとは？

FEgrowは、フラグメント分子（足場となる小さな分子）に、多様なリンカーや置換基（R-groups）を結合させることで、官能基を置換した化合物ライブラリを仮想的に構築し、その中から有望な化合物を効率的に設計・評価するためのツールです。

今回は、FEgrowのチュートリアルをフォローします。

新型コロナウイルスのメインプロテアーゼ（SARS-CoV-2 Mpro）を標的とした仮想的な化学空間（Chemical Space）から、予測される結合親和性（pK）を最適化する化合物を優先的に選定する過程を追っていきます。

アクティブラーニング（Active Learning）とは？

アクティブラーニング（AL）は、機械学習の一種で、「学習データが不足している状況下で、どのデータ（化合物）を優先的に評価すれば、最も効率よくモデルの精度を高められるか？」を自律的に判断する手法です。

創薬研究におけるALの役割は以下の通りです。

1. 初期評価（ランダムサンプリング）: まず少数の化合物をランダムに選び、その結合親和性を計算（評価）します。
2. モデル構築: 評価結果を基に、未評価の化合物群のスコア（結合親和性）を予測する機械学習モデルを構築します。
3. 情報量に基づく選択: モデルの予測結果から、「最もスコアが高そう」または「予測の不確実性が高く、評価すればモデルが大きく改善しそう」な化合物を、優先的に選択します。
4. 再評価と学習: 選択した化合物を実際に評価し、その結果をモデルにフィードバック（学習）させることで、モデルの予測精度を向上させます。

このサイクルを繰り返すことで、全化合物を評価せずとも、最終的に目的とする**高性能な化合物（高い結合親和性を持つ化合物）に効率よくたどり着くことが可能になります。

FEgrowは、このALの仕組みを、化合物の設計・ドッキング評価プロセスに組み込むことを可能にしています。

環境構築

installationの資料はこちら。

以下をターミナルで打ちます。

# Miniforge3インストーラをダウンロード
# uname コマンドでOSとアーキテクチャ名を取得し、適切なファイル名を構築
curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
# Miniforge3をインストール
bash Miniforge3-$(uname)-$(uname -m).sh
# 👇ここからconda環境を初期化・設定
# Condaの初期設定を行うためのフックを現在のシェルセッションにロード
# /home/shizuku/miniforge3/ はMiniforge3のインストール先ディレクトリに合わせる
eval "$(/home/shizuku/miniforge3/bin/conda shell.bash hook)"
# bashシェルでcondaコマンドを適切に動作させるために初期化設定をシェル設定ファイル（例: ~/.bashrc）に書き込む
conda init bash
# シェル設定ファイル（.bashrc）を再読み込みし、上記の設定を現在のセッションに反映
source ~/.bashrc
# 👇ここからFEgrowのセットアップ
# FEgrowリポジトリをクローン（作業ディレクトリはどこでも可）
git clone https://github.com/cole-group/FEgrow.git
# クローンしたディレクトリに移動
cd FEgrow
# mamba（condaの高速版）を使って、environment.ymlファイルに基づいて仮想環境を作成
mamba env create -f environment.yml
# 作成した仮想環境 'fegrow' をアクティベート
conda activate fegrow
# FEgrowパッケージを依存関係なしでインストール（開発モードや、環境ファイルが依存関係を処理済みのため）
# 最後のピリオド '.' はカレントディレクトリ（FEgrowのルート）にあるセットアップファイルを参照
pip install --no-deps .

• curl: URLからデータを転送するためのコマンドラインツール。
• -L: リダイレクトを辿る（GitHubの「latest」リンクに対応するため）。
• -O: ダウンロードしたファイルを、リモートファイル名と同じ名前で現在のディレクトリに保存する。
• $(uname) と $(uname -m): OS名（例: Linux, Darwin）とアーキテクチャ名（例: x86_64, arm64）をコマンド実行時に動的に取得し、適切なインストーラファイル名を構築する。 | | bash Miniforge3-$(uname)-$(uname -m).sh | Miniforge3のインストール。ダウンロードしたシェルスクリプトを実行し、Miniforge3をインストールする。 | | eval "$(/home/shizuku/miniforge3/bin/conda shell.bash hook)" | Condaの初期設定を現在のシェルセッションにロード。condaコマンドを一時的に利用可能にするための設定（フック）を現在のセッションに適用する。miniforge3のインストールパスは環境によって異なる可能性があります。 | | conda init bash | Condaの永続的な初期設定。condaコマンドを次回以降のシェル起動時にも使えるように、使用しているシェル設定ファイル（~/.bashrcなど）に設定を書き込む。 | | source ~/.bashrc | 設定ファイルの再読み込み。conda init bashで書き込まれた設定を現在のシェルセッションに反映させるために、設定ファイル（ここでは.bashrc）を再読み込みする。 | | git clone https://github.com/cole-group/FEgrow.git | リポジトリのクローン。指定されたURLからFEgrowのGitリポジトリを現在のディレクトリにダウンロードする。 | | cd FEgrow | ディレクトリの移動。クローンして作成されたFEgrowディレクトリに移動する。 | | mamba env create -f environment.yml | 仮想環境の作成。mamba（condaの高速な実装）を使用して、environment.ymlファイルに記述されている依存関係（パッケージ）を持つ仮想環境を作成する。 | | conda activate fegrow | 仮想環境の有効化。新しく作成されたfegrowという名前の仮想環境を現在のシェルセッションでアクティブにする。これにより、その環境内のPythonやパッケージが使えるようになる。 | | pip install --no-deps . | パッケージのインストール。カレントディレクトリ（.）にあるPythonパッケージ（FEgrow自体）をインストールする。
• pip: Pythonのパッケージ管理システム。
• --no-deps: 依存関係のチェックとインストールをスキップする（既にmamba env createで依存関係が処理されているため）。
• .: カレントディレクトリを参照し、setup.pyまたはpyproject.tomlに基づいてパッケージをインストールする。 |

クローンしてきたFEgrowのtutorialsの2_tutorial_active_learning.ipynb　をcursorで開き、一つずつrunしてください。

cursorでのjupyter環境の設定は以下をご覧ください。

 環境構築｜【完全版】In silico創薬実践書 〜おうち創薬で論文を書こう〜

FEgrowによるアクティブラーニングの実行

全コードはこちらを参考にしています。一部うまくいかなかった部分があるので、少し変更しています。チュートリアルとほぼ一緒ですが、GPUは使用しておりません。gnina_gpu =False にして実行しています。

# ----------------------------------------------------
# STEP 1: 準備と環境設定
# ----------------------------------------------------
# 必要なライブラリをインポート
import prody # タンパク質（受容体）の操作・解析用ライブラリ
from rdkit import Chem # 分子構造（化学）の操作用ライブラリ
import fegrow # 分子の拡張とドッキング（結合予測）を行う中心ライブラリ
# fegrow内の主要なクラスをインポート
from fegrow import ChemSpace, Linkers, RGroups
from fegrow.al import Model, Query # Active Learning（能動学習）のモデルとクエリをインポート
rgroups = RGroups() # 利用可能なRグループ（置換基）のコレクションを準備
linkers = Linkers() # 利用可能なリンカー（つなぎ）のコレクションを準備
# DaskのLocalClusterを設定し、計算を並列化（複数のCPUコアで同時に実行）できるようにする
from dask.distributed import LocalCluster
lc = LocalCluster(processes=True, n_workers=None, threads_per_worker=1)
# create the chemical space (化学空間、つまり作成する可能性のある分子の集合) を作成
cs = ChemSpace(dask_cluster=lc) # Daskクラスターと関連付ける
cs
# turn on the caching in RAM (optional)
# 計算結果をメモリ（RAM）にキャッシュし、処理を速くする（任意）
cs.set_dask_caching()
# ----------------------------------------------------
# STEP 2: 足場分子とターゲットタンパク質の準備
# ----------------------------------------------------
# 足場（コアとなる分子骨格）の構造ファイル（.sdf）を読み込む
init_mol = Chem.SDMolSupplier("sarscov2/5R83_core.sdf", removeHs=False)[0]
# rdkitのMolオブジェクトをfegrow特有のRMol形式に変換
scaffold = fegrow.RMol(init_mol)
# 足場の2D画像を表示（idx=Trueで原子番号を表示、サイズを指定）
scaffold.rep2D(idx=True, size=(500, 500))
# specify the attachment point (in this case hydrogen atom number 6)
# どこに新しい部分をつなぐか（ここでは原子番号6の水素の位置）を指定
attachmentid = 6
# 接続ポイント（原子番号6）の原子をダミー原子（原子番号0、通常は'*'）に置き換える
scaffold.GetAtomWithIdx(attachmentid).SetAtomicNum(0)
cs.add_scaffold(scaffold) # 処理した足場を化学空間に追加
# load the receptor structure
# ターゲットタンパク質（受容体）の構造ファイル（.pdb）を読み込む
sys = prody.parsePDB("sarscov2/5R83_final.pdb")
# remove any unwanted molecules
# 受容体から核酸、ヘテロ原子（cofactorなど）、水分子を除外して純粋なタンパク質を抽出
rec = sys.select("not (nucleic or hetatm or water)")
# save the processed protein
# 処理済みのタンパク質を新しいファイルに保存
prody.writePDB("rec.pdb", rec)
# fix the receptor file (missing residues, protonation, etc)
# 受容体ファイルに残基の欠損修正やプロトン化状態の調整などを行う
fegrow.fix_receptor("rec.pdb", "rec_final.pdb")
cs.add_protein("rec_final.pdb") # 最終的な受容体（タンパク質）を化学空間に追加
# ----------------------------------------------------
# STEP 3: 化学空間の構築（分子候補の網羅的な作成）
# ----------------------------------------------------
numlinkers = 50 # 試すリンカーの数
numrgroups = 50 # 試すRグループの数
# 指定された数のリンカーとRグループの全ての組み合わせを作成し、化学空間に追加する
for i in range(numlinkers): if i % 10 == 0: print(i) # 進行状況を10個ごとに表示 for j in range(numrgroups): # リンカー[i]とRグループ[j]を組み合わせて化学空間に分子の候補を追加 cs.add_rgroups(linkers.Mol[i], rgroups.Mol[j])
# The chemical space now includes our 2500 small molecules:
# 化学空間に分子候補の総数（50x50=2500）が追加された
cs
# 化学空間の最初の分子（cs[0]）の2D構造を表示
cs[0].rep2D()
# ----------------------------------------------------
# STEP 4: 能動学習（Active Learning）の初期評価
# ----------------------------------------------------
# Pick 50 random molecules
# Active Learning（能動学習）の最初のステップとして、ランダムに50個の分子を選ぶ
random1 = cs.active_learning(50, first_random=True)
# now evaluate the first selection, note that dask is used to parallelise the calculation
# 選ばれた50個の分子に対してドッキングシミュレーションを実行
# daskが並列計算を行う
# molecules that cannot be built assigned a predicted affinity of 0
# gnina_gpu=Falseに変更 (GPUを使わずにCPUでgninaを実行することを指定)
random1_results = cs.evaluate( random1, num_conf=50, gnina_gpu=False, penalty=0.0, al_ignore_penalty=False
)
random1_results # 結果（ドッキングスコアなど）を表示
# スコア（計算値）がある（NaNではない）分子だけを抽出
computed = cs.df[~cs.df.score.isna()]
print("Computed cases in total: ", len(computed)) # 計算された分子の総数を表示
# ----------------------------------------------------
# STEP 5: AIモデルの学習と最適分子の選択
# ----------------------------------------------------
# チュートリアルにはない部分。付け足しました。
# gninaのパスを明示的に設定
import os
from pathlib import Path
# 現在のディレクトリのgninaバイナリを設定（セキュリティや環境依存性のため）
gnina_path = os.path.abspath("gnina")
if os.path.exists(gnina_path): fegrow.RMol.set_gnina(gnina_path) # gnina実行ファイルの場所をfegrowに教える print(f"gnina path set to: {gnina_path}")
else: # gninaが見つからない場合はメッセージを表示 print(f"gnina not found at: {gnina_path}") print("Available files in current directory:") for f in os.listdir("."): if "gnina" in f.lower(): print(f" - {f}")
# AIの学習モデルとしてガウス過程を設定
cs.model = Model.gaussian_process()
# 分子選択の戦略としてUCB (Upper Confidence Bound) を設定（探索と利用のバランスをとる）
cs.query = Query.UCB(beta=1)
# gnina_gpu=Falseでないとうまくいかない。 # 環境によってはGPUの使用がうまくいかないため、CPUに固定する
for cycle in range(3): # 能動学習のプロセスを3回繰り返す print(f"Starting cycle {cycle + 1}/3...") # 現在のサイクル数を表示 try: # AIモデルと選択戦略に基づいて、次に計算すべき最適な50個の分子を選ぶ picks = cs.active_learning(50) print(f"Selected {len(picks)} molecules for evaluation") # 選ばれた分子数を表示 # 選ばれた50個の分子をドッキングシミュレーションで評価 picks_results = cs.evaluate( picks, num_conf=50, gnina_gpu=False, penalty=0.0, al_ignore_penalty=False # num_conf=50: 分子の立体構造（コンフォメーション）を50個生成して試す # gnina_gpu=False: GNINAをCPUで実行するように指定 ) # save the new results # 今回の結果をサイクルごとに異なるCSVファイルに保存 picks_results.to_csv(f"notebook_iteration{cycle}_results.csv") print(f"Cycle {cycle + 1} completed successfully. Results saved to notebook_iteration{cycle}_results.csv") except Exception as e: # エラーが発生した場合、メッセージを表示し、次のサイクルへ進む print(f"Error in cycle {cycle + 1}: {str(e)}") print("Continuing with next cycle...") continue
cs.model = Model.gaussian_process() # Active Learning（能動学習）のモデルとしてガウス過程を設定
cs.query = Query.Greedy() # 次に評価する分子の選択戦略としてGreedy（貪欲法）を設定
# モデルを使って予測し、次に計算すべき最適な50個の分子を選ぶ
picks = cs.active_learning(50)
# 選ばれた50個の分子をドッキングシミュレーションで評価
picks_results = cs.evaluate( picks, num_conf=50, gnina_gpu=False, penalty=0.0, al_ignore_penalty=False
)
# save the new results
picks_results.to_csv("notebook_greedy_results.csv") # 結果をCSVファイルに保存
# ----------------------------------------------------
# STEP 6: 結果の統合と上位分子の抽出・保存
# ----------------------------------------------------
# save the chemical space of built molecules:
# 構築された（または構築できなかった）全ての分子を含む化学空間を保存する準備
failed = False
unbuilt = False
# 結果をSDファイル（分子構造とそのプロパティを格納するファイル形式）として書き出す
with Chem.SDWriter("notebook_chemspace.sdf") as SD: # 分子構造以外のプロパティ（スコア、成功フラグなど）の列名リストを作成 columns = cs.df.columns.to_list() columns.remove("Mol") # 化学空間内の全ての行（分子候補）をループ処理 for i, row in cs.df.iterrows(): # ignore this molecule because it failed during the build # 構築に失敗した分子をスキップする設定（failed=Falseなのでスキップしない） if failed is False and row.Success is False: continue # ignore this molecule because it was not built yet # 未構築の分子をスキップする設定（unbuilt=Falseなので、SuccessがFalseならスキップしない） if unbuilt is False and not row.Success: continue mol = row.Mol # RDKit Molオブジェクトを取得 mol.SetIntProp("index", i) # 元のインデックスをプロパティとして設定 for column in columns: # 各プロパティをMolオブジェクトに設定 value = getattr(row, column) mol.SetProp(column, str(value)) mol.ClearProp("attachement_point") # 不要なプロパティをクリア SD.write(mol) # SDファイルに分子構造とプロパティを書き込む
# save the structures of the top 10 molecules in ranked order as a sdf file:
# ドッキングスコアの高い上位10個の分子を保存する処理
molecules = []
input_sdf = "notebook_chemspace.sdf" # 保存したSDファイル
best_n = 10 # 上位10個
with Chem.SDMolSupplier(input_sdf) as SDF: # for each mol # 保存したSDファイルから分子を一つずつ読み込む for mol in SDF: if mol is None: # 読み込めなかったらスキップ continue # 構築に成功した分子('Success'プロパティが'True')のみをリストに追加 if mol.GetPropsAsDict()["Success"] == "True": molecules.append(mol)
# sort by the key
# 分子リストを、プロパティの'score'の値（ドッキングスコア）で降順（reverse=True、高いスコアが先）にソート
sorted_molecules = sorted( molecules, key=lambda m: m.GetPropsAsDict()["score"], reverse=True
)
# ソートされた分子の上位10個を新しいSDファイルに書き出す
with Chem.SDWriter(f"top_{best_n:d}_{input_sdf}") as SDF_OUT: for i, mol in enumerate(sorted_molecules): if i == best_n: # 10個書き出したら終了 break SDF_OUT.write(mol)
print("Done") # 処理完了を通知

全体の流れ：AIを使った新しい薬の候補探し

このコードは、既存の薬の骨格をベースに、AI（機械学習）を使って、ターゲットタンパク質に最もよく結合するであろう新しい分子（薬の候補）を効率的に見つけ出すという、創薬研究のプロセスをシミュレーションしています。

プロセスは以下のステップで進行します。

• 準備と分子設計（Step 1〜3）:
  • 必要なツールを準備し、PCの並列処理環境を立ち上げます。
  • 薬のコア骨格とターゲットタンパク質を読み込み、シミュレーション用に加工します。
  • コア骨格に50種のリンカーと50種のRグループを組み合わせ、2,500個の分子候補（化学空間）を作成します。
• 初期評価（Step 4）:
  • 作成した分子候補からランダムに50個を選び出し、ドッキングシミュレーション（結合予測）を実行してスコアを計算します。これはAIが学習するための最初のデータセットとなります。
• AI学習と最適化（Step 5）:
  • 初期評価の結果を元に、AIモデル（ガウス過程）が学習します。
  • AIは学習結果に基づき、「次に計算すれば最も良いスコアが出そう」と予測した最適な50個の分子を選び出し、再度シミュレーションを実行します。
• 結果の統合と抽出（Step 6）:
  • 全ての分子の構造と評価スコアを一つのファイルに統合して保存します。
  • 最終的に、全分子の中からドッキングスコアが最も高い上位10個の分子を抜き出し、最終ファイルとして保存します。

STEP 1: 準備と環境設定

シミュレーションを行うための道具の準備と、計算を効率化するための設定を行います。

• import prody / from rdkit import Chem / import fegrow: タンパク質操作のProDy、分子構造操作のRDKit、そして創薬シミュレーションの中心となるfegrowという専門的なツールキットをプログラムに組み込んでいます。
• from fegrow import ChemSpace, Linkers, RGroups:fegrowから、分子リストの管理者(ChemSpace)、部品カタログのデータ(Linkers, RGroups)といった、主要な機能を呼び出せるようにしています。
• rgroups = RGroups() / linkers = Linkers(): Rグループとリンカーの**利用可能なリスト（部品カタログ）**を、プログラム内で実際に使える形に初期化しています。
• lc = LocalCluster(...):Daskというライブラリを使い、あなたのPCの複数のCPUコアを計算に使えるようにするための**並列処理チーム（LocalCluster）**を立ち上げています。これにより、計算が速くなります。
• cs = ChemSpace(dask_cluster=lc): これから作る全ての分子の構造やスコアを管理するメインのワークシート（化学空間）を作成し、並列処理チーム（lc）と連携させています。
• cs.set_dask_caching(): 計算結果をメモリに一時保存し、同じ計算を省略することで処理を高速化する設定を有効にしています。

STEP 2: 足場分子とターゲットタンパク質の準備

新しい薬のコアとなる骨格と、結合させるターゲット（受容体）をシミュレーションに適した形に加工し、登録します。

• init_mol = Chem.SDMolSupplier("...")[0]: 薬のコア骨格（足場）の構造ファイル（.sdf）を読み込みます。

• scaffold = fegrow.RMol(init_mol): 読み込んだ分子データを、fegrow専用の構造形式（RMol）に変換しています。

• scaffold.rep2D(idx=True, size=(500, 500)): 足場分子の2D構造図を、原子番号付きで表示します。

  

• attachmentid = 6: 新しい部品をつなげる場所として、原子番号6の原子を指定しています。

• scaffold.GetAtomWithIdx(attachmentid).SetAtomicNum(0): 指定した結合点（原子番号6）を、ダミー原子（'*'）という**「ここに部品をつなぐ目印」**に置き換えています。

• cs.add_scaffold(scaffold): 加工済みの足場分子を化学空間（cs）に登録します。

• sys = prody.parsePDB("..."): 薬が結合するターゲットタンパク質の構造データ（.pdbファイル）を読み込みます。

• rec = sys.select("not (nucleic or hetatm or water)"): タンパク質構造から、核酸、水、不純物といったシミュレーションに不要なものを取り除いています。

• fegrow.fix_receptor("rec.pdb", "rec_final.pdb"): 一時ファイル（rec.pdb）に対し、欠損修正やプロトン化を行い、最終的な受容体ファイル（rec_final.pdb）を作成しています。

• cs.add_protein("rec_final.pdb"): 最終調整を終えたターゲットタンパク質を化学空間（cs）に登録し、シミュレーションの準備を完了します。

• attachmentid = 6: 新しい部品をつなげる場所として、原子番号6の原子を指定しています。

• scaffold.GetAtomWithIdx(attachmentid).SetAtomicNum(0): 指定した原子（原子番号6）を、「ここに部品をつなぐ」という**目印（ダミー原子）**に置き換えています。H:6に様々な官能基を伸ばしていくという設定を行っています。

• cs.add_scaffold(scaffold): 処理を終えた足場分子を、化学空間（ワークシートcs）に登録します。

• sys = prody.parsePDB("..."): ターゲットタンパク質（受容体）の構造データ（.pdbファイル）を読み込みます。

• rec = sys.select("not (nucleic or hetatm or water)"): タンパク質の構造から、核酸、水分子、不純物（hetatm）などのシミュレーションに不要なものを取り除き、純粋なタンパク質を選び出しています。

• fegrow.fix_receptor("rec.pdb", "rec_final.pdb"): 選出したタンパク質構造に対し、欠損部分の補完やプロトン化状態の調整などを行い、シミュレーションに適した最終ファイル（rec_final.pdb）を作成しています。

• cs.add_protein("rec_final.pdb"): 最終的に準備されたターゲットタンパク質を、化学空間（cs）に登録します。

STEP 3: 化学空間の構築（分子候補の網羅的な作成）

足場に全ての部品の組み合わせを適用し、総勢2,500個の分子候補を作成します。

• numlinkers = 50 / numrgroups = 50: 使用するリンカーとRグループの数をそれぞれ50個に設定しています。

• for i in range(...) / for j in range(...):二重ループを使い、50個のリンカーと50個のRグループの**全ての組み合わせ（50×50＝2,500通り）**を順に処理する指示です。

  

• cs.add_rgroups(linkers.Mol[i], rgroups.Mol[j]): ループで選ばれた特定のリンカーとRグループを足場につなげた新しい分子候補を、化学空間（cs）に登録しています。

  

• cs[0].rep2D(): 作成された分子候補リストの最初の分子の2D構造を表示し、正しく分子が構築されているかを確認します。

  

STEP 4: 能動学習（Active Learning）の初期評価

AIに学習させるための初期データを収集するため、ランダムに分子を選んでシミュレーションを実行します。

• random1 = cs.active_learning(50, first_random=True): 能動学習の初期段階として、ランダムに50個の分子を選び出します。
• random1_results = cs.evaluate(random1, ...): 選ばれた50個の分子について、ドッキングシミュレーション（結合予測）を実行し、スコアを計算しています。gnina_gpu=FalseはCPUでの計算を意味します。

以下のような出力になります。長い出力です。公式のマークダウンを合わせて参考にしてください。

• random1_results: 計算が完了した初期評価の結果（スコアなどが含まれる表形式のデータ）を表示しています。

• computed = cs.df[~cs.df.score.isna()]:スコアが計算できた（NaNではない）分子だけを抽出し、計算が成功した数を数えています。

STEP 5: AIモデルの学習と最適分子の選択

初期データでAIが学習し、次に試すべき最適な分子を選び出して最終評価を行います。

• fegrow.RMol.set_gnina(gnina_path): ドッキングシミュレーションに使うGNINAというプログラムがどこにあるか（パス）をfegrowに明示的に設定しています。
• cs.model = Model.gaussian_process(): 能動学習のためのAIの学習モデルとして、ガウス過程という予測手法を設定しています。
• cs.query = Query.UCB(beta=1)
  • Queryは、次にどの分子を評価するかを決める戦略（クエリ戦略）を設定しています。
  • UCB（Upper Confidence Bound：上限信頼限界）は、「探索（Exploration）」と「利用（Exploitation）」という2つの行動をバランス良く行うための戦略です。
    • 利用: AIが「この分子はスコアが高そう（良い結果が得られそう）」と予測する分子を選ぶことです。
    • 探索: AIが「この分子のことはよくわからない（不確実性が高い）」と判断する分子を、予測スコアに関わらず選ぶことです。
  • UCB戦略は、「予測スコア＋不確実性の幅」が大きい分子を選びます。これにより、単に予測スコアが高い分子だけでなく、まだ情報が少なく「もしかしたらすごく良い分子かもしれない」未知の領域にも積極的に挑戦できます。
• cs.query = Query.Greedy(): AIが次に試す分子を選ぶ際の戦略として、Greedy（貪欲法）（最も期待値の高いものを選択する戦略）を設定しています。
• picks = cs.active_learning(50): AIが予測した結果に基づき、「最も高いスコアが出そう」な最適な50個の分子を選び出します。
• picks_results = cs.evaluate(picks, ...): AIが選んだ50個の分子に対し、再度ドッキングシミュレーションを実行してスコアを計算します。
• picks_results.to_csv("notebook_greedy_results.csv"): 2回目の評価結果を、CSVファイルとして保存しています。

STEP 6: 結果の統合と上位分子の抽出・保存

全ての分子のデータを整理し、最も優秀な分子を抽出して最終ファイルとして保存します。

• with Chem.SDWriter("notebook_chemspace.sdf") as SD:: 全ての分子の構造と評価結果を記録するためのSDファイルの書き出しを開始します。
• for i, row in cs.df.iterrows():: ワークシート（cs.df）にある全分子を一つずつ処理するためのループです。
• mol.SetProp(column, str(value)): 分子の構造データに対し、計算で得られたスコアや成功/失敗フラグなどの情報を**プロパティ（付箋）**として書き込んでいます。
• SD.write(mol): 情報が付加された分子構造をSDファイルに書き込み、全分子のデータ統合を完了させています。
• best_n = 10: 最終的に抽出する上位分子の数を10個に設定しています。
• if mol.GetPropsAsDict()["Success"] == "True":: 構築に成功した分子だけを選び出すための条件です。
• sorted_molecules = sorted(molecules, key=lambda m: ..., reverse=True): 成功した分子のリストを、ドッキングスコア（score）が高い順に並び替えています。
• with Chem.SDWriter(f"top_{best_n:d}_...") as SDF_OUT:: 並び替えたリストの上位10個の分子だけを、新しいSDファイルとして書き出し、最終的な成果物として保存しています。
• print("Done"): すべての処理が完了したことを知らせるメッセージです。

結果の可視化

もともとのタンパク質と出力されたtop_10_notebook_chemspace.sdf　をpymolにドラック＆ドロップして表示されると上位10個の結合力の高い化合物が表示されます。右下の再生ボタンを押せば各分子の結合の様式がわかります。

最後に

FEgrowとアクティブラーニング（AL）を活用したシミュレーション、いかがでしたでしょうか。

数千にも及ぶ大規模な仮想ライブラリの中から、わずか数回のサイクルで最も結合親和性が高いと予測される化合物を効率的に見つけ出すことができました。

全ての仮想ライブラリを網羅的に計算することは、膨大な計算リソースと時間が必要となり現実的ではありません。しかし、ALは初期の限られたデータからAIが学習し、次に試すべき最適な分子を予測することで、リソースを大幅に節約しながら、有望な化合物に素早くたどり着くための強力な探索手法となります。

ぜひ皆さんもFEgrowとアクティブラーニングを組み合わせ、効率的なインシリコ創薬に取り組んでみてください！

参考文献

GitHub – cole-group/FEgrow: An Open-Source Molecular Builder and Free Energy Preparation Workflow

License: MIT, Apache-2.0