---
title: 'LD-FPG: Latent Diffusion for Protein Dynamics'
url: https://www.emergentmind.com/topics/ld-fpg
type: topic
---

# LD-FPG: Latent Diffusion for Protein Dynamics

Searching arXiv for LD-FPG and closely related latent-space protein dynamics papers.
to=arxiv_search.search  北京赛车能  大发快三豹子on  彩神争霸怎么json
{"query":"LD-FPG latent diffusion full protein generation all-atom protein dynamics latent space", "max_results": 10, "sort_by": "relevance"}【อ่านข้อความเต็มjson
{"results":[{"arxiv_id":"2506.17064","title":"Generative Modeling of Full-Atom Protein Conformations using Latent Diffusion on Graph Embeddings","authors":["I. Alawneh","R. Van de Vreken","A. Taly","L. P. Cordi","J. M. François","A. Heifetz","Y. Ollivier","L. Pardo","D. Fourches","M. Degiacomi"],"abstract":"Generating diverse, all-atom conformational ensembles of dynamic proteins such as G-protein-coupled receptors (GPCRs) is critical for understanding their function, yet most generative models simplify atomic detail or ignore conformational diversity altogether. We present latent diffusion for full protein generation (LD-FPG), a framework that constructs complete all-atom protein structures, including every side-chain heavy atom, directly from molecular dynamics (MD) trajectories. LD-FPG employs a Chebyshev graph neural network (ChebNet) to obtain low-dimensional latent embeddings of protein conformations, which are processed using three pooling strategies: blind, sequential and residue-based. A diffusion model trained on these latent representations generates new samples that a decoder, optionally regularized by dihedral-angle losses, maps back to Cartesian coordinates. Using D2R-MD, a 2-microsecond MD trajectory (12 000 frames) of the human dopamine D2 receptor in a membrane environment, the sequential and residue-based pooling strategy reproduces the reference ensemble with high structural fidelity (all-atom lDDT of approximately 0.7; C-alpha-lDDT of approximately 0.8) and recovers backbone and side-chain dihedral-angle distributions with a Jensen-Shannon divergence of less than 0.03 compared to the MD data. LD-FPG thereby offers a practical route to system-specific, all-atom ensemble generation for large proteins, providing a promising tool for structure-based therapeutic design on complex, dynamic targets. The D2R-MD dataset and our implementation are freely available to facilitate further research.","published":"2025-06-20","categories":["physics.bio-ph","q-bio.BM","cs.LG"]},{"arxiv_id":"2509.02196","title":"Beyond Ensembles: Simulating All-Atom Protein Dynamics in a Learned Latent Space","authors":["I. Alawneh","R. Van de Vreken","A. Taly","L. P. Cordi","J. M. François","A. Heifetz","Y. Ollivier","D. Fourches","M. Degiacomi"],"abstract":"Simulating the long-timescale dynamics of biomolecules is a central challenge in computational science. While enhanced sampling methods can accelerate these simulations, they rely on pre-defined collective variables that are often difficult to identify. A recent generative model, LD-FPG, demonstrated that this problem could be bypassed by learning to sample the static equilibrium ensemble as all-atom deformations from a reference structure, establishing a powerful method for all-atom ensemble generation. However, while this approach successfully captures a system's probable conformations, it does not model the temporal evolution between them. Here we extend LD-FPG with a temporal propagator that operates within the learned latent space and compare three classes: (i) score-guided Langevin dynamics, (ii) Koopman-based linear operators, and (iii) autoregressive neural networks. Within a unified encoder-propagator-decoder framework, we evaluate long-horizon stability, backbone and side-chain ensemble fidelity, and functional free-energy landscapes. Autoregressive neural networks deliver the most robust long rollouts; score-guided Langevin best recovers side-chain thermodynamics when the score is well learned; and Koopman provides an interpretable, lightweight baseline that tends to damp fluctuations. These results clarify the trade-offs among propagators and offer practical guidance for latent-space simulators of all-atom protein dynamics.","published":"2025-09-02","categories":["q-bio.BM","physics.bio-ph","cs.LG"]},{"arxiv_id":"2408.04920","title":"New Approaches to Molecular Dynamics Simulations in Long Timescales: A Review","authors":["Piotr Niewiadomski","Jadwiga Juraszek"],"abstract":"Molecular dynamics (MD) simulations are powerful tools for understanding the behavior of molecular systems at the atomic level. However, their application is often limited by the accessible simulation timescales, typically reaching up to microseconds, while many biologically relevant processes occur on significantly longer timescales, in the millisecond to second range. To address this challenge, various enhanced sampling methods have been developed, each with distinct advantages and limitations. This review focuses on recent advancements in molecular dynamics techniques for extending simulation timescales, providing a critical overview of methods such as coarse-grained simulations, metadynamics, milestoning, Markov state models, weighted ensemble approaches, and diffusion maps. Particular attention is given to their practical implementation and suitability for modeling complex biomolecular processes such as protein folding, ligand binding, and conformational transitions.","published":"2024-08-07","categories":["physics.comp-ph","physics.bio-ph"]},{"arxiv_id":"2406.11268","title":"Koopman-accelerated molecular dynamics: Perspective and prospects","authors":["Enrico Trizio","Alejandro de la Hoz","Yicong Fu","Sergei Izrailev","Alan E. Markland"],"abstract":"Molecular dynamics (MD) simulations are a central tool in computational chemistry, physics, biology, and materials science. However, conventional MD is often unable to access the long timescales necessary to study rare events, conformational transitions, and other phenomena of interest. In recent years, a range of methods based on Koopman operator theory have been proposed to accelerate MD simulations, promising data-driven and interpretable ways to approximate long-timescale dynamics. In this perspective, we review the theoretical foundations of Koopman operator-based approaches, their integration with enhanced sampling, and their prospects for practical simulation workflows.","published":"2024-06-17","categories":["physics.chem-ph"]},{"arxiv_id":"2406.19400","title":"A benchmark study of diffusion generative models on all-atom protein conformational ensembles","authors":["Y. Zhang","L. Shao","R. Wu","L. Zhu","D. H. de Jong","M. Degiacomi"],"abstract":"Understanding the complex dynamics of proteins requires accurate conformational ensembles. Molecular dynamics (MD) simulations provide atomistic detail but are computationally expensive, motivating machine learning approaches that generate realistic all-atom protein ensembles. Recent diffusion-based methods offer promise, but their performance across architectures and training objectives has not been systematically compared. We benchmark diffusion models on multiple proteins and evaluate structural fidelity, ensemble diversity, and thermodynamic consistency, highlighting practical design trade-offs for all-atom ensemble generation.","published":"2024-06-27","categories":["q-bio.BM","physics.bio-ph","cs.LG"]}]}
LD-FPG, short for **latent diffusion for full protein generation**, is a generative framework for learning and sampling **system-specific, all-atom conformational ensembles** of dynamic proteins directly from molecular dynamics (MD) data. In its original form, LD-FPG was introduced to generate **full heavy-atom Cartesian coordinates**, including every side-chain heavy atom, by compressing MD snapshots into a learned latent representation, training a diffusion model in that latent space, and decoding sampled latents back into protein structures [2506.17064]. In subsequent work, the same latent manifold was repurposed for **temporal propagation**, extending LD-FPG from a **static equilibrium ensemble generator** into a **latent-space dynamical simulator** through an encoder–propagator–decoder framework [2509.02196].

