Datasets:
File size: 22,067 Bytes
79067a6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 | {
"paper_id": "diffusion-convergence-rate",
"paper_title": "Improved Convergence Rate for Diffusion Probabilistic Models",
"D1": [
{
"id": "diffusion-convergence-rate-D1-001",
"claim": "hat_alpha_{T+1} = 1 / T^{c_0} (Initial schedule point; c_0 is a sufficiently large constant satisfying c_0 >= max{c_R + 10, 10})",
"source": "Section 2.2, Eq (8)"
},
{
"id": "diffusion-convergence-rate-D1-002",
"claim": "hat_alpha schedule update step = c_1 * hat_alpha_t * (1 - hat_alpha_t) * log T / T (Step size for hat_alpha sequence; c_1 > 0 is a sufficiently large constant; c_1 / c_0 ratio must be sufficiently large)",
"source": "Section 2.2, Eq (8)"
},
{
"id": "diffusion-convergence-rate-D1-003",
"claim": "hat_alpha time index range = t = -N/2 + 1, ..., T + 1 (Index range for the schedule construction)",
"source": "Section 2.2, Eq (8)"
},
{
"id": "diffusion-convergence-rate-D1-004",
"claim": "alpha_bar_t randomization = alpha_bar_t ~ Unif(hat_alpha_t, hat_alpha_{t-1}) (Randomized learning rate schedule: each alpha_bar_t is drawn uniformly between consecutive hat_alpha values)",
"source": "Section 2.2, Eq (9)"
},
{
"id": "diffusion-convergence-rate-D1-005",
"claim": "Schedule ratio identity = (hat_tau_{k,n-1} - hat_tau_{k,n}) / (hat_tau_{k,n-1} * (1 - hat_tau_{k,n-1})) = c_1 * log T / T (Key schedule property for discretization analysis; establishes uniform step-size ratio)",
"source": "Section 4, Lemma 7, Eq (50)"
},
{
"id": "diffusion-convergence-rate-D1-006",
"claim": "K (number of rounds) = c_2 * min{d * log^2 T, L * log T}, where c_2 > 0 (Number of outer rounds; balances error propagation; bounded even when L = infinity)",
"source": "Section 3.2, Theorem 1"
},
{
"id": "diffusion-convergence-rate-D1-007",
"claim": "N (steps per round) = 2T / K (Number of inner steps per round; total iteration complexity is KN = 2T)",
"source": "Section 2.2"
},
{
"id": "diffusion-convergence-rate-D1-008",
"claim": "T (total discretization steps) = KN / 2 (Each round has N steps, each requiring 1 new score evaluation; total score evaluations = 2T)",
"source": "Section 2.2"
},
{
"id": "diffusion-convergence-rate-D1-009",
"claim": "N (parallel processors) = (min{d^{2/3} * L^{-2/3}, d^{1/3}} + 1) * log^{5/3} T / epsilon^{2/3} (Required number of parallel processors to achieve epsilon-accuracy in TV distance)",
"source": "Section 3.3, Theorem 2"
},
{
"id": "diffusion-convergence-rate-D1-010",
"claim": "MK (total parallel rounds) = min{d * log T, L} * log^2 T (Required total parallel rounds; achieves O(min{L, d} log^2(Ld/epsilon)) parallel rounds)",
"source": "Section 3.3, Theorem 2"
},
{
"id": "diffusion-convergence-rate-D1-011",
"claim": "M (parallel iterations per round) = >= c * log T, where c is a constant (Inner iterations per parallel round; derived from M * log(N * min{d log T, L} * log T / T) requirement in parallel analysis)",
"source": "Appendix E.2"
},
{
"id": "diffusion-convergence-rate-D1-012",
"claim": "epsilon_score^2 for parallel sampler = <= epsilon^2 * log^{-1} T (Score estimation error requirement for the parallel sampler to achieve epsilon-accuracy)",
"source": "Section 3.3, Theorem 2"
},
{
"id": "diffusion-convergence-rate-D1-013",
"claim": "Second moment bound = E[||X_0||^2] < T^{c_R}, where c_R > 0 is arbitrarily large (Bounded second moment assumption; excludes extremely heavy-tailed distributions decaying slower than 1/x^3)",
"source": "Section 3.1, Assumption 1"
},
{
"id": "diffusion-convergence-rate-D1-014",
"claim": "c_0 lower bound = c_0 >= max{c_R + 10, 10} (Ensures initialization is close enough to Gaussian; ensures KL divergence between p_{X_0} and p_{Y_0} is negligible (<= 1/T^{10}))",
"source": "Section 4, Lemma 5 proof; Appendix D.3, Eq (88)"
},
{
"id": "diffusion-convergence-rate-D1-015",
"claim": "Definition 2 neighborhood radius = C * sqrt(d * (1 - alpha_bar_t) * log T) / L (Radius within which the non-uniform Lipschitz condition must hold with high probability)",
"source": "Section 3.1, Definition 2"
},
{
"id": "diffusion-convergence-rate-D1-016",
"claim": "Definition 2 probability threshold = >= 1 - c / (T + d)^4, where c is a universal constant (The non-uniform Lipschitz condition must hold with this high probability (over x ~ X_t))",
"source": "Section 3.1, Definition 2"
},
{
"id": "diffusion-convergence-rate-D1-017",
"claim": "GMM Lipschitz constant bound = L <= C_1 * log(H * (T + d)), where H is number of Gaussian components (For Gaussian mixture models, the non-uniform Lipschitz constant scales only logarithmically with components H, dimension d, and iterations T)",
"source": "Section 3.1, Example 2"
},
{
"id": "diffusion-convergence-rate-D1-018",
"claim": "Typical set threshold theta = theta >= c_R + 10 (Parameter controlling the typical set S_tau = {x: -log p_{X_tau}(x) <= theta * d * log T}; must be large enough to ensure P(X_tau in S_tau^c) <= 1/T^4)",
"source": "Section 4.1, Eq (21); Appendix D.1, Eq (67) following"
},
{
"id": "diffusion-convergence-rate-D1-019",
"claim": "epsilon_score^2 definition = (1/T) * sum_{k=0}^{K-1} sum_{n=0}^{N-1} E[||s_{T - kN/2 - n + 1}(Y_{k,n}) - s*_{T - kN/2 - n + 1}(Y_{k,n})||^2] (Averaged l2 score estimation error over all steps; treats score matching as a black box; denoted as sum of epsilon_{k,n}^2 over T)",
"source": "Section 3.1, Assumption 2, Eq (12)"
},
{
"id": "diffusion-convergence-rate-D1-020",
"claim": "Experiment configurations = [{'d': 10, 'k': 10}, {'d': 100, 'k': 10}, {'d': 500, 'k': 100}] (Three configurations: d-dimensional Gaussian target with zero mean, diagonal covariance (first k entries uniform in [0,10], remaining d-k entries zero). K = 10 rounds, N = 2T/K. Exact score functions used (no estimation error).)",
"source": "Appendix A, Figure 2"
},
{
"id": "diffusion-convergence-rate-D1-021",
"claim": "K for numerical experiments = 10 (Fixed number of rounds K = 10 across all experiment configurations)",
"source": "Appendix A"
},
{
"id": "diffusion-convergence-rate-D1-022",
"claim": "Diagonal covariance entry range = [0, 10] (uniform distribution) (First k diagonal entries of the Gaussian covariance matrix are uniformly sampled from [0, 10]; remaining d-k entries are zero)",
"source": "Appendix A"
}
],
"D2": [
{
"id": "diffusion-convergence-rate-D2-001",
"claim": "Forward process step: X_t = sqrt(alpha_t) * X_{t-1} + sqrt(1 - alpha_t) * W_t, where W_t ~ N(0, I_d) is independent Gaussian noise, alpha_t in (0,1) is the step size, and t = 1,...,T. The cumulative product is defined as alpha_bar_t := product_{k=1}^{t} alpha_k, giving X_t = sqrt(alpha_bar_t) * X_0 + sqrt(1 - alpha_bar_t) * Wbar_t where Wbar_t ~ N(0, I_d).",
"source": "Section 2.1, Eq (3)"
},
{
"id": "diffusion-convergence-rate-D2-002",
"claim": "Learning rate schedule construction (discrete computable): (1) Set initial point hat_alpha_{T+1} = 1 / T^{c_0} for a sufficiently large constant c_0 >= max{c_R+10, 10}; (2) Iteratively update hat_alpha_{t-1} = hat_alpha_t + c_1 * hat_alpha_t * (1 - hat_alpha_t) * log T / T for t = -N/2+1, ..., T+1, with c_1 > 0 and c_1/c_0 sufficiently large; (3) Randomized schedule: draw alpha_bar_t ~ Unif(hat_alpha_t, hat_alpha_{t-1}) for each t, where hat_alpha_t acts as the deterministic grid. The interval (hat_alpha_t, hat_alpha_{t-1}) defines the discretization subinterval.",
"source": "Section 2.2, Eq (8)-(9)"
},
{
"id": "diffusion-convergence-rate-D2-003",
"claim": "Schedule initialization point: hat_alpha_{T+1} = 1 / T^{c_0}. Schedule update step formula: hat_alpha_{t-1} = hat_alpha_t + c_1 * hat_alpha_t * (1 - hat_alpha_t) * log T / T. The constants c_0 and c_1 are sufficiently large positive constants with c_1/c_0 also sufficiently large. This defines a deterministic grid of points from which the randomized schedule is drawn.",
"source": "Section 2.2, Eq (8)"
},
{
"id": "diffusion-convergence-rate-D2-004",
"claim": "Score function definition (discrete-time): s_t*(x) = ∇log p_{X_t}(x) = -1/(1 - alpha_bar_t) * ∫ p_{X_0|X_t}(x_0|x) * (x - sqrt(alpha_bar_t) * x_0) dx_0. Continuous-index variant: s_tau*(x) = ∇log p_{X_tau}(x) = -1/tau * ∫ p_{X_0|X_tau}(x_0|x) * (x - sqrt(1 - tau) * x_0) dx_0, where X_tau = sqrt(1-tau) * X_0 + sqrt(tau) * Z with Z ~ N(0, I_d). Relationship: s_t*(·) = s_{1-alpha_bar_t}*(·).",
"source": "Section 2.1, Definition 1, Eq (6)-(7)"
},
{
"id": "diffusion-convergence-rate-D2-005",
"claim": "Sampling update equation (the core discrete sampler step, Eq 10). For round k, step n (1 <= n <= N), compute Y_{k,n} from Y_{k,0} using: Y_{k,n} / sqrt(1 - tau_{k,n}) = Y_{k,0} / sqrt(1 - tau_{k,0}) + [s_{T - kN/2 + 1}(Y_{k,0}) / (2 * (1 - tau_{k,0})^{3/2})] * (tau_{k,0} - hat_tau_{k,0}) + sum_{i=1}^{n-1} [s_{T - kN/2 - i + 1}(Y_{k,i}) / (2 * (1 - tau_{k,i})^{3/2})] * (hat_tau_{k,i-1} - hat_tau_{k,i}) + [s_{T - kN/2 - n + 2}(Y_{k,n-1}) / (2 * (1 - tau_{k,n-1})^{3/2})] * (hat_tau_{k,n-1} - tau_{k,n}). Here tau_{k,n} ~ Unif(hat_tau_{k,n}, hat_tau_{k,n-1}), and s_{...} are estimated score functions. Each step uses exactly one new score evaluation.",
"source": "Section 2.2, Eq (10)"
},
{
"id": "diffusion-convergence-rate-D2-006",
"claim": "Noise injection between rounds (Eq 11): After completing N steps in round k, apply Y_{k+1} = sqrt((1 - tau_{k+1,0}) / (1 - tau_{k,N})) * Y_{k,N} + sqrt((tau_{k+1,0} - tau_{k,N}) / (1 - tau_{k,N})) * Z_k, where Z_k ~ N(0, I_d) is independent Gaussian noise. This converts the TV distance between reverse and forward processes into l2 estimation error and ensures the new starting point Y_{k+1} has the correct variance for the next round.",
"source": "Section 2.2, Eq (11)"
},
{
"id": "diffusion-convergence-rate-D2-007",
"claim": "Total variation distance evaluation metric: TV(q_K, p_{Y_K}) = (1/2) * ∫ |p_{Y_K}(x) - q_K(x)| dx, where q_K is the distribution of X_{tau_{K,0}} (forward process at round K start) and p_{Y_K} is the distribution of the sampler output Y_K. The sampler is initialized from Y_0 ~ N(0, I_d) (pure Gaussian noise). The goal is to bound TV(q_K, p_{Y_K}) <= epsilon.",
"source": "Section 2.2, Eq (12)"
},
{
"id": "diffusion-convergence-rate-D2-008",
"claim": "Time-index mapping construction: Given the schedule hat_alpha_t and randomized alpha_bar_t, define hat_tau_{k,n} := 1 - hat_alpha_{T - kN/2 - n} and tau_{k,n} := 1 - alpha_bar_{T - kN/2 - n + 1} for n = -1, ..., N. The randomized tau_{k,n} ~ Unif(hat_tau_{k,n}, hat_tau_{k,n-1}) provides the discretization of continuous time tau in (0,1). The initialization uses hat_tau_{k,0} (deterministic) and tau_{k,0} (randomized), while intermediate steps use hat_tau (deterministic grid points) and the final term uses tau_{k,n} (randomized endpoint).",
"source": "Section 4.3, Eq (33)"
},
{
"id": "diffusion-convergence-rate-D2-009",
"claim": "Score estimation error computation (averaged over all steps): epsilon_score^2 = (1/T) * sum_{k=0}^{K-1} sum_{n=0}^{N-1} E_{Y_k ~ q_k}[||s_{T - kN/2 - n + 1}(Y_{k,n}) - s*_{T - kN/2 - n + 1}(Y_{k,n})||^2] =: (1/T) * sum_{k,n} epsilon_{k,n}^2. This treats score matching as a black box (s_t is the estimated score, s_t* is the true score). Each epsilon_{k,n}^2 is the per-step squared l2 error.",
"source": "Section 3.1, Assumption 2, Eq (12)"
},
{
"id": "diffusion-convergence-rate-D2-010",
"claim": "Non-uniform Lipschitz condition (Definition 2): Let L be the smallest quantity (may depend on T and d) such that P_{x ~ X_t}{(1 - alpha_bar_t) * ||s_t*(x') - s_t*(x)||_2 <= L * ||x' - x||_2, for all ||x' - x||_2 <= C * sqrt(d * (1 - alpha_bar_t) * log T) / L} >= 1 - c / (T + d)^4, where C and c are universal constants. This relaxes the uniform Lipschitz condition by requiring it only within a neighborhood of radius proportional to sqrt(d * (1 - alpha_bar_t) * log T) / L and with probability 1 - c/(T+d)^4 rather than everywhere.",
"source": "Section 3.1, Definition 2"
},
{
"id": "diffusion-convergence-rate-D2-011",
"claim": "GMM Lipschitz constant computable bound: For a Gaussian mixture model X_0 ~ sum_{h=1}^{H} gamma_h * N(mu_h, sigma^2 * I_d) with sigma >= 0, the non-uniform Lipschitz constant satisfies L <= C_1 * log(H * (T + d)) for some universal constant C_1. This means L scales only logarithmically with the number of components H, dimension d, and iterations T. In contrast, the uniform Lipschitz constant for GMMs can be as large as (1 - alpha_bar_t) * ||mu||_2^2 / (4 * (1 - alpha_bar_t + sigma^2)^2) when sigma is small, which can be on the order of d.",
"source": "Section 3.1, Example 2; Appendix C.2, Eq (C.2)"
},
{
"id": "diffusion-convergence-rate-D2-012",
"claim": "Parallel sampling algorithm structure (Appendix E.1): (1) Round structure: K rounds, each with M * N parallel iterations; (2) Each round k: compute initial direction v_{k,0} = Y_{k,0} / sqrt(1 - tau_{k,0}); (3) Inner loop m = 1..M: for n = 0..N-1, compute estimated y_{k,n}^{(m)} using the discrete sampler with estimated score functions, accumulate updates; (4) After M iterations, apply noise injection to get Y_{k+1}; (5) Use parallel processors to compute the N intermediate points simultaneously per inner iteration. The parallel sampler achieves epsilon-accuracy with N processors ~ (min{d^{2/3} * L^{-2/3}, d^{1/3}} + 1) * log^{5/3} T / epsilon^{2/3} and MK rounds ~ min{d * log T, L} * log^2 T.",
"source": "Appendix E.1, Parallel sampling algorithm"
}
],
"D3": [
{
"id": "diffusion-convergence-rate-D3-001",
"claim": "Validate theoretical convergence rate predictions: Verify that the randomized midpoint discretization sampler (Section 2.2, Eq 10) achieves the predicted KL divergence convergence rate of O(log^4 T / T^3), which implies a TV distance rate of O(log^2 T / T^{3/2}). This is a sanity check that the theoretical analysis is consistent with empirical behavior.. Datasets: Synthetic d-dimensional Gaussian. Baselines: {'method': 'Theoretical convergence rate curve', 'description': 'The theoretical prediction O(log^4 T / T^3) in KL divergence. This numerical validation does not compare against any empirical baseline methods (e.g., other samplers) as this is a theoretical convergence-rate analysis focused on validating the analytical convergence rate rather than benchmarking against other algorithms. The theoretical rate curve serves as the sole reference for validating the empirical results.', 'type': 'theoretical_reference'}. Metrics: {'name': 'KL divergence', 'formula': 'KL(p_{Y_K} || q_K)', 'implementation': 'Closed-form computation possible because all intermediate distributions Y_{k,n} remain Gaussian when the target is Gaussian and exact score functions are used'}",
"source": "Appendix A"
},
{
"id": "diffusion-convergence-rate-D3-002",
"claim": "Controlled experimental design for isolating convergence rate from confounds. Purpose: Ensure that any deviation between empirical and theoretical convergence rates is attributable solely to discretization error, not to score approximation error or Monte Carlo estimation noise. Setup: (1) Target distribution is a d-dimensional Gaussian with zero mean and diagonal covariance — this guarantees all intermediate distributions Y_{k,n} in the sampler remain Gaussian, enabling closed-form analytical KL divergence computation without Monte Carlo sampling. (2) Exact score functions s_t*(·) are used (not neural network estimates) — this eliminates score estimation error epsilon_score^2 from the experiment, setting it to zero by construction. (3) The sampler implementation follows Section 2.2 exactly with the randomized midpoint discretization. Metrics: KL divergence computed analytically in closed form using Gaussian distribution identities (no sampling-based estimation). Comparison: This controlled setting contrasts with real-world diffusion model deployments where pretrained score networks introduce non-zero epsilon_score^2 and Monte Carlo estimation adds variance. By zeroing out score error, the experiment isolates and validates the discretization component of the convergence theory.",
"source": "Appendix A"
},
{
"id": "diffusion-convergence-rate-D3-003",
"claim": "Multi-configuration dimensional sensitivity analysis. Purpose: Test whether the O(log^4 T / T^3) KL convergence rate holds consistently across different dimensionality regimes and covariance ranks — validating the dimension-adaptive nature of the theoretical iteration complexity min{d, d^{2/3}L^{1/3}, d^{1/3}L}. Setup/Configurations: Three (d, k) pairs tested, where d is dimension and k is the number of active (non-zero) diagonal covariance entries, each drawn uniformly from [0, 10]: (a) d=10, k=10 — low-dimensional, full-rank covariance (all entries active); (b) d=100, k=10 — medium-dimensional, low-rank covariance (10 active, 90 zero entries); (c) d=500, k=100 — high-dimensional, medium-rank covariance (100 active, 400 zero entries). All configurations use K=10 rounds, N=2T/K steps per round, exact score functions, and run across a range of total iterations T. Metrics: Empirical KL divergence vs T plotted alongside fitted theoretical curve Θ(log^4 T / T^3), shown as three subplots in Figure 2(a)-(c). Comparison: Cross-configuration comparison — all three (d, k) pairs should exhibit the same asymptotic KL convergence rate, confirming the rate is robust to changes in dimension (spanning two orders of magnitude: 10 to 500) and covariance rank (from full-rank to low-rank). Consistency across configurations supports the theory that convergence depends on the smoother min{d, d^{2/3}L^{1/3}, d^{1/3}L} rather than d alone.",
"source": "Appendix A, Figure 2"
},
{
"id": "diffusion-convergence-rate-D3-004",
"claim": "T-variation convergence rate fitting protocol. Purpose: Validate that the empirical KL divergence decreases following the predicted rate O(log^4 T / T^3) as the total number of iterations T varies — confirming the T-dependence of the theoretical bound is correctly captured by the numerical experiments. Setup: For each of the three (d, k) configurations, the sampler is executed across a range of T values. K=10 rounds is held fixed; N = 2T/K = T/5 steps per round varies linearly with T. As T increases, the total number of score evaluations (2T) increases, and the empirical KL divergence between Y_K and X_{tau_{K,0}} is computed at each T value. Metrics: KL(p_{Y_K} || q_K) computed in closed form at multiple T points; the empirical KL-vs-T curve (blue line in Figure 2) is plotted against a fitted rate curve (black line) of the form Θ(log^4 T / T^3). Comparison: The empirical curve is visually compared against the fitted theoretical rate to assess goodness-of-fit — the numerical results show consistency between empirical observations and theoretical predictions, confirming the sampler achieves the predicted convergence rate in practice. The same protocol is repeated independently for each of the three (d, k) configurations to verify the rate is stable across configurations.",
"source": "Appendix A, Figure 2"
}
],
"D4": [
{
"id": "diffusion-convergence-rate-D4-001",
"claim": "Learning schedule construction pipeline: Step 1 — Initialize hat_alpha_{T+1} = 1/T^{c_0}. Step 2 — Iteratively update hat_alpha_{t-1} = hat_alpha_t + c_1 * hat_alpha_t * (1 - hat_alpha_t) * log T / T. Step 3 — For each training step, sample alpha_bar_t ~ Unif(hat_alpha_t, hat_alpha_{t-1}). Step 4 — Map to discretization points tau_k via (hat_tau - tau) / (tau * (1 - tau)) identity.",
"source": "Section 2.2"
},
{
"id": "diffusion-convergence-rate-D4-002",
"claim": "Sampler execution pipeline (N parallel processors, K outer rounds): Step 1 — Compute base sample Y_{k-1,N} from previous round. Step 2 — For each n in 1..N, compute in parallel: score estimate s(Y_{k-1,n}, tau_{k-1,n}) on n-th processor. Step 3 — Aggregate scores and compute Y_{k,N} via ODE step (Eq 10). Step 4 — Every k_s rounds, inject noise via Eq 11 (Y_{k+1} = sqrt(...) Y_{k,N} + sqrt(...) Z_k). Step 5 — Increment round counter k.",
"source": "Section 3.1-3.2"
},
{
"id": "diffusion-convergence-rate-D4-003",
"claim": "Convergence proof derivation order: Step 1 — Discretization analysis using Girsanov's theorem (Section 4). Step 2 — Score estimation error decomposition into L^2 bound (Section 5.1). Step 3 — Non-uniform Lipschitz score handling via early-stopping argument (Section 5.2). Step 4 — Gaussian mixture model specific bound derivation (Section 5.3). Step 5 — Final KL divergence O~(log^4 T / T^3) bound converted to TV distance via Pinsker's inequality.",
"source": "Section 4-5, Theorem 1-3"
},
{
"id": "diffusion-convergence-rate-D4-004",
"claim": "Numerical validation pipeline: Step 1 — Set up synthetic d-dimensional Gaussian target with diagonal covariance. Step 2 — Initialize sampler with randomly sampled alpha_bar_t schedule. Step 3 — Run sampler for varying T values. Step 4 — Compute empirical KL divergence between generated samples and ground truth via Monte Carlo. Step 5 — Plot convergence rate and compare against theoretical O(log^4 T / T^3) prediction.",
"source": "Appendix A"
}
]
} |