viennarna-structure-prediction

ViennaRNA による構造予測

概要

ViennaRNA は、熱力学的な最近接塩基対パラメーターに基づく RNA 二次構造予測のゴールドスタンダードのツールキットです。指定された RNA 配列の最小自由エネルギー（MFE）構造とドットブラケット表記を予測し、塩基対確率を得るために全分配関数を計算するとともに、共折りたたみや二本鎖予測を通じて RNA-RNA 相互作用をモデル化します。Python バインディング（import RNA）では、配列レベルおよび fold-compound API を備えた ViennaRNA C ライブラリ全体を利用できます。コマンドラインプログラム（RNAfold、RNAalifold、RNAduplex）も利用でき、ここで紹介します。

使用する場面

• RNA 配列（mRNA、lncRNA、miRNA 前駆体、アプタマー）の最小自由エネルギー二次構造を予測する場合
• 塩基対確率行列を計算し、構造の不確実性を評価して、明確に定まったステムループを特定する場合
• 標的 mRNA 領域を折りたたみ、二本鎖構造の有無を確認して、siRNA のアクセス可能性を設計または評価する場合
• 標的への作用を弱める可能性があるガイド RNA の二次構造を予測し、sgRNA の標的効率を評価する場合
• miRNA と標的の結合やアンチセンスオリゴヌクレオチドの設計に向けて、RNA-RNA 相互作用（共折りたたみまたは二本鎖予測）をモデル化する場合
• 配列セットの折りたたみ自由エネルギーを計算し、熱力学的安定性を比較する場合
• Mfold アルゴリズムによる予測が必要な場合や Efold 分配関数が必要な場合は、代わりに mfold（ウェブサーバー）または RNAstructure を使用してください。ViennaRNA は Turner 2004 の最近接塩基対パラメーターを使用しており、研究レベルの熱力学予測における標準です

前提条件

• Python パッケージ：ViennaRNA（Python バインディング）、matplotlib、numpy
• データ要件：文字列形式の RNA 配列（ACGU アルファベット。T は ViennaRNA によって自動的に U に変換されます）
• 環境：Python 3.8 以降。conda によるインストールを強く推奨します（C ライブラリの依存関係を処理します）

# Install via conda (recommended)
conda install -c conda-forge -c bioconda viennarna

# Verify installation
python -c "import RNA; print(RNA.__version__)"
# 2.6.4

# Install additional Python dependencies
pip install matplotlib numpy pandas

# Optional: verify CLI tools are available
RNAfold --version
# RNAfold 2.6.4

クイックスタート

import RNA

# Predict MFE structure for an RNA sequence
sequence = "GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUCUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCACCA"
structure, mfe = RNA.fold(sequence)

print(f"Sequence:  {sequence}")
print(f"Structure: {structure}")
print(f"MFE:       {mfe:.2f} kcal/mol")
# Sequence:  GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUCUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCACCA
# Structure: (((((((..((((........)))).(((((.......))))).....(((((.......))))))))))))....
# MFE:       -31.30 kcal/mol

ワークフロー

ステップ 1：配列の準備と MFE の折りたたみ

RNA 配列を読み込み、RNA.fold() を使用して最小自由エネルギー二次構造を計算します。入力を検証し、ドットブラケット出力を確認します。

import RNA

def prepare_sequence(seq: str) -> str:
    """Normalize sequence: uppercase, replace T→U, validate alphabet."""
    seq = seq.upper().replace("T", "U").strip()
    invalid = set(seq) - set("ACGUNX")
    if invalid:
        raise ValueError(f"Invalid characters in sequence: {invalid}")
    return seq

# E. coli tRNA-Phe (GenBank: M10217)
raw_seq = "GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUCUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCACCA"
sequence = prepare_sequence(raw_seq)

structure, mfe = RNA.fold(sequence)

print(f"Sequence length: {len(sequence)} nt")
print(f"Structure:       {structure}")
print(f"MFE:             {mfe:.2f} kcal/mol")

# Validate: structure length must equal sequence length
assert len(structure) == len(sequence), "Structure and sequence length mismatch"

