{"id":10048,"date":"2026-11-14T03:22:25","date_gmt":"2026-11-14T08:22:25","guid":{"rendered":"https:\/\/www.serverpronto.com\/spu\/2026\/11\/inference-latency-how-to-reduce-latency-deep-learning-model-inference\/"},"modified":"2026-11-14T03:22:28","modified_gmt":"2026-11-14T08:22:28","slug":"inference-latency-how-to-reduce-latency-deep-learning-model-inference","status":"publish","type":"post","link":"https:\/\/www.serverpronto.com\/spu\/2026\/11\/inference-latency-how-to-reduce-latency-deep-learning-model-inference\/","title":{"rendered":"How to Reduce Latency in Deep Learning Model Inference"},"content":{"rendered":"<p><em>Last Updated: November 12, 2026<\/em><\/p>\n<div class=\"article-answer\" style=\"margin:1.5rem 0;padding:16px 20px;background-color:#f8fafc;border:1px solid #e2e8f0;border-radius:8px\">\n<p style=\"margin:0 0 6px;color:#111827;font-size:14px\"><strong>Quick Summary<\/strong><\/p>\n<p style=\"margin:0;color:#1f2937;font-size:16px;line-height:1.6\">To reduce inference latency, measure real requests under realistic load and record p50, p95, and p99 instead of a single average. Then profile to find the true bottleneck and fix it in order: shrink the model with pruning and distillation, apply quantization, optimize GPU inference, and tune batching. Lock every speedup against a fixed accuracy floor.<\/p>\n<ul style=\"margin:10px 0 0;padding-left:20px;color:#374151;font-size:15px;line-height:1.6\">\n<li>Split timing into queueing delay and compute time, and report queue time as its own metric.<\/li>\n<li>Profile on the hardware you will actually deploy, since latency depends on the hardware.<\/li>\n<li>Start quantization with post-training quantization, which needs no retraining.<\/li>\n<li>Set a maximum wait window for dynamic batching and measure the p99 impact.<\/li>\n<li>Set a p95 latency budget and an accuracy floor, then stop tuning.<\/li>\n<\/ul>\n<\/div>\n<div class=\"cta-card\" style=\"display: flex;flex-wrap: wrap;align-items: center;gap: 16px;margin: 24px 0;padding: 18px 20px;border: 1px solid #2563eb33;background-color: #f4f7fe;border-radius: 12px\">\n<div style=\"flex: 1 1 240px;min-width: 0\"><strong style=\"display: block;font-size: 17px;line-height: 1.3;color: #111827\">Still fighting tail latency in production?<\/strong><span style=\"display: block;margin-top: 4px;font-size: 14px;line-height: 1.45;color: #4b5563\">ServerPronto provides dedicated GPU servers with full root access and no shared resources.<\/span><\/div>\n<p><a href=\"https:\/\/www.serverpronto.com\/\" class=\"cta-action-button\" style=\"display: inline-flex;align-items: center;gap: 4px;min-height: 42px;padding: 0 18px;background-color: #2563eb;color: #ffffff;border: 1px solid #2563eb;border-radius: 8px;font-size: 15px;font-weight: 600;line-height: 1.2;text-decoration: none\">Build &amp; Price<\/a><\/div>\n<h2 id=\"table-of-contents\">Table of Contents<\/h2>\n<ul>\n<li><a href=\"#why-inference-latency-decides-whether-your-model-ships\">Why Inference Latency Decides Whether Your Model Ships<\/a><\/li>\n<li><a href=\"#model-inference-latency-measurement-build-a-benchmark-you-can-trust\">Model Inference Latency Measurement: Build a Benchmark You Can Trust<\/a>\n<ul>\n<li><a href=\"#separate-queueing-delay-from-compute-time\">Separate Queueing Delay From Compute Time<\/a><\/li>\n<li><a href=\"#track-p95-and-p99-not-just-the-average\">Track p95 and p99, Not Just the Average<\/a><\/li>\n<\/ul>\n<\/li>\n<li><a href=\"#diagnose-the-bottleneck-before-you-optimize-anything\">Diagnose the Bottleneck Before You Optimize Anything<\/a><\/li>\n<li><a href=\"#step-1-shrink-the-model-with-pruning-and-distillation\">Step 1: Shrink the Model With Pruning and Distillation<\/a><\/li>\n<li><a href=\"#step-2-apply-model-quantization-for-inference-speed\">Step 2: Apply Model Quantization for Inference Speed<\/a><\/li>\n<li><a href=\"#step-3-gpu-inference-optimization-at-the-hardware-layer\">Step 3: GPU Inference Optimization at the Hardware Layer<\/a><\/li>\n<li><a href=\"#step-4-batching-strategies-for-model-serving-under-load\">Step 4: Batching Strategies for Model Serving Under Load<\/a><\/li>\n<li><a href=\"#step-5-measure-the-latency-accuracy-trade-off-and-lock-it-in\">Step 5: Measure the Latency-Accuracy Trade-Off and Lock It In<\/a><\/li>\n<li><a href=\"#frequently-asked-questions\">Frequently Asked Questions<\/a><\/li>\n<\/ul>\n<h2 id=\"why-inference-latency-decides-whether-your-model-ships\">Why Inference Latency Decides Whether Your Model Ships<\/h2>\n<p><strong>Inference latency<\/strong> is the time a trained model takes to return a prediction for one request. It is the metric users feel. A model that scores well offline but answers slowly will lose to a simpler model that responds instantly.<\/p>\n<p>That gap is the whole game. Reducing latency in deep learning model inference is less about clever math and more about knowing where the clock actually stops.<\/p>\n<p>The pressure is real. Ultralytics notes that teams now cut computation through smaller model variants, lower input resolution, or fewer weights, precisely because latency blocks deployment (Ultralytics on inference latency).<\/p>\n<p>Here is the tension most guides skip: latency and throughput pull against each other. NVIDIA describes partitioning workloads across multiple GPUs with tensor parallelism as a standard way to cut runtime latency (NVIDIA on low-latency inference communication). That adds coordination cost. You trade simplicity for speed.<\/p>\n<p>Below, we walk through a reproducible benchmarking workflow, then five optimization steps in order. Each step targets a different part of the clock.<\/p>\n<p>If you are still deciding where to run latency-sensitive inference, our breakdown of <a href=\"\/spu\/2026\/09\/dedicated-server-vs-cloud-ai-workloads\/\">dedicated server vs cloud for AI workloads<\/a> covers the trade-offs.<\/p>\n<h2 id=\"model-inference-latency-measurement-build-a-benchmark-you-can-trust\">Model Inference Latency Measurement: Build a Benchmark You Can Trust<\/h2>\n<p>Model inference latency measurement is the practice of timing real requests under realistic load and recording the distribution, not a single number. Measure first. Optimize second.<\/p>\n<p>A common mistake is timing one request on an idle machine. That tells you almost nothing. Production traffic arrives in bursts, queues form, and the tail stretches.<\/p>\n<p>Freeze Inference, a 2019 paper by A. Kumar and coauthors, attacks prediction latency by adding intermediate-layer caches to deep networks (<a rel=\"noopener noreferrer\" target=\"_blank\" href=\"https:\/\/www.usenix.org\/conference\/hotcloud19\/presentation\/kumar\">Accelerating Deep Learning Inference via Freezing<\/a>(<a rel=\"noopener noreferrer\" target=\"_blank\" href=\"https:\/\/www.usenix.org\/conference\/hotcloud19\/presentation\/kumar\">https:\/\/www.usenix.org\/conference\/hotcloud19\/presentation\/kumar<\/a>)). The lesson for measurement is simple: cache hits and misses behave differently, so benchmark both.<\/p>\n<figure class=\"article-content-image my-8\" style=\"margin:2em 0;padding:0;background:transparent;border:0\"><img decoding=\"async\" src=\"https:\/\/www.serverpronto.com\/spu\/wp-content\/uploads\/how-to-reduce-latency-in-deep-learning-model-inference-content-1-1794536167.jpg\" alt=\"Engineer analyzing terminal logs and benchmark notes to measure inference latency at a workstation.\" class=\"w-full rounded-lg shadow-lg\" loading=\"lazy\" style=\"display:block;width:100%;max-width:100%;height:auto;border-radius:8px;margin:0 auto\"><figcaption class=\"text-sm text-gray-600 mt-2 text-center\" style=\"font-size:0.875em;color:inherit;opacity:0.75;text-align:center;margin-top:0.6em\">Engineer analyzing terminal logs and benchmark notes to measure inference latency at a workstation.<\/figcaption><\/figure>\n<h3 id=\"separate-queueing-delay-from-compute-time\">Separate Queueing Delay From Compute Time<\/h3>\n<p>Split your timing into two buckets. Queueing delay is time spent waiting for a worker. Compute time is the model actually running.<\/p>\n<ul>\n<li>Log request arrival and worker pickup timestamps separately<\/li>\n<li>Report queue time as its own metric<\/li>\n<li>Watch queue time first when load rises<\/li>\n<\/ul>\n<h3 id=\"track-p95-and-p99-not-just-the-average\">Track p95 and p99, Not Just the Average<\/h3>\n<p>Averages hide pain. If p99 latency spikes, one in a hundred users waits far too long.<\/p>\n<ul>\n<li>Record p50, p95, and p99 for every run<\/li>\n<li>Set a service-level objective on the tail, not the mean<\/li>\n<li>Rerun benchmarks after every model or runtime change<\/li>\n<\/ul>\n<h2 id=\"diagnose-the-bottleneck-before-you-optimize-anything\">Diagnose the Bottleneck Before You Optimize Anything<\/h2>\n<p>Profiling comes before tuning. Most teams quantize a model, see no gain, and blame the model. The real bottleneck was the request queue or the data transfer.<\/p>\n<p>Hardware-aware profiling answers one question: what is the machine waiting on?<\/p>\n<ul>\n<li><strong>Compute bottleneck:<\/strong> GPU use sits near the ceiling while requests stack up<\/li>\n<li><strong>Memory bandwidth:<\/strong> use is high but compute sits idle<\/li>\n<li><strong>Data transfer:<\/strong> preprocessing and host-to-device copies dominate<\/li>\n<li><strong>Queueing:<\/strong> workers are idle while requests wait<\/li>\n<\/ul>\n<p>nn-Meter, a system from Tsinghua researchers, predicts deep neural network inference latency across diverse edge devices (EXTERNAL_LINK: nn-Meter latency prediction research | <a rel=\"noopener noreferrer\" target=\"_blank\" href=\"https:\/\/air.tsinghua.edu.cn\/pdf\/nn-Meter-Towards-Accurate-Latency-Prediction-of-Deep-Learning-Model-Inference-on-Diverse-Edge-Devices.pdf\">https:\/\/air.tsinghua.edu.cn\/pdf\/nn-Meter-Towards-Accurate-Latency-Prediction-of-Deep-Learning-Model-Inference-on-Diverse-Edge-Devices.pdf<\/a>). The practical takeaway: latency depends on the hardware, so profile on the hardware you will actually deploy.<\/p>\n<p>Here is the decision framework we use:<\/p>\n<table style=\"width:100%;border-collapse:collapse;margin:2rem 0;font-size:14px;line-height:1.6\">\n<thead style=\"background-color:#f8f9fa;color:#111827;padding:12px 16px;text-align:left;font-weight:600;border-bottom:2px solid #e5e7eb\">\n<tr>\n<th style=\"background-color:#f8f9fa;color:#111827;padding:12px 16px;text-align:left;font-weight:600;border-bottom:2px solid #e5e7eb\">Symptom<\/th>\n<th style=\"background-color:#f8f9fa;color:#111827;padding:12px 16px;text-align:left;font-weight:600;border-bottom:2px solid #e5e7eb\">Likely Bottleneck<\/th>\n<th style=\"background-color:#f8f9fa;color:#111827;padding:12px 16px;text-align:left;font-weight:600;border-bottom:2px solid #e5e7eb\">First Fix<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td style=\"padding:12px 16px;border-bottom:1px solid #e5e7eb\">GPU near full, queue growing<\/td>\n<td style=\"padding:12px 16px;border-bottom:1px solid #e5e7eb\">Compute<\/td>\n<td style=\"padding:12px 16px;border-bottom:1px solid #e5e7eb\">Pruning, distillation, quantization<\/td>\n<\/tr>\n<tr>\n<td style=\"padding:12px 16px;border-bottom:1px solid #e5e7eb\">GPU idle, latency high<\/td>\n<td style=\"padding:12px 16px;border-bottom:1px solid #e5e7eb\">Data transfer or preprocessing<\/td>\n<td style=\"padding:12px 16px;border-bottom:1px solid #e5e7eb\">Batch inputs, move preprocessing<\/td>\n<\/tr>\n<tr>\n<td style=\"padding:12px 16px;border-bottom:1px solid #e5e7eb\">Spiky p99 under load<\/td>\n<td style=\"padding:12px 16px;border-bottom:1px solid #e5e7eb\">Queueing<\/td>\n<td style=\"padding:12px 16px;border-bottom:1px solid #e5e7eb\">Dynamic batching, more workers<\/td>\n<\/tr>\n<tr>\n<td style=\"padding:12px 16px;border-bottom:1px solid #e5e7eb\">High memory use, slow steps<\/td>\n<td style=\"padding:12px 16px;border-bottom:1px solid #e5e7eb\">Memory bandwidth<\/td>\n<td style=\"padding:12px 16px;border-bottom:1px solid #e5e7eb\">Lower precision, smaller batches<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2 id=\"step-1-shrink-the-model-with-pruning-and-distillation\">Step 1: Shrink the Model With Pruning and Distillation<\/h2>\n<p>Smaller models generally run faster.<\/p>\n<p><strong>Pruning<\/strong> removes weights or entire channels that contribute little to output quality. <strong>Knowledge distillation<\/strong> trains a small student model to mimic a larger teacher. Both cut the compute per request.<\/p>\n<ul>\n<li>Prune iteratively and re-benchmark after each pass<\/li>\n<li>Distill from your best large model into a deployable small one<\/li>\n<li>Check accuracy after every change, not at the end<\/li>\n<\/ul>\n<p>The trap: aggressive pruning can quietly degrade accuracy. Measure both sides of the trade-off as you go.<\/p>\n<h2 id=\"step-2-apply-model-quantization-for-inference-speed\">Step 2: Apply Model Quantization for Inference Speed<\/h2>\n<p>Model quantization for inference stores weights and activations in lower precision, usually 8-bit or 4-bit integers instead of 32-bit floats. Less data to move means faster math and lower memory bandwidth pressure.<\/p>\n<ul>\n<li>Start with post-training quantization, which needs no retraining<\/li>\n<li>Compare 8-bit and 4-bit variants against your accuracy floor<\/li>\n<li>Re-profile after quantizing, since the bottleneck may shift<\/li>\n<\/ul>\n<p>Watch out: quantized models can behave differently on outlier inputs. Test on real traffic samples, not just a clean validation set.<\/p>\n<h2 id=\"step-3-gpu-inference-optimization-at-the-hardware-layer\">Step 3: GPU Inference Optimization at the Hardware Layer<\/h2>\n<p>GPU inference optimization means matching the model, the runtime, and the hardware so nothing waits on nothing. This is where most of the remaining latency lives.<\/p>\n<ul>\n<li>Use an inference engine that fuses operations and compiles the graph<\/li>\n<li>Keep inputs on the device to avoid repeated data transfer<\/li>\n<li>Pin memory and pre-allocate buffers<\/li>\n<li>Confirm the GPU is not shared with other tenants<\/li>\n<\/ul>\n<p>That last point matters more than people admit. Shared resources can create noisy-neighbor latency that is hard to tune away. Our <a href=\"\/ai-inference-hosting\/\">AI inference and LLM hosting<\/a> runs on dedicated or customer-owned hardware so you control the serving stack. For deeper tuning, see our guide to <a href=\"\/spu\/2026\/09\/how-to-optimize-gpu-for-ai-training\/\">optimizing GPUs for AI training<\/a>, and if you are sizing hardware, the <a href=\"\/spu\/2026\/09\/gpu-dedicated-server-deep-learning\/\">GPU dedicated server guide for deep learning<\/a> covers the infrastructure options.<\/p>\n<h2 id=\"step-4-batching-strategies-for-model-serving-under-load\">Step 4: Batching Strategies for Model Serving Under Load<\/h2>\n<p>Batching strategies for model serving group requests so the GPU processes more work per pass. The trick is doing it without inflating response time.<\/p>\n<p>Dynamic batching waits a short window to collect requests, then runs them together. It raises throughput and can lower cost per request, but it adds queueing delay.<\/p>\n<ul>\n<li>Set a maximum wait window and measure the p99 impact<\/li>\n<li>Cap batch size to protect tail latency<\/li>\n<li>Scale workers horizontally when queues grow<\/li>\n<\/ul>\n<p>Traffic distribution matters here too. Our <a href=\"\/load-balancing\/\">load balancing<\/a> overview covers configuration options for spreading requests across workers.<\/p>\n<h2 id=\"step-5-measure-the-latency-accuracy-trade-off-and-lock-it-in\">Step 5: Measure the Latency-Accuracy Trade-Off and Lock It In<\/h2>\n<p>Every optimization above moves two numbers: speed and accuracy. Lock both down before you ship.<\/p>\n<ul>\n<li>Build a fixed evaluation set and record accuracy at each optimization stage<\/li>\n<li>Pair every latency gain with its accuracy cost in one table<\/li>\n<li>Set a p95 latency budget and an accuracy floor, then stop tuning<\/li>\n<li>Add production monitoring to catch regressions after deploys<\/li>\n<\/ul>\n<p>The trade-off is not free. Ultralytics and practitioner discussions both flag that latency work sits alongside accuracy concerns and the throughput-versus-latency balance (Ultralytics inference latency guide). Treat any speedup that costs accuracy as a decision, not a win.<\/p>\n<hr>\n<p>Reducing latency in deep learning model inference comes down to measurement discipline. Profile first, fix the real bottleneck, and prove every gain against your accuracy floor. When the remaining bottleneck is shared hardware, that is an infrastructure problem. ServerPronto offers dedicated GPU environments with full root access, 2-hour provisioning, month-to-month billing with no contracts, and 24\/7 on-site technicians. Visit ServerPronto&#8217;s website for current pricing or a quote.<\/p>\n<section style=\"margin:3rem 0 2rem 0\">\n<h2 style=\"font-weight:700;margin:0 0 4px 0\" id=\"frequently-asked-questions\">Frequently Asked Questions<\/h2>\n<div style=\"padding:20px 0;border-bottom:1px solid #e5e7eb\">\n<h3 style=\"font-weight:600;margin:0 0 8px 0\">What does inference latency mean, and how is it different from throughput?<\/h3>\n<div style=\"line-height:1.7\">\n<p style=\"margin:0\">Inference latency is the time from when a request hits your server to when the prediction comes back. Throughput is how many requests you finish per second. They pull against each other: larger batches raise throughput but push up the time each individual request waits. For real-time applications like fraud scoring or chat responses, latency is the number users feel. For overnight batch scoring, throughput matters more. Measure both, but set your service-level objective on latency percentiles, since a fast average hides the slow requests that generate complaints.<\/p>\n<\/div>\n<\/div>\n<div style=\"padding:20px 0;border-bottom:1px solid #e5e7eb\">\n<h3 style=\"font-weight:600;margin:0 0 8px 0\">How do batch size and request batching affect inference latency?<\/h3>\n<div style=\"line-height:1.7\">\n<p style=\"margin:0\">Batching strategies for model serving trade queueing delay for compute efficiency. A batch of 32 keeps a GPU busy and raises throughput, but each request waits for the batch to fill, which adds queueing delay. Small batches or batch size 1 keep response time low at the cost of hardware utilization. Dynamic batching, where the server waits a short window (often a few milliseconds) and ships whatever arrived, is the usual compromise. Benchmark your real arrival rate before picking a window, because a fixed timeout that is too long hurts tail latency more than it helps throughput.<\/p>\n<\/div>\n<\/div>\n<div style=\"padding:20px 0;border-bottom:1px solid #e5e7eb\">\n<h3 style=\"font-weight:600;margin:0 0 8px 0\">When should you use quantization to speed up model inference?<\/h3>\n<div style=\"line-height:1.7\">\n<p style=\"margin:0\">Model quantization for inference is worth trying when your model is memory-bandwidth bound, when you are serving on GPUs with limited VRAM, or when you need to fit more concurrent requests per device. Converting weights from 32-bit to 16-bit floating point usually costs little accuracy and roughly halves memory traffic. Going to 8-bit integers can cut memory further, but validate task accuracy on a held-out set first. If accuracy drops past your threshold, try quantization-aware training or keep the sensitive layers in higher precision.<\/p>\n<\/div>\n<\/div>\n<div style=\"padding:20px 0;border-bottom:1px solid #e5e7eb\">\n<h3 style=\"font-weight:600;margin:0 0 8px 0\">How do you identify whether model inference is limited by the GPU, CPU, or data pipeline?<\/h3>\n<div style=\"line-height:1.7\">\n<p style=\"margin:0\">Profile each stage separately. Log timestamps for request arrival, preprocessing completion, model execution, and postprocessing. If preprocessing or image decode dominates, the GPU is idle waiting on the CPU, and input resolution or frame sampling is your lever. If model execution dominates and GPU utilization sits near the ceiling, you are compute bound and should look at pruning, quantization, or a faster inference engine. Low GPU utilization with high memory traffic points to memory bandwidth. Fix the largest stage first, then re-measure, since removing one bottleneck often exposes the next.<\/p>\n<\/div>\n<\/div>\n<\/section>\n<div style=\"border:1px solid #d6d3d1;border-radius:12px;padding:18px 20px;margin:32px 0\"><a href=\"https:\/\/www.google.com\/preferences\/source?q=serverpronto.com\" target=\"_blank\" rel=\"noopener\" style=\"display:block;text-decoration:none;color:inherit\"><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/app.grandranker.com\/images\/google-g.svg\" width=\"24\" height=\"24\" alt=\"Google\" style=\"display:inline-block;width:24px !important;height:24px !important;max-width:24px;vertical-align:middle;margin:0 10px 0 0;border:0\"><span style=\"vertical-align:middle\">Add <strong>serverpronto.com<\/strong> as a preferred source on Google &rarr;<\/span><\/a><\/div>\n","protected":false},"excerpt":{"rendered":"<p>Learn how to cut inference latency in deep learning models with a step-by-step workflow covering measurement, quantization, GPU tuning, and batching.<\/p>\n","protected":false},"author":11,"featured_media":10049,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[409],"tags":[686,683,685,687,684],"class_list":["post-10048","post","type-post","status-publish","format-standard","has-post-thumbnail","category-blog","tag-gpu-inference-optimization","tag-inference-latency","tag-model-inference-latency-measurement","tag-model-quantization-for-inference","tag-reducing-latency-in-deep-learning-model-inference"],"_links":{"self":[{"href":"https:\/\/www.serverpronto.com\/spu\/wp-json\/wp\/v2\/posts\/10048","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.serverpronto.com\/spu\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.serverpronto.com\/spu\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.serverpronto.com\/spu\/wp-json\/wp\/v2\/users\/11"}],"replies":[{"embeddable":true,"href":"https:\/\/www.serverpronto.com\/spu\/wp-json\/wp\/v2\/comments?post=10048"}],"version-history":[{"count":1,"href":"https:\/\/www.serverpronto.com\/spu\/wp-json\/wp\/v2\/posts\/10048\/revisions"}],"predecessor-version":[{"id":10051,"href":"https:\/\/www.serverpronto.com\/spu\/wp-json\/wp\/v2\/posts\/10048\/revisions\/10051"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.serverpronto.com\/spu\/wp-json\/wp\/v2\/media\/10049"}],"wp:attachment":[{"href":"https:\/\/www.serverpronto.com\/spu\/wp-json\/wp\/v2\/media?parent=10048"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.serverpronto.com\/spu\/wp-json\/wp\/v2\/categories?post=10048"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.serverpronto.com\/spu\/wp-json\/wp\/v2\/tags?post=10048"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}