## 1. Conceptual scope and problem setting

LD-FPG was introduced to address a specific gap in protein machine learning: many generative models can produce either **single static structures** or **backbone-only ensembles**, but do not reliably generate **full-atom, side-chain-resolved conformational ensembles** for a specific dynamic protein [2506.17064]. The method is explicitly designed to learn the **conformational landscape of one protein from molecular dynamics data**, then sample new latent conformations and decode them back into **all heavy-atom Cartesian coordinates**.

The motivating application is dynamic proteins such as G-protein-coupled receptors (GPCRs), where **side-chain packing and dihedral distributions** are essential for function, allostery, and ligand recognition. In this setting, LD-FPG is not framed as a general structure predictor in the AlphaFold sense. Rather, it is a system-specific ensemble model that learns deformations relative to a reference structure. The paper states that this is important because proteins are functional not only by adopting a fold, but by populating the right **torsional states**, including backbone \((\phi,\psi)\) and side-chain \((\chi)\) angles.

Within the broader methodological landscape, LD-FPG is situated in the family of **latent-space simulation / enhanced sampling** methods that replace explicit coordinate-space simulation with a learned low-dimensional representation that is easier to sample and model. The later dynamical extension explicitly places LD-FPG alongside **CV-learning methods like TICA, VAMPnets, VDE, and SPIB**, **latent-space molecular simulators**, **Koopman/DMD-based dynamical embeddings**, and **score-based / diffusion generative models that approximate equilibrium distributions or effective forces** [2509.02196]. A central distinguishing feature is that LD-FPG learns an **all-atom equilibrium latent manifold without hand-crafted CVs**.