# Count stems (paired bases)
n_paired   = structure.count("(") + structure.count(")")
n_unpaired = structure.count(".")
print(f"Paired bases: {n_paired}  |  Unpaired bases: {n_unpaired}")
print(f"Stem fraction: {n_paired/len(sequence):.2f}")

ステップ 2：高度な解析用の Fold Compound の作成

RNA.fold_compound オブジェクトは、分配関数、塩基対確率、制約付き折りたたみを扱う中心的な API です。

import RNA

sequence = "GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUCUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCACCA"

# Create fold compound (wraps the sequence with model parameters)
fc = RNA.fold_compound(sequence)

# Compute MFE structure via the fold compound API
structure, mfe = fc.mfe()
print(f"MFE structure: {structure}")
print(f"MFE:           {mfe:.2f} kcal/mol")

# Evaluate free energy of an alternative structure
alt_structure = "." * len(sequence)   # fully unfolded
energy = fc.eval_structure(alt_structure)
print(f"Fully unfolded energy: {energy:.2f} kcal/mol")
print(f"Folding stabilization:  {energy - mfe:.2f} kcal/mol")

ステップ 3：分配関数と塩基対確率

熱力学的分配関数を計算して、アンサンブルレベルの塩基対確率を取得します。確率の高い塩基対は、明確に定まった構造要素を示します。

import RNA
import numpy as np

sequence = "GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUCUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCACCA"
n = len(sequence)

fc = RNA.fold_compound(sequence)

# Step 1: MFE folding (required before pf for proper initialization)
structure_mfe, mfe = fc.mfe()

# Step 2: Rescale Boltzmann factors for numerical stability (optional but recommended)
fc.exp_params_rescale(mfe)

# Step 3: Compute partition function
structure_pf, gibbs_free_energy = fc.pf()
print(f"Gibbs free energy (ensemble): {gibbs_free_energy:.2f} kcal/mol")
print(f"MFE structure:  {structure_mfe}")
print(f"Centroid (pf):  {structure_pf}")

# Step 4: Retrieve base pair probability matrix
bpp = fc.bpp()   # returns (n+1)x(n+1) matrix; 1-indexed

# Convert to 0-indexed numpy array for analysis
probs = np.zeros((n, n))
for i in range(1, n + 1):
    for j in range(i + 1, n + 1):
        if bpp[i][j] > 0.0:
            probs[i - 1][j - 1] = bpp[i][j]
            probs[j - 1][i - 1] = bpp[i][j]

# Identify high-confidence pairs (p > 0.9)
high_conf = [(i, j, probs[i, j]) for i in range(n) for j in range(i + 1, n) if probs[i, j] > 0.9]
print(f"\nHigh-confidence base pairs (p > 0.9): {len(high_conf)}")
for i, j, p in high_conf[:5]:
    print(f"  {sequence[i]}{i+1} — {sequence[j]}{j+1}: p={p:.3f}")

ステップ 4：塩基対確率行列の可視化

塩基対確率行列をヒートマップとしてプロットし、構造領域を可視化します。

import RNA
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors

sequence = "GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUCUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCACCA"
n = len(sequence)

fc = RNA.fold_compound(sequence)
structure_mfe, mfe = fc.mfe()
fc.exp_params_rescale(mfe)
fc.pf()
bpp = fc.bpp()

# Build matrix
probs = np.zeros((n, n))
for i in range(1, n + 1):
    for j in range(i + 1, n + 1):
        if bpp[i][j] > 0.0:
            probs[i - 1][j - 1] = bpp[i][j]
            probs[j - 1][i - 1] = bpp[i][j]

fig, ax = plt.subplots(figsize=(8, 7))
im = ax.imshow(probs, cmap="hot_r", vmin=0, vmax=1, origin="upper", aspect="equal")
plt.colorbar(im, ax=ax, label="Base pair probability")

ax.set_xlabel("Nucleotide position")
ax.set_ylabel("Nucleotide position")
ax.set_title(f"Base Pair Probability Matrix\n(n={n} nt, MFE={mfe:.2f} kcal/mol)")
plt.tight_layout()
plt.savefig("bpp_matrix.png", dpi=150, bbox_inches="tight")
print("Saved: bpp_matrix.png")

