{"id":679,"date":"2026-04-07T07:23:53","date_gmt":"2026-04-06T23:23:53","guid":{"rendered":"https:\/\/connectword.dpdns.org\/?p=679"},"modified":"2026-04-07T07:23:53","modified_gmt":"2026-04-06T23:23:53","slug":"an-implementation-guide-to-running-nvidia-transformer-engine-with-mixed-precision-fp8-checks-benchmarking-and-fallback-execution","status":"publish","type":"post","link":"https:\/\/connectword.dpdns.org\/?p=679","title":{"rendered":"An Implementation Guide to Running NVIDIA Transformer Engine with Mixed Precision, FP8 Checks, Benchmarking, and Fallback Execution"},"content":{"rendered":"

In this tutorial, we implement an advanced, practical implementation of the <\/strong>NVIDIA Transformer Engine<\/strong><\/a> in Python, focusing on how mixed-precision acceleration can be explored in a realistic deep learning workflow. We set up the environment, verify GPU and CUDA readiness, attempt to install the required Transformer Engine components, and handle compatibility issues gracefully so that the notebook remains runnable even when the full extension cannot be built. As we move through each step, we build teacher and student networks, compare a baseline PyTorch path with a Transformer Engine-enabled path, train both models, benchmark their speed and memory usage, and visualize the results, giving us a clear hands-on understanding of how performance-oriented training workflows are structured in practice.<\/p>\n

\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
import os\nimport sys\nimport json\nimport time\nimport math\nimport random\nimport shutil\nimport platform\nimport subprocess\nimport statistics\n\n\ndef run(cmd, check=True):\n   print(\"n[RUN]\", \" \".join(cmd))\n   result = subprocess.run(cmd, text=True, capture_output=True)\n   if result.stdout.strip():\n       print(result.stdout[-4000:])\n   if result.returncode != 0 and result.stderr.strip():\n       print(result.stderr[-4000:])\n   if check and result.returncode != 0:\n       raise subprocess.CalledProcessError(result.returncode, cmd)\n   return result\n\n\ndef has_cmd(name):\n   return shutil.which(name) is not None\n\n\nrun([sys.executable, \"-m\", \"pip\", \"install\", \"-q\", \"--upgrade\", \"pip\"])\nrun([sys.executable, \"-m\", \"pip\", \"install\", \"-q\", \"ninja\", \"packaging\", \"matplotlib\"])\n\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport matplotlib.pyplot as plt\n\n\nassert torch.cuda.is_available(), \"This notebook needs a GPU runtime in Colab.\"\n\n\ngpu_name = torch.cuda.get_device_name(0)\ncc_major, cc_minor = torch.cuda.get_device_capability(0)\ncuda_runtime = torch.version.cuda\npython_version = sys.version.split()[0]\ntorch_version = torch.__version__\ncuda_home = os.environ.get(\"CUDA_HOME\", \"\/usr\/local\/cuda\")\nnvcc_path = shutil.which(\"nvcc\") or os.path.join(cuda_home, \"bin\", \"nvcc\")\ncudnn_header_candidates = [\n   os.path.join(cuda_home, \"include\", \"cudnn.h\"),\n   \"\/usr\/include\/cudnn.h\",\n   \"\/usr\/local\/include\/cudnn.h\",\n]\n\n\nnvcc_exists = os.path.exists(nvcc_path)\ncudnn_header_exists = any(os.path.exists(p) for p in cudnn_header_candidates)\n\n\nprint(\"=\" * 120)\nprint(\"ENVIRONMENT CHECK\")\nprint(\"=\" * 120)\nprint(json.dumps({\n   \"python\": python_version,\n   \"platform\": platform.platform(),\n   \"torch\": torch_version,\n   \"torch_cuda\": cuda_runtime,\n   \"gpu_name\": gpu_name,\n   \"compute_capability\": f\"{cc_major}.{cc_minor}\",\n   \"cuda_home\": cuda_home,\n   \"nvcc_exists\": nvcc_exists,\n   \"nvcc_path\": nvcc_path if nvcc_exists else None,\n   \"cudnn_header_exists\": cudnn_header_exists,\n}, indent=2))\nprint(\"=\" * 120)<\/code><\/pre>\n<\/div>\n<\/div>\n
We prepare the Colab environment by importing the required Python libraries, defining a helper function for executing shell commands, and installing the core dependencies for the tutorial. We then import PyTorch and Matplotlib, verify that a GPU is available, and collect key environment details, including the GPU name, CUDA version, Python version, and toolkit paths. This gives us a clear view of the system state before we attempt any Transformer Engine installation or model execution.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
te_available = False\nte_mode = \"fallback\"\nte_import_error = None\n\n\ntry:\n   run([sys.executable, \"-m\", \"pip\", \"install\", \"-q\", \"transformer_engine[core_cu12]\"])\nexcept Exception as e:\n   print(\"Core wheel install failed:\", repr(e))\n\n\ncan_try_te_torch = nvcc_exists and cudnn_header_exists\n\n\nif can_try_te_torch:\n   env = os.environ.copy()\n   env[\"NVTE_FRAMEWORK\"] = \"pytorch\"\n   env[\"MAX_JOBS\"] = \"1\"\n   env[\"NVTE_BUILD_THREADS_PER_JOB\"] = \"1\"\n   env[\"CUDA_PATH\"] = cuda_home\n   env[\"CUDA_HOME\"] = cuda_home\n   try:\n       print(\"nAttempting to build the PyTorch extension for Transformer Engine...\")\n       result = subprocess.run(\n           [sys.executable, \"-m\", \"pip\", \"install\", \"-q\", \"--no-build-isolation\", \"transformer_engine[pytorch]\"],\n           text=True,\n           capture_output=True,\n           env=env,\n       )\n       if result.stdout.strip():\n           print(result.stdout[-4000:])\n       if result.returncode != 0 and result.stderr.strip():\n           print(result.stderr[-4000:])\n       if result.returncode == 0:\n           import transformer_engine.pytorch as te\n           from transformer_engine.common import recipe\n           te_available = True\n           te_mode = \"transformer_engine\"\n       else:\n           te_import_error = result.stderr[-4000:] if result.stderr else \"Unknown pip build error\"\n   except Exception as e:\n       te_import_error = repr(e)\nelse:\n   te_import_error = \"Missing nvcc or cuDNN headers in this Colab runtime, so TE PyTorch extension cannot be built here.\"\n\n\nif te_available:\n   try:\n       fp8_available, fp8_reason = te.is_fp8_available(return_reason=True)\n   except Exception as e:\n       fp8_available, fp8_reason = False, f\"Could not query FP8 availability: {e}\"\n   try:\n       bf16_available = te.is_bf16_available()\n   except Exception:\n       bf16_available = torch.cuda.is_bf16_supported()\nelse:\n   fp8_available = False\n   fp8_reason = \"Transformer Engine not installed; using fallback PyTorch path.\"\n   bf16_available = torch.cuda.is_bf16_supported()\n\n\namp_dtype = torch.bfloat16 if bf16_available else torch.float16\n\n\nprint(\"n\" + \"=\" * 120)\nprint(\"INSTALL STATUS\")\nprint(\"=\" * 120)\nprint(json.dumps({\n   \"te_available\": te_available,\n   \"te_mode\": te_mode,\n   \"fp8_available\": fp8_available,\n   \"fp8_reason\": fp8_reason,\n   \"te_import_error\": te_import_error,\n   \"amp_dtype\": str(amp_dtype),\n}, indent=2))\nprint(\"=\" * 120)\n\n\ndevice = \"cuda\"\nrandom.seed(42)\ntorch.manual_seed(42)\ntorch.cuda.manual_seed_all(42)\n\n\nif te_available:\n   fp8_recipe = recipe.DelayedScaling(margin=0, fp8_format=recipe.Format.E4M3)\n\n\ndef baseline_autocast():\n   return torch.autocast(device_type=\"cuda\", dtype=amp_dtype)\n\n\ndef te_forward_context(use_fp8):\n   if te_available and use_fp8:\n       return te.autocast(enabled=True, recipe=fp8_recipe)\n   return baseline_autocast()<\/code><\/pre>\n<\/div>\n<\/div>\n
We attempt to install the Transformer Engine core package and then check whether the Colab runtime can build the PyTorch extension by verifying the presence of nvcc and cuDNN headers. If the environment supports it, we try to install the Transformer Engine PyTorch backend and then inspect whether FP8 and BF16 are available on the current hardware. We also configure the precision mode and define the autocast contexts that later allow us to switch between standard mixed precision and Transformer Engine execution.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
class TeacherNet(nn.Module):\n   def __init__(self, hidden_size=512, intermediate_size=2048, num_layers=3, vocab_size=4096):\n       super().__init__()\n       self.embed = nn.Embedding(vocab_size, hidden_size)\n       self.layers = nn.ModuleList([\n           nn.Sequential(\n               nn.LayerNorm(hidden_size),\n               nn.Linear(hidden_size, intermediate_size),\n               nn.GELU(),\n               nn.Linear(intermediate_size, hidden_size),\n           ) for _ in range(num_layers)\n       ])\n       self.head = nn.Linear(hidden_size, hidden_size)\n\n\n   def forward(self, token_ids):\n       x = self.embed(token_ids)\n       for layer in self.layers:\n           x = x + layer(x)\n       return self.head(x)\n\n\nclass BaselineStudent(nn.Module):\n   def __init__(self, hidden_size=512, intermediate_size=2048, num_layers=3, vocab_size=4096):\n       super().__init__()\n       self.embed = nn.Embedding(vocab_size, hidden_size)\n       self.norms = nn.ModuleList([nn.LayerNorm(hidden_size) for _ in range(num_layers)])\n       self.fc1 = nn.ModuleList([nn.Linear(hidden_size, intermediate_size) for _ in range(num_layers)])\n       self.fc2 = nn.ModuleList([nn.Linear(intermediate_size, hidden_size) for _ in range(num_layers)])\n       self.head = nn.Linear(hidden_size, hidden_size)\n\n\n   def forward(self, token_ids):\n       x = self.embed(token_ids)\n       for ln, fc1, fc2 in zip(self.norms, self.fc1, self.fc2):\n           residual = x\n           x = ln(x)\n           x = fc1(x)\n           x = F.gelu(x, approximate=\"tanh\")\n           x = fc2(x)\n           x = x + residual\n       return self.head(x)\n\n\nif te_available:\n   class TEStudent(nn.Module):\n       def __init__(self, hidden_size=512, intermediate_size=2048, num_layers=3, vocab_size=4096):\n           super().__init__()\n           self.embed = nn.Embedding(vocab_size, hidden_size)\n           self.norms = nn.ModuleList([te.LayerNorm(hidden_size) for _ in range(num_layers)])\n           self.fc1 = nn.ModuleList([te.Linear(hidden_size, intermediate_size, bias=True) for _ in range(num_layers)])\n           self.fc2 = nn.ModuleList([te.Linear(intermediate_size, hidden_size, bias=True) for _ in range(num_layers)])\n           self.head = te.Linear(hidden_size, hidden_size, bias=True)\n\n\n       def forward(self, token_ids, use_fp8=False):\n           x = self.embed(token_ids)\n           with te_forward_context(use_fp8):\n               for ln, fc1, fc2 in zip(self.norms, self.fc1, self.fc2):\n                   residual = x\n                   x = ln(x)\n                   x = fc1(x)\n                   x = F.gelu(x, approximate=\"tanh\")\n                   x = fc2(x)\n                   x = x + residual\n               x = self.head(x)\n           return x\nelse:\n   class TEStudent(nn.Module):\n       def __init__(self, hidden_size=512, intermediate_size=2048, num_layers=3, vocab_size=4096):\n           super().__init__()\n           self.embed = nn.Embedding(vocab_size, hidden_size)\n           self.norms = nn.ModuleList([nn.LayerNorm(hidden_size) for _ in range(num_layers)])\n           self.fc1 = nn.ModuleList([nn.Linear(hidden_size, intermediate_size) for _ in range(num_layers)])\n           self.fc2 = nn.ModuleList([nn.Linear(intermediate_size, hidden_size) for _ in range(num_layers)])\n           self.head = nn.Linear(hidden_size, hidden_size)\n\n\n       def forward(self, token_ids, use_fp8=False):\n           x = self.embed(token_ids)\n           with baseline_autocast():\n               for ln, fc1, fc2 in zip(self.norms, self.fc1, self.fc2):\n                   residual = x\n                   x = ln(x)\n                   x = fc1(x)\n                   x = F.gelu(x, approximate=\"tanh\")\n                   x = fc2(x)\n                   x = x + residual\n               x = self.head(x)\n           return x\n\n\ndef count_params(model):\n   return sum(p.numel() for p in model.parameters() if p.requires_grad)\n\n\ndef format_millions(n):\n   return f\"{n \/ 1e6:.2f}M\"<\/code><\/pre>\n<\/div>\n<\/div>\n
We define the neural network architectures used throughout the tutorial, including the teacher model, the baseline student model, and the Transformer Engine student path. We keep the model structures aligned so that the comparison remains meaningful while allowing the TE path to swap in Transformer Engine layers when the extension is available. We also define small utility functions for counting parameters and formatting model size, which help us inspect the scale of the models before training begins.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
hidden_size = 512\nintermediate_size = 2048\nnum_layers = 3\nvocab_size = 4096\nseq_len = 128\nbatch_size = 8\nsteps = 25\nbenchmark_iters = 20\nlr = 2e-4\nweight_decay = 1e-2\n\n\nteacher = TeacherNet(hidden_size, intermediate_size, num_layers, vocab_size).to(device).eval()\nbaseline_model = BaselineStudent(hidden_size, intermediate_size, num_layers, vocab_size).to(device)\nte_model = TEStudent(hidden_size, intermediate_size, num_layers, vocab_size).to(device)\n\n\noptimizer_baseline = torch.optim.AdamW(baseline_model.parameters(), lr=lr, weight_decay=weight_decay)\noptimizer_te = torch.optim.AdamW(te_model.parameters(), lr=lr, weight_decay=weight_decay)\n\n\nprint(\"Teacher params :\", format_millions(count_params(teacher)))\nprint(\"Baseline params:\", format_millions(count_params(baseline_model)))\nprint(\"TE-path params :\", format_millions(count_params(te_model)))\n\n\ndef make_batch(batch_size, seq_len, vocab_size, device):\n   tokens = torch.randint(0, vocab_size, (batch_size, seq_len), device=device)\n   with torch.no_grad():\n       target = teacher(tokens)\n   return tokens, target\n\n\ndef peak_mem_mb():\n   return torch.cuda.max_memory_allocated() \/ (1024 ** 2)\n\n\ndef train_baseline_step():\n   baseline_model.train()\n   optimizer_baseline.zero_grad(set_to_none=True)\n   tokens, target = make_batch(batch_size, seq_len, vocab_size, device)\n   with baseline_autocast():\n       pred = baseline_model(tokens)\n       loss = F.mse_loss(pred, target)\n   loss.backward()\n   optimizer_baseline.step()\n   return float(loss.detach().item())\n\n\ndef train_te_step(use_fp8):\n   te_model.train()\n   optimizer_te.zero_grad(set_to_none=True)\n   tokens, target = make_batch(batch_size, seq_len, vocab_size, device)\n   pred = te_model(tokens, use_fp8=use_fp8)\n   loss = F.mse_loss(pred, target)\n   loss.backward()\n   optimizer_te.step()\n   return float(loss.detach().item())<\/code><\/pre>\n<\/div>\n<\/div>\n
We set the main experiment hyperparameters, instantiate all models on the GPU, and create the optimizers that will be used during training. We also print the parameter counts to confirm that the baseline and TE paths are comparable in terms of model size. In addition, we define the batch-generation logic, memory tracking function, and the individual training-step functions that execute one optimization step for each model path.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
baseline_losses = []\nte_losses = []\nmode_name = \"TE-FP8\" if (te_available and fp8_available) else (\"TE-BF16\/FP16\" if te_available else \"Fallback-PyTorch\")\n\n\nprint(\"n\" + \"=\" * 120)\nprint(\"TRAINING\")\nprint(\"=\" * 120)\n\n\nfor step in range(1, steps + 1):\n   b_loss = train_baseline_step()\n   t_loss = train_te_step(use_fp8=fp8_available)\n   baseline_losses.append(b_loss)\n   te_losses.append(t_loss)\n   if step == 1 or step % 5 == 0 or step == steps:\n       print(f\"step={step:02d} | baseline_loss={b_loss:.6f} | te_path_loss={t_loss:.6f} | mode={mode_name}\")\n\n\n@torch.no_grad()\ndef evaluate_model(model, is_te=False, use_fp8=False, eval_batches=8):\n   model.eval()\n   vals = []\n   for _ in range(eval_batches):\n       tokens, target = make_batch(batch_size, seq_len, vocab_size, device)\n       if is_te:\n           pred = model(tokens, use_fp8=use_fp8)\n       else:\n           with baseline_autocast():\n               pred = model(tokens)\n       vals.append(float(F.mse_loss(pred, target).item()))\n   return sum(vals) \/ len(vals)\n\n\nbaseline_eval = evaluate_model(baseline_model, is_te=False)\nte_eval = evaluate_model(te_model, is_te=True, use_fp8=fp8_available)\n\n\ndef benchmark_train_step(model, optimizer, is_te=False, use_fp8=False, warmup=5, iters=20):\n   times_ms = []\n   mems_mb = []\n   for _ in range(warmup):\n       optimizer.zero_grad(set_to_none=True)\n       tokens, target = make_batch(batch_size, seq_len, vocab_size, device)\n       if is_te:\n           pred = model(tokens, use_fp8=use_fp8)\n       else:\n           with baseline_autocast():\n               pred = model(tokens)\n       loss = F.mse_loss(pred, target)\n       loss.backward()\n       optimizer.step()\n   torch.cuda.synchronize()\n   for _ in range(iters):\n       torch.cuda.reset_peak_memory_stats()\n       optimizer.zero_grad(set_to_none=True)\n       tokens, target = make_batch(batch_size, seq_len, vocab_size, device)\n       start = time.perf_counter()\n       if is_te:\n           pred = model(tokens, use_fp8=use_fp8)\n       else:\n           with baseline_autocast():\n               pred = model(tokens)\n       loss = F.mse_loss(pred, target)\n       loss.backward()\n       optimizer.step()\n       torch.cuda.synchronize()\n       end = time.perf_counter()\n       times_ms.append((end - start) * 1000.0)\n       mems_mb.append(peak_mem_mb())\n   return {\n       \"mean_ms\": statistics.mean(times_ms),\n       \"median_ms\": statistics.median(times_ms),\n       \"max_memory_mb\": max(mems_mb),\n   }\n\n\nbaseline_bench = benchmark_train_step(baseline_model, optimizer_baseline, is_te=False, use_fp8=False, iters=benchmark_iters)\nte_bench = benchmark_train_step(te_model, optimizer_te, is_te=True, use_fp8=fp8_available, iters=benchmark_iters)<\/code><\/pre>\n<\/div>\n<\/div>\n
We run the main training loop for both the baseline model and the TE path, tracking their losses over multiple steps. We then define and execute the evaluation function to measure how well each model matches the teacher\u2019s outputs after training. Finally, we implement the benchmarking routine to measure per-step runtime and peak CUDA memory usage, enabling quantitative comparison of performance characteristics.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
summary = {\n   \"gpu_name\": gpu_name,\n   \"compute_capability\": f\"{cc_major}.{cc_minor}\",\n   \"te_available\": te_available,\n   \"fp8_available\": fp8_available,\n   \"fp8_reason\": fp8_reason,\n   \"mode\": mode_name,\n   \"baseline_eval_mse\": baseline_eval,\n   \"te_path_eval_mse\": te_eval,\n   \"baseline_mean_step_ms\": baseline_bench[\"mean_ms\"],\n   \"te_path_mean_step_ms\": te_bench[\"mean_ms\"],\n   \"baseline_peak_mem_mb\": baseline_bench[\"max_memory_mb\"],\n   \"te_path_peak_mem_mb\": te_bench[\"max_memory_mb\"],\n}\n\n\nprint(\"n\" + \"=\" * 120)\nprint(\"SUMMARY\")\nprint(\"=\" * 120)\nprint(json.dumps(summary, indent=2))\n\n\nplt.figure(figsize=(10, 5))\nplt.plot(baseline_losses, label=\"Baseline loss\")\nplt.plot(te_losses, label=f\"{mode_name} loss\")\nplt.xlabel(\"Training step\")\nplt.ylabel(\"MSE loss\")\nplt.title(\"Training Loss Comparison\")\nplt.legend()\nplt.grid(True)\nplt.show()\n\n\nplt.figure(figsize=(8, 5))\nplt.bar([\"Baseline\", mode_name], [baseline_bench[\"mean_ms\"], te_bench[\"mean_ms\"]])\nplt.ylabel(\"Mean train step time (ms)\")\nplt.title(\"Speed Comparison\")\nplt.grid(True, axis=\"y\")\nplt.show()\n\n\nplt.figure(figsize=(8, 5))\nplt.bar([\"Baseline\", mode_name], [baseline_bench[\"max_memory_mb\"], te_bench[\"max_memory_mb\"]])\nplt.ylabel(\"Peak memory (MB)\")\nplt.title(\"Peak CUDA Memory Comparison\")\nplt.grid(True, axis=\"y\")\nplt.show()<\/code><\/pre>\n<\/div>\n<\/div>\n
We gather all final metrics into a summary dictionary and print the experiment\u2019s consolidated results in a structured format. We then generate visualizations of training loss, mean training-step time, and peak memory usage to more intuitively interpret the differences between the baseline and TE paths. This final section helps us move from raw numbers to practical insights by showing how the two implementations behave across accuracy, speed, and memory.<\/p>\n
In conclusion, we built far more than a simple installation walkthrough; we created a complete experimental pipeline that helps us understand how the NVIDIA Transformer Engine fits into modern GPU-accelerated model training. We tested the runtime environment, adapted to Colab limitations, preserved a working fallback path, and then trained, evaluated, and benchmarked two implementations side by side to observe practical differences in efficiency, precision behavior, and resource usage. At the end, we understood how to use the Transformer Engine in a Colab-friendly setting and gained a reusable foundation that we can extend to larger transformer architectures, richer benchmarking scenarios, and more production-oriented optimization workflows.<\/p>\n
\n
Check out\u00a0the\u00a0Full Codes\/Notebook here<\/a>. \u00a0<\/strong>Also,\u00a0feel free to follow us on\u00a0Twitter<\/mark><\/a><\/strong>\u00a0and don\u2019t forget to join our\u00a0120k+ ML SubReddit<\/a><\/strong>\u00a0and Subscribe to\u00a0our Newsletter<\/a><\/strong>. Wait! are you on telegram?\u00a0now you can join us on telegram as well.<\/a><\/strong><\/p>\n
Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.?\u00a0Connect with us<\/a><\/strong><\/p>\n
The post An Implementation Guide to Running NVIDIA Transformer Engine with Mixed Precision, FP8 Checks, Benchmarking, and Fallback Execution<\/a> appeared first on MarkTechPost<\/a>.<\/p>","protected":false},"excerpt":{"rendered":"
In this tutorial, we implement…<\/p>\n","protected":false},"author":1,"featured_media":29,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-679","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/posts\/679","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=679"}],"version-history":[{"count":0,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/posts\/679\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/media\/29"}],"wp:attachment":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=679"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=679"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=679"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}