## 2. Structural representation and encoder–decoder design

The original LD-FPG pipeline begins by representing each MD frame as a graph
$$
G^{(t)}=(V,E^{(t)}),
$$
where \(V\) denotes heavy atoms, \(N=|V|\), and node features are coordinates
$$
X^{(t)}\in \mathbb{R}^{N\times 3}.
$$
Edges are built on-the-fly by **k-nearest neighbors** on aligned coordinates, with \(k=4\). Before graph construction, coordinates are rigidly aligned to the first frame using **Kabsch alignment** so that the model learns **internal conformational changes** rather than rigid-body motion [2506.17064].

The encoder \(\Theta\) is a **4-layer ChebNet** spectral graph convolution network that maps each conformation to atom-wise latent embeddings
$$
Z^{(t)} \in \mathbb{R}^{N \times d_z}.
$$
The convolution is given as
$$
H^{(l+1)} = \sigma\!\Bigl(\sum_{k=0}^{K-1} \Theta^{(l)}_{k}\,T_k(\tilde{L})\,H^{(l)}\Bigr),
$$
with \(H^{(0)} = X^{(t)}\), \(K=4\), and a scaled graph Laplacian \(\tilde L\). The appendix details four ChebConv layers, **LeakyReLU** in the first two layers, **ReLU** in the third, **BatchNorm1d** after each ChebConv, and final **L2-normalization per atom**. The encoder is pretrained with a coordinate reconstruction objective so that the latent code preserves enough information to reconstruct coordinates [2506.17064].

The decoder does not generate structures in an unconstrained manner. Instead, it predicts deformations relative to a reference conformation. The reference is the **first aligned frame** of the trajectory, and the conditioning signal is not raw Cartesian coordinates but a **reference latent embedding**
$$
C = \Theta^*(X_{\text{ref}},E_{\text{ref}}),
$$
where \(\Theta^*\) is the frozen pretrained encoder. The paper reports that conditioning on latent reference embeddings is significantly better than conditioning on raw Cartesian coordinates, interpreting the latent reference embedding as a more compact and useful summary of geometry and connectivity [2506.17064].

This representation choice is important for understanding LD-FPG’s scope. The model is trained to generate **deformations from a reference fold**, not arbitrary protein topologies. A common misconception is therefore to treat LD-FPG as a generic protein generator. The cited work instead presents it as a framework for **ensemble generation at atomic resolution** for a specific protein system.

## 3. Pooling strategies, latent diffusion, and decoding

After atom-wise encoding, LD-FPG compresses \(Z^{(t)}\) into a pooled latent representation \(\mathbf h_0\) on which a **DDPM** is trained [2506.17064]. Three pooling strategies are defined.

| Strategy | Latent organization | Reported characterization |
|---|---|---|
| Blind pooling | One global pooled latent vector | Best global fold performance; can blur fine side-chain detail |
| Sequential pooling | Two-stage latent organization for backbone then side chain | Strong balance of backbone geometry and side-chain realism |
| Residue-based pooling | Per-residue pooled latents | Especially good at side-chain rotamer distributions and functional landscape coverage |

In **blind pooling**, all atom latents are globally compressed into one context vector \(\mathbf h_{\text{global}}\in\mathbb R^{d_p}\), tiled across atoms, concatenated with the conditioner \(C\), and mapped to coordinates with a shared MLP. The main configuration uses \(d_z=16\), \(H=50\), \(W=2\), \(d_p=100\), hidden size 128, and 12 layers.

In **sequential pooling**, the protein is predicted in two stages: a **backbone decoder** followed by a **side-chain decoder**. Backbone atom embeddings \(Z_{\text{bb}}\) are pooled and decoded first; side-chain predictions are then conditioned on the predicted backbone and additional context. The main setup uses \(d_z=8\), with backbone pooled to \(45 \times 3 = 135\), side chains pooled to \(54 \times 2 = 108\), and **arch-type 1**.