ステップ 5：RNA-RNA 二本鎖予測（共折りたたみ）

RNA.cofold() を使用して、2 つの RNA 配列を & 区切り文字で連結し、その相互作用を予測します。

import RNA

# miRNA (hsa-miR-21-5p) and its target sequence in mRNA (PTEN 3'UTR region)
mirna_seq  = "UAGCUUAUCAGACUGAUGUUGA"
target_seq = "UCAACAUCAGUCUGAUAAGCUA"   # approximate complementary target

# Co-fold: concatenate with & separator
cofold_seq = mirna_seq + "&" + target_seq
structure, mfe = RNA.cofold(cofold_seq)

print(f"miRNA:          {mirna_seq}")
print(f"Target:         {target_seq}")
print(f"Co-fold MFE:    {mfe:.2f} kcal/mol")

# Parse the structure — & is retained in output
n1, n2 = len(mirna_seq), len(target_seq)
struct_mirna  = structure[:n1]
struct_ampersand = structure[n1]
struct_target = structure[n1 + 1:]

print(f"miRNA structure:  {struct_mirna}")
print(f"Target structure: {struct_target}")

paired_in_duplex = struct_mirna.count("(") + struct_mirna.count(")")
print(f"Bases paired across the duplex: {paired_in_duplex}")

ステップ 6：siRNA 設計に向けた RNA アクセス可能性の解析

より長い mRNA 配列内にある標的領域のアクセス可能性を計算します。これは siRNA やアンチセンスオリゴヌクレオチドの効率にとって重要です。

import RNA
import numpy as np

def compute_accessibility(mrna_seq: str, window: int = 40) -> list:
    """
    Compute per-position probability of being unpaired (accessible) using
    a sliding-window approach on the partition function.
    Returns list of (position, accessibility) tuples.
    """
    n = len(mrna_seq)
    fc = RNA.fold_compound(mrna_seq)
    _, mfe = fc.mfe()
    fc.exp_params_rescale(mfe)
    fc.pf()
    bpp = fc.bpp()

    # Probability of being paired at each position
    p_paired = np.zeros(n)
    for i in range(1, n + 1):
        for j in range(1, n + 1):
            if i != j:
                p = bpp[min(i,j)][max(i,j)]
                p_paired[i - 1] += p

    p_unpaired = 1.0 - np.clip(p_paired, 0, 1)
    return p_unpaired

# Example: 80-nt mRNA segment with a known accessible region
mrna = "AUGCUAGCUAGCUAGCUAUGCUAGCUAGCUUUUUUUUUUUUAUGCUAGCUAGCUAGCUAGCUAGCUAGCUAGCUAGC"
p_unpaired = compute_accessibility(mrna)

import matplotlib.pyplot as plt
fig, ax = plt.subplots(figsize=(10, 3))
ax.bar(range(1, len(mrna) + 1), p_unpaired, color="#2166ac", alpha=0.8)
ax.axhline(0.5, color="red", lw=1, ls="--", label="50% unpaired")
ax.set_xlabel("Position (nt)")
ax.set_ylabel("P(unpaired)")
ax.set_title("RNA Accessibility Profile")
ax.legend()
plt.tight_layout()
plt.savefig("rna_accessibility.png", dpi=150, bbox_inches="tight")
print("Saved: rna_accessibility.png")

# Top 5 most accessible positions (siRNA target candidates)
best = sorted(enumerate(p_unpaired, 1), key=lambda x: -x[1])[:5]
print("\nMost accessible positions:")
for pos, prob in best:
    print(f"  Position {pos}: P(unpaired) = {prob:.3f}  ({mrna[pos-1]})")

ステップ 7：コマンドライン版 RNAfold と出力の解析

RNAfold CLI を使用して subprocess 経由で一括折りたたみを実行し、その後、出力を解析します。

# Fold a single sequence from stdin
echo "GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUCUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCACCA" | RNAfold

# Output:
# GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUCUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCACCA
# (((((((..((((........)))).(((((.......))))).....(((((.......)))))))))))).... (-31.30)

# Batch fold from FASTA file
RNAfold < sequences.fasta > structures.txt

# Generate base pair probability dot plot (PostScript)
RNAfold --noPS < sequences.fasta   # suppress PostScript output
RNAfold -p < sequences.fasta       # save dot plot as rna.ps

# Python: run RNAfold via subprocess and parse output
import subprocess
import re

def run_rnafold(sequence: str) -> tuple:
    """Run RNAfold CLI and return (structure, mfe) tuple."""
    result = subprocess.run(
        ["RNAfold", "--noPS"],
        input=sequence,
        capture_output=True, text=True, timeout=30
    )
    if result.returncode != 0:
        raise RuntimeError(f"RNAfold failed: {result.stderr}")

    lines = result.stdout.strip().split("\n")
    # Last line: structure and energy, e.g. "((....)) (-5.40)"
    match = re.match(r"^([.()\[\]{}<>|]+)\s+\((-?\d+\.\d+)\)$", lines[-1])
    if not match:
        raise ValueError(f"Could not parse RNAfold output: {lines[-1]}")
    structure = match.group(1)
    mfe       = float(match.group(2))
    return structure, mfe

sequences = [
    ("tRNA-Phe", "GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUCUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCACCA"),
    ("miR-21",   "UAGCUUAUCAGACUGAUGUUGA"),
]

for name, seq in sequences:
    struct, mfe = run_rnafold(seq)
    print(f"{name}: {mfe:.2f} kcal/mol  |  {struct}")

ステップ 8：制約付き折りたたみとサブオプティマル構造

ハード制約（特定の塩基対を強制または禁止）を適用し、サブオプティマル構造を列挙します。

import RNA

sequence = "GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUCUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCACCA"

# --- Constrained folding: force specific pairs ---
fc = RNA.fold_compound(sequence)

# Add hard constraint: force positions 1-7 to be paired (known stem)
hc = RNA.hc_add_bp(fc, 1, 72)  # force pair between position 1 and 72 (0-indexed in C API)
structure_c, mfe_c = fc.mfe()
print(f"Constrained MFE:   {mfe_c:.2f} kcal/mol")
print(f"Constrained struct: {structure_c}")

# --- Enumerate suboptimal structures (delta_mfe threshold) ---
fc_sub = RNA.fold_compound(sequence)
_, mfe_opt = fc_sub.mfe()

# Get suboptimal structures within 5 kcal/mol of MFE
delta = 5.0  # kcal/mol window
subopt_list = RNA.subopt(sequence, int(delta * 100))   # energy in 10-cal units
print(f"\nSuboptimal structures within {delta} kcal/mol of MFE:")
print(f"Total suboptimal structures: {len(subopt_list)}")
for s in subopt_list[:3]:
    e = s.energy / 100.0  # convert from 10-cal to kcal/mol
    print(f"  {s.structure}  ({e:.2f} kcal/mol)")

主要なパラメーター

パラメーター	デフォルト	範囲／オプション	効果
sequence (RNA.fold)	—	ACGU 文字列	入力 RNA 配列です。T は自動的に U に変換されます
temperature (model detail)	37.0 °C	0–100 °C	フォールディング温度です。温度が低いほど構造が安定します
dangles (model detail)	2	0、1、2、3	ダングリング末端の処理です。2 は平均、0 はなしを意味します。ほとんどの用途では 2 を使用してください
noGU (model detail)	False	True/False	True の場合、G-U ワブル塩基対を許可しません
noLP (model detail)	False	True/False	孤立した塩基対（1 塩基対のステム）を許可しません。ノイズを低減します
delta (RNA.subopt)	—	float kcal/mol	サブオプティマル構造を列挙する際の、MFE を上回るエネルギー範囲です
window (sliding window)	—	int nt	長い配列のアクセシビリティ解析に使用するスライディングウィンドウのサイズです

よくあるレシピ

レシピ：FASTA ファイルからのバッチ MFE フォールディング