In **residue-based pooling**, atom latents are pooled **per residue**. Each atom receives the pooled vector of its parent residue and combines it with the reference conditioner in an atom-wise coordinate predictor. The main residue-pooling setup uses \(d_z=4\) and \(d_p=4\) per residue; for D2R with 273 residues, this yields an effective latent space of about \(273\times 4 \approx 1092\) dimensions.

The diffusion model is trained on the pooled latent \(\mathbf h_0\) using a standard DDPM forward process,
$$
q(\mathbf{h}_t | \mathbf{h}_{t-1}) = \mathcal{N}\bigl(\mathbf{h}_t; \sqrt{1-\beta_t}\mathbf{h}_{t-1}, \beta_t \mathbf{I}\bigr),
$$
and noise-prediction loss
$$
\mathcal{L}_{\text{diffusion}}(\theta) = \mathbb{E}_{t,\mathbf{h}_0,\epsilon} \left[ \| \epsilon - \epsilon_\theta(\sqrt{\bar{\alpha}_t}\mathbf{h}_0 + \sqrt{1-\bar{\alpha}_t}\epsilon, t) \|^2 \right].
$$
Sampling starts from \(\mathbf h_T\sim\mathcal N(0,I)\) and iteratively denoises. The main denoiser is an MLP, **DiffusionMLP_v2**, with 4 linear layers and ReLU. Typical settings are hidden size 1024 and around 500 diffusion steps for blind and sequential pooling, and larger hidden size around 4096 with often up to 1500 steps for residue pooling.

Decoder training uses coordinate MSE as the base loss. For blind pooling, the paper also explores **dihedral-angle regularization** via dihedral MSE and dihedral distribution divergence. The reported outcome is cautious: these dihedral losses improve dihedral statistics only modestly and slightly reduce coordinate fidelity. This is one of several places where LD-FPG’s evaluation emphasizes trade-offs rather than a uniformly dominant design choice.

## 4. Dataset, evaluation protocol, and equilibrium-ensemble performance

The primary demonstration system for LD-FPG is **D2R-MD**, a molecular dynamics trajectory of the human dopamine D2 receptor [2506.17064]. The system starts from cryo-EM D2R bound to risperidone (**PDB 6CM4**), with ligand removed, **ICL3** remodeled using **RosettaRemodel**, embedding in a **POPC membrane**, solvation with **TIP3P water**, neutralization with **0.15 M NaCl**, force field **CHARMM36m**, and simulation in **GROMACS 2024.2**. Ten independent replicas were run; one representative replica was selected; roughly the first **776 ns** were discarded as equilibration; the remaining analyzed trajectory was about **1.224 μs**; and frames sampled every **100 ps** yielded **12,241 frames**. The abstract summarizes this as a **2 μs human D2 receptor trajectory**. The split is **90% training** and **10% test**, chronologically.

Evaluation covers both reconstruction and generation. The main structural fidelity metrics are **lDDT**, **TM-score**, per-angle **Jensen–Shannon divergence (JSD)** for backbone and side-chain dihedrals, steric clashes under a **2.1 Å** cutoff, PCA of pooled latent space, and the **A100 activation index** for GPCR activation-state coverage.

The encoder reconstruction upper bound is strong. For \(d_z=16\), the encoder achieves **lDDT\(_\text{All} = 0.696\)**, **lDDT\(_\text{BB} = 0.782\)**, **TM\(_\text{All} = 0.959\)**, **\(\sum\)JSD\(_\text{bb} = 0.00009\)**, and **\(\sum\)JSD\(_\text{sc} = 0.00016\)**. This establishes the encoder as a high-fidelity latent compressor.

When decoder quality is isolated by reconstructing from ground-truth latents, **blind pooling** at \(d_z=16\) yields **lDDT\(_\text{All} = 0.714\)**, **lDDT\(_\text{BB} = 0.792\)**, and **\(\sum\)JSD\(_\text{sc} = 0.0290\)**. **Sequential pooling** at \(d_z=8\) gives **lDDT\(_\text{All} = 0.718\)**, **lDDT\(_\text{BB} = 0.800\)**, and **\(\sum\)JSD\(_\text{sc} = 0.0192\)**, which the paper identifies as the best backbone geometry among the main decoders. **Residue pooling** at \(d_z=4\) gives **lDDT\(_\text{All} = 0.704\)**, **lDDT\(_\text{BB} = 0.777\)**, and **\(\sum\)JSD\(_\text{sc} = 0.0125\)**, the best side-chain distributional fidelity among the decoders.

For full diffusion generation, the reported results continue this division of labor. **Blind pooling** reaches **lDDT\(_\text{All} = 0.719\)**, **TM\(_\text{All} = 0.964\)**, **\(\sum\)JSD\(_\text{sc} = 0.04185\)**, and average clashes **1350.5**. **Sequential pooling** achieves **lDDT\(_\text{All} = 0.712\)**, **lDDT\(_\text{BB} = 0.801\)**, **TM\(_\text{All} = 0.942\)**, **\(\sum\)JSD\(_\text{sc} = 0.02895\)**, and clashes **1220.5**. **Residue pooling** gives **lDDT\(_\text{All} = 0.6880\)**, **TM\(_\text{All} = 0.9570\)**, **\(\sum\)JSD\(_\text{sc} = 0.0224\)**, and clashes **1145.6**. The paper summarizes the best cases by stating that the sequential and residue-based pooling strategies reproduce the reference ensemble with **all-atom lDDT of approximately 0.7**, **C-alpha-lDDT of approximately 0.8**, and backbone and side-chain dihedral-angle distributions with **JSD of less than 0.03**.

Functionally, LD-FPG is also evaluated on landscape coverage. Generated latent distributions cover the main regions of the MD latent space, especially for sequential and residue pooling. On the GPCR **A100 activation index**, blind and sequential pooling track the main D2R distribution reasonably well, while residue pooling recovers both primary and subtler states more comprehensively. The paper additionally notes that **BioEmu** failed to match the D2R-specific A100 distribution well, emphasizing the value of **system-specific training**.

## 5. Extension to latent-space dynamics

A key limitation of the original LD-FPG formulation is that it is primarily an **ensemble sampler**: it can represent the distribution of likely conformations, but does **not** explicitly model how one conformation evolves into another over time. This limitation motivates the later extension that keeps the LD-FPG encoder and decoder fixed and inserts a learned **propagator** in the latent space [2509.02196].

The resulting encoder–propagator–decoder pipeline is
$$
X(t) \xrightarrow{\text{encoder}} z(t) \xrightarrow{\text{propagator}} z(t+\Delta t) \xrightarrow{\text{decoder}} \hat X(t+\Delta t),
$$
with \(X(t)\in\mathbb R^{N\times 3}\), \(z(t)\in\mathbb R^d\), and a one-frame latent stride. Dynamics are modeled with the general update form
$$
z_{t+1} = f(z_t) + \eta_t,
$$
where \(f\) is the learned latent propagator and \(\eta_t\) is stochastic noise, typically Gaussian. The encoder remains the pre-trained LD-FPG **ChebNet** encoder, and the paper does not retrain the encoder or decoder; the propagator is isolated so that all comparisons occur in the same learned latent manifold.

Three propagator classes are compared.

The first is **score-guided Langevin dynamics**, which evolves the latent state in an effective potential of mean force \(U(z)\). The paper uses the pre-trained LD-FPG diffusion denoiser \(\epsilon_\theta(z_\tau,\tau)\) to estimate the score \(s(z)=\nabla_z \log p(z)\), yielding the practical update
$$
z_{i+1} = z_i + Th\, s(z_i) + \sqrt{2Th}\,\eta_i, \qquad \eta_i\sim\mathcal N(0,I).
$$
For numerical stability, long rollouts use **score clipping**, capping \(\|s(z_i)\|\).

The second is a **Koopman-based linear operator**,
$$
z_{t+1}\approx A z_t,
$$
fit by Dynamic Mode Decomposition / EDMD from snapshot matrices \(\mathbf X\) and \(\mathbf Y\) as
$$
A=\mathbf{Y}\mathbf{X}^{+},
$$
with \(\mathbf X^+\) computed using truncated SVD at a rank \(r\) chosen by an energy threshold, for example **95%**. Rollouts follow
$$
\hat z_{t+1}=A\hat z_t+\eta_t.
$$