使用する場面：RNA 配列のライブラリ（候補アプタマーやガイド RNA など）をフォールディングし、エネルギーを比較します。

import RNA
from pathlib import Path

def read_fasta(fasta_path: str) -> list:
    """Parse FASTA file, return list of (name, sequence) tuples."""
    records = []
    name, seq = None, []
    for line in Path(fasta_path).read_text().splitlines():
        if line.startswith(">"):
            if name:
                records.append((name, "".join(seq).upper().replace("T", "U")))
            name, seq = line[1:].split()[0], []
        else:
            seq.append(line.strip())
    if name:
        records.append((name, "".join(seq).upper().replace("T", "U")))
    return records

# Example: fold sequences from a FASTA file
sequences = [
    ("aptamer_1", "GGGUUUUGAAACUAAACUAGGCUCUAGCGCUGGUGUCCCUUCCCGGCUCUAGCCUCAGCAGAAGCUUGAAAAAACCC"),
    ("aptamer_2", "GGGAGACAAGAAUAAACGCUCAACGUCUACCAUGAUCGAAUGCUAGCCUUCUAGCUUGCUUCGGCAGCACUAUAGGG"),
    ("aptamer_3", "GGGCGACCCUGAUGAGUCCCAAGUCGAAACGAUUCCUUUUUAAACUCAUGGUGCCCAGCCUCGCUCAGCA"),
]

print(f"{'Name':<15} {'Length':>8} {'MFE':>10} {'Structure'}")
print("-" * 80)
for name, seq in sequences:
    struct, mfe = RNA.fold(seq)
    print(f"{name:<15} {len(seq):>8} {mfe:>10.2f}  {struct[:50]}...")

レシピ：sgRNA の二次構造を確認する

使用する場面：CRISPR sgRNA ガイド配列が、Cas9 の結合効率を低下させる二次構造にフォールディングするかを評価します。

import RNA

def assess_sgrna(guide_seq: str, scaffold: str = None) -> dict:
    """
    Assess sgRNA secondary structure.
    guide_seq: 20-nt spacer sequence (RNA)
    scaffold: constant sgRNA scaffold sequence (default: SpCas9)
    """
    if scaffold is None:
        # SpCas9 sgRNA scaffold (Addgene standard)
        scaffold = "GUUUUAGAGCUAGAAAUAGCAAGUUAAAAUAAGGCUAGUCCGUUAUCAACUUGAAAAAGUGGCACCGAGUCGGUGCUUU"

    full_sgrna = guide_seq.upper().replace("T", "U") + scaffold
    fc = RNA.fold_compound(full_sgrna)
    structure, mfe = fc.mfe()
    fc.exp_params_rescale(mfe)
    fc.pf()
    bpp = fc.bpp()

    n_guide = len(guide_seq)
    # Check if any guide bases are paired (bad for targeting)
    guide_paired = sum(
        bpp[min(i, j)][max(i, j)]
        for i in range(1, n_guide + 1)
        for j in range(1, n_guide + 1)
        if i != j
    )
    guide_accessibility = 1.0 - min(1.0, guide_paired / n_guide)
    return {
        "guide_seq":    guide_seq,
        "mfe":          mfe,
        "structure":    structure[:n_guide],
        "guide_access": guide_accessibility,
        "predicted_ok": guide_accessibility > 0.7,
    }

guides = ["GCACUAGUGACGCAUGGCAC", "GGGCAUAGCUAGCUAGCUAU", "AAAUUCGCACUAGUGACGCA"]
for g in guides:
    result = assess_sgrna(g)
    status = "OK" if result["predicted_ok"] else "WARN (self-paired)"
    print(f"{g}: accessibility={result['guide_access']:.2f}, MFE={result['mfe']:.1f} kcal/mol  [{status}]")

レシピ：RNA 構造のマウンテンプロット可視化

使用する場面：マウンテンプロットを作成します。配列に沿ったステムの高さを示す、RNA 構造の古典的な可視化方法です。

import RNA
import matplotlib.pyplot as plt