The third is an **autoregressive neural network**, a multilayer perceptron \(f_\theta\) trained with one-step MSE,
$$
\mathcal{L}(\theta)=\frac{1}{M-1}\sum_{t=0}^{M-2}\|f_\theta(z_t)-z_{t+1}\|^2,
$$
and rolled out autoregressively with optional noise. The network uses fully connected layers, ReLU activations, and dropout.

Evaluation spans three axes: **long-horizon stability**, **equilibrium ensemble fidelity**, and **functional free-energy landscapes**. Long-horizon stability is measured by **RMSD** and **lDDT** over rollout time, with failure time defined as the first frame where lDDT relative to the initial frame falls below **0.65**. Ensemble fidelity uses free-energy maps in backbone \((\phi,\psi)\) and, for GPCRs, side-chain \((\chi_1,\chi_2)\) space, with **Jensen–Shannon divergence** and **RMSF**. Functional GPCR motion is evaluated through TM3–6 and TM3–7 distance projections.

The main findings are sharply differentiated. **Autoregressive neural networks** deliver the most robust **long-horizon rollouts**, giving the longest stable trajectories overall and, for **A1AR**, completing the full **10,000-frame rollout without failure**. **Score-guided Langevin** is best when the target is **equilibrium thermodynamics**, especially **side-chain rotamer distributions**; on GPCRs it achieves the lowest side-chain JSD, but is more sensitive to score quality, diffusion-model calibration, and step size. **Koopman** provides an interpretable, lightweight baseline that is linear, efficient, and relatively stable, but tends to **damp fluctuations**, underestimate variance, and blur multimodal structure.

System-specific conclusions follow the same pattern. For **alanine dipeptide**, all methods recover the main Ramachandran basins, with the neural network best matching basin shape and Langevin weakest due to early instability. For **A1AR**, the neural network gives the best backbone fidelity and the longest rollouts, while Langevin is best for side-chain rotamers. For **A2AR**, the same qualitative pattern holds. For functional GPCR motion, the neural-network and Langevin propagators both recover the main low-free-energy valley associated with activation, while Koopman captures the basin center but tends to over-smooth barriers and anisotropy.

## 6. Significance, limitations, and methodological implications

LD-FPG is significant because it makes **all-atom ensemble generation** a latent generative modeling problem rather than a hand-engineered collective-variable problem. In the original formulation, its practical implications are stated in terms of **structure-based drug design**, **allosteric conformational ensembles**, **GPCR activation mechanisms**, and the generation of **protein ensembles rather than single snapshots** [2506.17064]. For membrane receptors such as GPCRs, where active and inactive states differ subtly and side-chain motions can control signaling, this emphasis on ensemble-level atomic detail is central rather than incidental.

At the same time, the literature is explicit about scope limitations. LD-FPG is **system-specific** and trained on MD trajectories of a single target rather than across broad structural classes. It generates structures as **deformations relative to a reference structure**, which constrains it to a learned manifold tied to the observed system. Training is nontrivial: the appendix reports roughly **15,000 GPU-hours** for ML work and around **30,000 GPU-hours** total including preliminaries [2506.17064]. Residue pooling, while strong on side-chain realism and landscape diversity, is described as more difficult to train and often needing multi-epoch checkpoint sampling to show full diversity.

The dynamical extension further clarifies that a good latent representation does not by itself solve the simulation problem. The paper’s central message is that **the latent representation is only half of the simulation problem: the choice of propagator determines whether the model is best viewed as a sampler, a stable dynamical surrogate, or a thermodynamically grounded local simulator** [2509.02196]. This statement also resolves a common misunderstanding: original LD-FPG should not be treated as a temporal simulator simply because it is trained on MD frames. It learns the **static equilibrium geometry of the conformational landscape**, not the **temporal dynamics** on that landscape.

A plausible implication is that future work on LD-FPG will continue to separate two design questions that are often conflated: how to learn a latent manifold that preserves all-atom structural thermodynamics, and how to propagate trajectories on that manifold without sacrificing stability, variance, or local thermodynamic fidelity. The cited works already suggest that no single propagator uniformly dominates: the neural network is the strongest long-rollout surrogate, score-guided Langevin is the most thermodynamically grounded local sampler when the score is well learned, and Koopman remains the cleanest linear baseline.

Source: https://www.emergentmind.com/topics/ld-fpg