def dot_bracket_to_mountain(structure: str) -> list:
    """Convert dot-bracket structure to mountain plot heights."""
    heights = []
    level = 0
    for c in structure:
        if c == "(":
            level += 1
        heights.append(level)
        if c == ")":
            level -= 1
    return heights

sequence = "GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUCUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCACCA"
structure, mfe = RNA.fold(sequence)
heights = dot_bracket_to_mountain(structure)

fig, axes = plt.subplots(2, 1, figsize=(12, 5), sharex=True,
                          gridspec_kw={"height_ratios": [1, 3]})

# Top: sequence text
axes[0].text(0.5, 0.5, "tRNA-Phe  |  E. coli", ha="center", va="center",
             fontsize=10, transform=axes[0].transAxes)
axes[0].axis("off")

# Bottom: mountain plot
axes[1].fill_between(range(len(sequence)), heights, step="mid",
                      color="#2c7bb6", alpha=0.7, label=f"MFE = {mfe:.2f} kcal/mol")
axes[1].set_xlabel("Nucleotide position")
axes[1].set_ylabel("Stem height")
axes[1].set_title("Mountain Plot")
axes[1].legend()
plt.tight_layout()
plt.savefig("mountain_plot.png", dpi=150, bbox_inches="tight")
print(f"Saved: mountain_plot.png  (MFE structure: {structure[:40]}...)")

想定される出力

出力	型	説明
structure	string	MFE 二次構造のドットブラケット表記です。塩基対には ( と )、非対合塩基には . を使用します
mfe	float (kcal/mol)	予測構造の最小自由エネルギーです。値がより負であるほど安定しています
bpp	(n+1)×(n+1) matrix	分配関数から得られる塩基対確率行列です。要素 [i][j] は P(i と j が対合する確率) を表し、インデックスは 1 始まりです
bpp_matrix.png	PNG	塩基対確率のヒートマップ可視化です
rna_accessibility.png	PNG	各位置が非対合である確率です
mountain_plot.png	PNG	配列に沿ったステムの高さを示すマウンテンプロットです

トラブルシューティング

問題	原因	解決策
ImportError: No module named 'RNA'	ViennaRNA の Python バインディングがインストールされていません	conda install -c conda-forge viennarna でインストールしてください。pip install だけでは C ライブラリとのリンクに失敗する場合があります
RuntimeError: RNAfold not found	ViennaRNA CLI が PATH にありません	which RNAfold で確認してください。conda 環境を使用している場合は、スクリプトを実行する前に環境を有効化してください
MFE が予想外に正の値（> 0）です	好ましい塩基対が形成されない非常に短い配列、または反復配列です	短い配列（< 10 nt）では、MFE が正になることがよくあります。配列の長さと組成を確認してください
fc.pf() の後に bpp 行列がすべてゼロになります	同じフォールド化合物に対して、fc.pf() の前に fc.mfe() を呼び出す必要があります	必ず最初に fc.mfe() を呼び出し、次に fc.exp_params_rescale(mfe)、その後に fc.pf() を呼び出してください
サブオプティマル構造の列挙結果が数千件になります	長い配列に対してウィンドウが大きすぎます	長い配列では delta を 2～3 kcal/mol に減らしてください。非常に安定した配列では、サブオプティマル構造の集合が密になります
共フォールディング（RNA.cofold）で予想外の塩基対形成が見られます	一方の鎖では分子内フォールディングが優勢です	まず各鎖を個別に調べてください。個々の鎖の MFE が低い場合、強い自己構造が二本鎖形成を妨げていることを示します

参考資料

• ViennaRNA ドキュメント — 公式ドキュメント、パラメーターファイル、Python API リファレンス
• Lorenz et al., Algorithms Mol Biol 2011 — ViennaRNA Package 2.0 の論文（構造予測の主要な引用文献）
• Turner & Mathews, Nucleic Acids Res 2010 — ViennaRNA で使用される最近接塩基対の熱力学パラメーター
• ViennaRNA GitHub: ViennaRNA/ViennaRNA — ソースコード、課題トラッカー、Python チュートリアルノートブック