{"id":3422,"date":"2023-08-31T10:59:21","date_gmt":"2023-08-31T10:59:21","guid":{"rendered":"https:\/\/neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/"},"modified":"2025-11-28T10:47:01","modified_gmt":"2025-11-28T09:47:01","slug":"training-speed-comparison-gpu-approximation","status":"publish","type":"blog","link":"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/","title":{"rendered":"Training speed of TensorFlow, PyTorch, and Neural Designer"},"content":{"rendered":"\t\t<div data-elementor-type=\"wp-post\" data-elementor-id=\"3422\" class=\"elementor elementor-3422\" data-elementor-post-type=\"blog\">\n\t\t\t\t\t\t<section class=\"elementor-section elementor-top-section elementor-element elementor-element-2ed02c28 elementor-section-boxed elementor-section-height-default elementor-section-height-default\" data-id=\"2ed02c28\" data-element_type=\"section\">\n\t\t\t\t\t\t<div class=\"elementor-container elementor-column-gap-default\">\n\t\t\t\t\t<div class=\"elementor-column elementor-col-100 elementor-top-column elementor-element elementor-element-12759b4\" data-id=\"12759b4\" data-element_type=\"column\">\n\t\t\t<div class=\"elementor-widget-wrap elementor-element-populated\">\n\t\t\t\t\t\t<div class=\"elementor-element elementor-element-7d060f53 elementor-widget elementor-widget-text-editor\" data-id=\"7d060f53\" data-element_type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t\t\t\t\t\t<p>This post compares the GPU training speed of TensorFlow, PyTorch and Neural Designer for an approximation benchmark.<\/p><p><a href=\"https:\/\/tensorflow.org\/\">TensorFlow<\/a>, <a href=\"https:\/\/pytorch.org\/\">PyTorch<\/a> and <a href=\"https:\/\/www.neuraldesigner.com\/\">Neural Designer<\/a>\u00a0<span style=\"color: var( --e-global-color-text ); font-family: var( --e-global-typography-text-font-family ), Sans-serif; font-size: var( --e-global-typography-text-font-size ); font-weight: var( --e-global-typography-text-font-weight );\">are three popular machine learning platforms developed by\u00a0<\/span><a style=\"font-family: var( --e-global-typography-text-font-family ), Sans-serif; font-size: var( --e-global-typography-text-font-size ); font-weight: var( --e-global-typography-text-font-weight ); background-color: #ffffff;\" href=\"https:\/\/research.google\/teams\/brain\/\">Google<\/a><span style=\"color: var( --e-global-color-text ); font-family: var( --e-global-typography-text-font-family ), Sans-serif; font-size: var( --e-global-typography-text-font-size ); font-weight: var( --e-global-typography-text-font-weight );\">,\u00a0<\/span><a style=\"font-family: var( --e-global-typography-text-font-family ), Sans-serif; font-size: var( --e-global-typography-text-font-size ); font-weight: var( --e-global-typography-text-font-weight ); background-color: #ffffff;\" href=\"https:\/\/ai.facebook.com\/research\/\">Facebook<\/a><span style=\"color: var( --e-global-color-text ); font-family: var( --e-global-typography-text-font-family ), Sans-serif; font-size: var( --e-global-typography-text-font-size ); font-weight: var( --e-global-typography-text-font-weight );\"> and\u00a0<\/span><a style=\"font-family: var( --e-global-typography-text-font-family ), Sans-serif; font-size: var( --e-global-typography-text-font-size ); font-weight: var( --e-global-typography-text-font-weight ); background-color: #ffffff;\" href=\"https:\/\/www.artelnics.com\/\">Artelnics<\/a><span style=\"color: var( --e-global-color-text ); font-family: var( --e-global-typography-text-font-family ), Sans-serif; font-size: var( --e-global-typography-text-font-size ); font-weight: var( --e-global-typography-text-font-weight );\">, respectively.<\/span><\/p><section><p>Although all that frameworks are based on neural networks, they present some important differences in functionality, usability, performance, etc.<\/p><p>As we will see, Neural Designer trains this neural network <b>x1.55<\/b> times faster than TensorFlow and <b>x2.50<\/b> times faster than PyTorch in a NVIDIA Tesla T4.<\/p><p data-start=\"50\" data-end=\"154\">In this article, we outline all the steps required to reproduce the results using Neural Designer.<\/p><p><b>Contents:<\/b><\/p><ul><li><a href=\"#Introduction\">Introduction<\/a>.<\/li><li><a href=\"#BenchmarkApplication\">Benchmark application<\/a>.<\/li><li><a href=\"#ReferenceComputer\">Reference computer<\/a>.<\/li><li><a href=\"#Results\">Results<\/a>.<\/li><li><a href=\"#Conclusions\">Conclusions<\/a>.<\/li><\/ul><\/section><section id=\"Introduction\"><h2>Introduction<\/h2><p>One of the most important factors in machine learning platforms is their training speed. Indeed, modelling huge data sets is very expensive in computational terms.<\/p><p><img decoding=\"async\" style=\"width: 600px;\" src=\"https:\/\/www.neuraldesigner.com\/images\/training-speed-test-gpu-approximation.svg\" \/><\/p><p>Major machine learning tools use GPU computing techniques, such as NVIDIA CUDA, to speed up model training.<\/p><p>This article aims to measure the GPU training times of TensorFlow, PyTorch and Neural Designer for a benchmark application and compare the speeds obtained by those platforms.<\/p><p>The following table summarizes the technical features of these tools that might impact their GPU performance.<\/p><div style=\"overflow-x: auto;\"><table><thead><tr><th>\u00a0<\/th><th>TensorFlow<\/th><th>PyTorch<\/th><th>Neural Designer<\/th><\/tr><\/thead><tbody><tr><th>Written in<\/th><td>C++, CUDA, Python<\/td><td>C++, CUDA, Python<\/td><td>C++, CUDA<\/td><\/tr><tr><th>Interface<\/th><td>Python<\/td><td>Python<\/td><td>Graphical User Interface<\/td><\/tr><tr><th>Differentiation<\/th><td>Automatic<\/td><td>Automatic<\/td><td>Analytical<\/td><\/tr><\/tbody><\/table><\/div><p>The above table shows that TensorFlow and PyTorch are programmed in C++ and Python, while Neural Designer is entirely programmed in C++.<\/p><p>Interpreted languages like Python have some advantages over compiled languages like C ++, such as their ease of use.<\/p><p>However, the performance of Python is, in general, lower than that of C++. Indeed, Python takes significant time to interpret sentences during the program&#8217;s execution.<\/p><p>On the other hand, TensorFlow and PyTorch use automatic differentiation, while Neural Designer uses analytical differentiation.<\/p><p>As before, automatic differentiation has some advantages over analytical differentiation. Indeed, it simplifies obtaining the gradient for new architectures or loss indices.<\/p><p>However, the performance of automatic differentiation is, in general, lower than that of analytical differentiation: The first derives the gradient during the program&#8217;s execution, while the second has that formula pre-calculated.<\/p><p>Next, we measure the training speed for a benchmark problem on a reference computer using TensorFlow, PyTorch and Neural Designer. The results produced by that platforms are then compared.<\/p><\/section><section id=\"BenchmarkApplication\"><h2>Benchmark application<\/h2><p>The first step is to choose a benchmark application that is general enough to draw conclusions about the performance of the machine learning platforms. As previously stated, we will train a neural network that approximates a set of input-target samples.<\/p><p>In this regard, an approximation application is defined by a data set, a neural network and an associated training strategy.<br \/>The next table uniquely defines these three components.<\/p><div style=\"overflow-x: auto;\"><table><tbody><tr><th>Data set<br \/><img decoding=\"async\" class=\"small_left\" src=\"https:\/\/www.neuraldesigner.com\/images\/data_set.svg\" \/><\/th><td><ul><li>Benchmark: Rosenbrock<\/li><li>Inputs number: 1000<\/li><li>Targets number: 1<\/li><li>Samples number: 1000000<\/li><\/ul><\/td><\/tr><tr><th>Neural network<br \/><img decoding=\"async\" class=\"small_left\" src=\"https:\/\/www.neuraldesigner.com\/images\/neural_network.svg\" \/><\/th><td><ul><li>Layers number: 2<\/li><li>Layer 1:<br \/><ul style=\"list-style-type: none;\"><li>-Type: Perceptron (Dense)<\/li><li>-Inputs number: 1000<\/li><li>-Neurons number: 1000<\/li><li>-Activation function: Hyperbolic tangent (tanh)<\/li><\/ul><\/li><li>Layer 2:<br \/><ul style=\"list-style-type: none;\"><li>-Type: Perceptron (Dense)<\/li><li>-Inputs number: 1000<\/li><li>-Neurons number: 1<\/li><li>-Activation function: Linear<\/li><\/ul><\/li><li>Initialization: Random uniform [-1,1]<\/li><\/ul><\/td><\/tr><tr><th>Training strategy<br \/><img decoding=\"async\" class=\"small_left\" src=\"https:\/\/www.neuraldesigner.com\/images\/training_strategy.svg\" \/><\/th><td><ul><li>Loss index:<br \/><ul style=\"list-style-type: none;\"><li>-Error: Mean Squared Error (MSE)<\/li><li>-Regularization: None<\/li><\/ul><\/li><li>Optimization algorithm:<br \/><ul style=\"list-style-type: none;\"><li>-Algorithm: Adaptive Moment Estimation (Adam)<\/li><li>-Batch size: 1000<\/li><li>-Maximum epochs: 1000<\/li><\/ul><\/li><\/ul><\/td><\/tr><\/tbody><\/table><\/div><p>Once the TensorFlow, PyTorch and Neural Designer applications have been created, we need to run them.<\/p><\/section><section id=\"ReferenceComputer\"><h2>Reference computer<\/h2><p>The next step is to choose the computer to train the neural networks with TensorFlow, PyTorch and Neural Designer.<br \/>For training speed tests, the most important feature of the computer is the GPU or device card.<\/p><p>All calculations have been done on an Amazon Web Services instance to make the results easier to reproduce. The following table lists some basic information about the computer used here.<\/p><div style=\"overflow-x: auto;\"><table><thead><tr><th>Instance type:<\/th><td><a href=\"https:\/\/aws.amazon.com\/es\/ec2\/instance-types\/g4\/\">AWS g4dn.xlarge<\/a><\/td><\/tr><\/thead><tbody><tr><th>Operating system:<\/th><td>Windows 10 Enterprise<\/td><\/tr><tr><th>Processor:<\/th><td>CPU Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz<\/td><\/tr><tr><th>Physical RAM:<\/th><td>16.0 GB<\/td><\/tr><tr><th>Device (GPU):<\/th><td>NVIDIA Tesla T4<\/td><\/tr><\/tbody><\/table><\/div><p>Once the computer has been chosen, we install TensorFlow (2.1.0), PyTorch (1.7.0) and Neural Designer (5.0.4) on it.<\/p><p><!-- HTML generated using hilite.me --><\/p><div style=\"background: #ffffff; overflow: auto; width: auto; padding: .2em .6em;\"><pre style=\"margin: 0; line-height: 125%;\"><span style=\"color: #888888;\">#TENSORFLOW CODE<\/span>\n                <span style=\"color: #008800; font-weight: bold;\">import<\/span> <span style=\"color: #0e84b5; font-weight: bold;\">tensorflow<\/span> <span style=\"color: #008800; font-weight: bold;\">as<\/span> <span style=\"color: #0e84b5; font-weight: bold;\">tf<\/span>\n                <span style=\"color: #008800; font-weight: bold;\">import<\/span> <span style=\"color: #0e84b5; font-weight: bold;\">pandas<\/span> <span style=\"color: #008800; font-weight: bold;\">as<\/span> <span style=\"color: #0e84b5; font-weight: bold;\">pd<\/span>\n                <span style=\"color: #008800; font-weight: bold;\">import<\/span> <span style=\"color: #0e84b5; font-weight: bold;\">time<\/span>\n                <span style=\"color: #008800; font-weight: bold;\">import<\/span> <span style=\"color: #0e84b5; font-weight: bold;\">numpy<\/span> <span style=\"color: #008800; font-weight: bold;\">as<\/span> <span style=\"color: #0e84b5; font-weight: bold;\">np<\/span>\n\t\t\t\n                <span style=\"color: #888888;\">#read data float32<\/span>\n\tstart_time <span style=\"color: #333333;\">=<\/span> time<span style=\"color: #333333;\">.<\/span>time() \n\tfilename <span style=\"color: #333333;\">=<\/span> <span style=\"background-color: #fff0f0;\">\"C:\/R_new.csv\"<\/span>\n\tdf_test <span style=\"color: #333333;\">=<\/span> pd<span style=\"color: #333333;\">.<\/span>read_csv(filename, nrows<span style=\"color: #333333;\">=<\/span><span style=\"color: #0000dd; font-weight: bold;\">100<\/span>)\n\tfloat_cols <span style=\"color: #333333;\">=<\/span> [c <span style=\"color: #008800; font-weight: bold;\">for<\/span> c <span style=\"color: #000000; font-weight: bold;\">in<\/span> df_test <span style=\"color: #008800; font-weight: bold;\">if<\/span> df_test[c]<span style=\"color: #333333;\">.<\/span>dtype <span style=\"color: #333333;\">==<\/span> <span style=\"background-color: #fff0f0;\">\"float64\"<\/span>]\n\tfloat32_cols <span style=\"color: #333333;\">=<\/span> {c: np<span style=\"color: #333333;\">.<\/span>float32 <span style=\"color: #008800; font-weight: bold;\">for<\/span> c <span style=\"color: #000000; font-weight: bold;\">in<\/span> float_cols}\n\tdata <span style=\"color: #333333;\">=<\/span> pd<span style=\"color: #333333;\">.<\/span>read_csv(filename, engine<span style=\"color: #333333;\">=<\/span><span style=\"background-color: #fff0f0;\">'c'<\/span>, dtype<span style=\"color: #333333;\">=<\/span>float32_cols)\n                <span style=\"color: #008800; font-weight: bold;\">print<\/span>(<span style=\"background-color: #fff0f0;\">\"Loading time: \"<\/span>, <span style=\"color: #007020;\">round<\/span>(time<span style=\"color: #333333;\">.<\/span>time() <span style=\"color: #333333;\">-<\/span> start_time), <span style=\"background-color: #fff0f0;\">\" seconds\"<\/span>)\n\t\t\t\n\tx <span style=\"color: #333333;\">=<\/span> data<span style=\"color: #333333;\">.<\/span>iloc[:,:<span style=\"color: #333333;\">-<\/span><span style=\"color: #0000dd; font-weight: bold;\">1<\/span>]<span style=\"color: #333333;\">.<\/span>values\n\ty <span style=\"color: #333333;\">=<\/span> data<span style=\"color: #333333;\">.<\/span>iloc[:,[<span style=\"color: #333333;\">-<\/span><span style=\"color: #0000dd; font-weight: bold;\">1<\/span>]]<span style=\"color: #333333;\">.<\/span>values\n\t\t\t\n\tinitializer <span style=\"color: #333333;\">=<\/span> tf<span style=\"color: #333333;\">.<\/span>keras<span style=\"color: #333333;\">.<\/span>initializers<span style=\"color: #333333;\">.<\/span>RandomUniform(minval<span style=\"color: #333333;\">=-<\/span><span style=\"color: #6600ee; font-weight: bold;\">1.<\/span>, maxval<span style=\"color: #333333;\">=<\/span><span style=\"color: #6600ee; font-weight: bold;\">1.<\/span>)\n\t\t\t\t \n                <span style=\"color: #888888;\">#build model<\/span>\n\tmodel <span style=\"color: #333333;\">=<\/span> tf<span style=\"color: #333333;\">.<\/span>keras<span style=\"color: #333333;\">.<\/span>models<span style=\"color: #333333;\">.<\/span>Sequential([tf<span style=\"color: #333333;\">.<\/span>keras<span style=\"color: #333333;\">.<\/span>layers<span style=\"color: #333333;\">.<\/span>Dense(<span style=\"color: #0000dd; font-weight: bold;\">1000<\/span>, \n\t\t\t\t\t\t\t\t\t    activation <span style=\"color: #333333;\">=<\/span> <span style=\"background-color: #fff0f0;\">'tanh'<\/span>, \n\t\t\t\t\t\t\t\t\t    kernel_initializer <span style=\"color: #333333;\">=<\/span> initializer, \n\t\t\t\t\t\t\t\t\t    bias_initializer<span style=\"color: #333333;\">=<\/span>initializer),\n\t\t\t\t\t\t\ttf<span style=\"color: #333333;\">.<\/span>keras<span style=\"color: #333333;\">.<\/span>layers<span style=\"color: #333333;\">.<\/span>Dense(<span style=\"color: #0000dd; font-weight: bold;\">1<\/span>, \n\t\t\t\t\t\t\t\t\t    activation <span style=\"color: #333333;\">=<\/span> <span style=\"background-color: #fff0f0;\">'linear'<\/span>, \n\t\t\t\t\t\t\t\t\t    kernel_initializer <span style=\"color: #333333;\">=<\/span> initializer, \n\t\t\t\t\t\t\t\t\t    bias_initializer<span style=\"color: #333333;\">=<\/span>initializer)])\n\t\t\t\n                <span style=\"color: #888888;\">#compile model<\/span>\n\tmodel<span style=\"color: #333333;\">.<\/span>compile(optimizer<span style=\"color: #333333;\">=<\/span><span style=\"background-color: #fff0f0;\">'adam'<\/span>, loss <span style=\"color: #333333;\">=<\/span> <span style=\"background-color: #fff0f0;\">'mean_squared_error'<\/span>)\n\t\t\t\t\t\n                <span style=\"color: #888888;\">#train model<\/span>\n\tstart_time <span style=\"color: #333333;\">=<\/span> time<span style=\"color: #333333;\">.<\/span>time()\n\thistory <span style=\"color: #333333;\">=<\/span> model<span style=\"color: #333333;\">.<\/span>fit(x, y, batch_size <span style=\"color: #333333;\">=<\/span> <span style=\"color: #0000dd; font-weight: bold;\">1000<\/span>, epochs <span style=\"color: #333333;\">=<\/span> <span style=\"color: #0000dd; font-weight: bold;\">1000<\/span>)\n                <span style=\"color: #008800; font-weight: bold;\">print<\/span>(<span style=\"background-color: #fff0f0;\">\"Training time: \"<\/span>, <span style=\"color: #007020;\">round<\/span>(time<span style=\"color: #333333;\">.<\/span>time() <span style=\"color: #333333;\">-<\/span> start_time), <span style=\"background-color: #fff0f0;\">\" seconds\"<\/span>)\n\t\n            <\/pre><\/div><p>Building this application with PyTorch also requires some Python scripting. This code is listed below. Also, you can download <a href=\"https:\/\/www.neuraldesigner.com\/wp-content\/uploads\/2025\/07\/Final_pytorch-cpu.py_.zip\"> here.<\/a><\/p><div style=\"background: #ffffff; overflow: auto; width: auto; padding: .2em .6em;\"><pre style=\"margin: 0; line-height: 125%;\"><span style=\"color: #888888;\">#PYTORCH CODE\t<\/span>\n            <span style=\"color: #008800; font-weight: bold;\">import<\/span> <span style=\"color: #0e84b5; font-weight: bold;\">pandas<\/span> <span style=\"color: #008800; font-weight: bold;\">as<\/span> <span style=\"color: #0e84b5; font-weight: bold;\">pd<\/span>\n            <span style=\"color: #008800; font-weight: bold;\">import<\/span> <span style=\"color: #0e84b5; font-weight: bold;\">time<\/span>\n            <span style=\"color: #008800; font-weight: bold;\">import<\/span> <span style=\"color: #0e84b5; font-weight: bold;\">torch<\/span>\n            <span style=\"color: #008800; font-weight: bold;\">import<\/span> <span style=\"color: #0e84b5; font-weight: bold;\">numpy<\/span> <span style=\"color: #008800; font-weight: bold;\">as<\/span> <span style=\"color: #0e84b5; font-weight: bold;\">np<\/span>\n            <span style=\"color: #008800; font-weight: bold;\">import<\/span> <span style=\"color: #0e84b5; font-weight: bold;\">statistics<\/span>\n\t\n            <span style=\"color: #008800; font-weight: bold;\">def<\/span> <span style=\"color: #0066bb; font-weight: bold;\">init_weights<\/span>(m):\n            <span style=\"color: #008800; font-weight: bold;\">if<\/span> <span style=\"color: #007020;\">type<\/span>(m) <span style=\"color: #333333;\">==<\/span> torch<span style=\"color: #333333;\">.<\/span>nn<span style=\"color: #333333;\">.<\/span>Linear:\t\t\n\t\t\ttorch<span style=\"color: #333333;\">.<\/span>nn<span style=\"color: #333333;\">.<\/span>init<span style=\"color: #333333;\">.<\/span>uniform_(m<span style=\"color: #333333;\">.<\/span>weight, a<span style=\"color: #333333;\">=-<\/span><span style=\"color: #6600ee; font-weight: bold;\">1.0<\/span>, b<span style=\"color: #333333;\">=<\/span><span style=\"color: #6600ee; font-weight: bold;\">1.0<\/span>)\n\t\t\ttorch<span style=\"color: #333333;\">.<\/span>nn<span style=\"color: #333333;\">.<\/span>init<span style=\"color: #333333;\">.<\/span>uniform_(m<span style=\"color: #333333;\">.<\/span>bias<span style=\"color: #333333;\">.<\/span>data, a<span style=\"color: #333333;\">=-<\/span><span style=\"color: #6600ee; font-weight: bold;\">1.0<\/span>, b<span style=\"color: #333333;\">=<\/span><span style=\"color: #6600ee; font-weight: bold;\">1.0<\/span>)\n\t\t\t\t\t\t\n\tepoch <span style=\"color: #333333;\">=<\/span> <span style=\"color: #0000dd; font-weight: bold;\">1000<\/span>\n\ttotal_samples, batch_size, input_variables, hidden_neurons, output_variables <span style=\"color: #333333;\">=<\/span> <span style=\"color: #0000dd; font-weight: bold;\">1000000<\/span>, <span style=\"color: #0000dd; font-weight: bold;\">1000<\/span>, <span style=\"color: #0000dd; font-weight: bold;\">1000<\/span>, <span style=\"color: #0000dd; font-weight: bold;\">1000<\/span>, <span style=\"color: #0000dd; font-weight: bold;\">1<\/span>\n\tdevice <span style=\"color: #333333;\">=<\/span> torch<span style=\"color: #333333;\">.<\/span>device(<span style=\"background-color: #fff0f0;\">\"cuda:0\"<\/span>) \n\t\t\n            <span style=\"color: #888888;\"># read data float32<\/span>\n\tstart_time <span style=\"color: #333333;\">=<\/span> time<span style=\"color: #333333;\">.<\/span>time()\n\tfilename <span style=\"color: #333333;\">=<\/span> <span style=\"background-color: #fff0f0;\">\"C:\/R_new.csv\"<\/span>\n\tdf_test <span style=\"color: #333333;\">=<\/span> pd<span style=\"color: #333333;\">.<\/span>read_csv(filename, nrows<span style=\"color: #333333;\">=<\/span><span style=\"color: #0000dd; font-weight: bold;\">100<\/span>)\n\tfloat_cols <span style=\"color: #333333;\">=<\/span> [c <span style=\"color: #008800; font-weight: bold;\">for<\/span> c <span style=\"color: #000000; font-weight: bold;\">in<\/span> df_test <span style=\"color: #008800; font-weight: bold;\">if<\/span> df_test[c]<span style=\"color: #333333;\">.<\/span>dtype <span style=\"color: #333333;\">==<\/span> <span style=\"background-color: #fff0f0;\">\"float64\"<\/span>]\n\tfloat32_cols <span style=\"color: #333333;\">=<\/span> {c: np<span style=\"color: #333333;\">.<\/span>float32 <span style=\"color: #008800; font-weight: bold;\">for<\/span> c <span style=\"color: #000000; font-weight: bold;\">in<\/span> float_cols}\n\tdataset <span style=\"color: #333333;\">=<\/span> pd<span style=\"color: #333333;\">.<\/span>read_csv(filename, engine<span style=\"color: #333333;\">=<\/span><span style=\"background-color: #fff0f0;\">'c'<\/span>, dtype<span style=\"color: #333333;\">=<\/span>float32_cols)\n            <span style=\"color: #008800; font-weight: bold;\">print<\/span>(<span style=\"background-color: #fff0f0;\">\"Loading time: \"<\/span>, <span style=\"color: #007020;\">round<\/span>(time<span style=\"color: #333333;\">.<\/span>time() <span style=\"color: #333333;\">-<\/span> start_time), <span style=\"background-color: #fff0f0;\">\" seconds\"<\/span>)\n\t\t\n\tx <span style=\"color: #333333;\">=<\/span> torch<span style=\"color: #333333;\">.<\/span>tensor(dataset<span style=\"color: #333333;\">.<\/span>iloc[:,:<span style=\"color: #333333;\">-<\/span><span style=\"color: #0000dd; font-weight: bold;\">1<\/span>]<span style=\"color: #333333;\">.<\/span>values, dtype <span style=\"color: #333333;\">=<\/span> torch<span style=\"color: #333333;\">.<\/span>float32)\n\ty <span style=\"color: #333333;\">=<\/span> torch<span style=\"color: #333333;\">.<\/span>tensor(dataset<span style=\"color: #333333;\">.<\/span>iloc[:,[<span style=\"color: #333333;\">-<\/span><span style=\"color: #0000dd; font-weight: bold;\">1<\/span>]]<span style=\"color: #333333;\">.<\/span>values, dtype <span style=\"color: #333333;\">=<\/span> torch<span style=\"color: #333333;\">.<\/span>float32)\n            <span style=\"color: #888888;\"># build model<\/span>\n\tmodel <span style=\"color: #333333;\">=<\/span> torch<span style=\"color: #333333;\">.<\/span>nn<span style=\"color: #333333;\">.<\/span>Sequential(torch<span style=\"color: #333333;\">.<\/span>nn<span style=\"color: #333333;\">.<\/span>Linear(input_variables, hidden_neurons),\n\t\t\t\t\t\t\t\ttorch<span style=\"color: #333333;\">.<\/span>nn<span style=\"color: #333333;\">.<\/span>Tanh(),\n\t\t\t\t\t\t\t\ttorch<span style=\"color: #333333;\">.<\/span>nn<span style=\"color: #333333;\">.<\/span>Linear(hidden_neurons, output_variables))<span style=\"color: #333333;\">.<\/span>cuda()\n\t\t\n            <span style=\"color: #888888;\"># initialize weights<\/span>\n\tmodel<span style=\"color: #333333;\">.<\/span>apply(init_weights)\n\t\n            <span style=\"color: #888888;\"># compile model<\/span>\n\tlearning_rate <span style=\"color: #333333;\">=<\/span> <span style=\"color: #6600ee; font-weight: bold;\">0.001<\/span>\n\tloss_fn <span style=\"color: #333333;\">=<\/span> torch<span style=\"color: #333333;\">.<\/span>nn<span style=\"color: #333333;\">.<\/span>MSELoss(reduction <span style=\"color: #333333;\">=<\/span> <span style=\"background-color: #fff0f0;\">'mean'<\/span>)\n\toptimizer <span style=\"color: #333333;\">=<\/span> torch<span style=\"color: #333333;\">.<\/span>optim<span style=\"color: #333333;\">.<\/span>Adam(model<span style=\"color: #333333;\">.<\/span>parameters(), lr<span style=\"color: #333333;\">=<\/span>learning_rate)\n\t\t\t \n\tindices <span style=\"color: #333333;\">=<\/span> np<span style=\"color: #333333;\">.<\/span>arange(<span style=\"color: #0000dd; font-weight: bold;\">0<\/span>,total_samples)\n\t\t\t\t\n\tstart <span style=\"color: #333333;\">=<\/span> time<span style=\"color: #333333;\">.<\/span>time()\n\t\t\n            <span style=\"color: #008800; font-weight: bold;\">for<\/span> j <span style=\"color: #000000; font-weight: bold;\">in<\/span> <span style=\"color: #007020;\">range<\/span>(epoch):\n\t\t\t\t\t\n\t\tmse<span style=\"color: #333333;\">=<\/span>[]\n\t\t\t\t\t\n\t\tt0 <span style=\"color: #333333;\">=<\/span> time<span style=\"color: #333333;\">.<\/span>time()\n\t\t\t\t\t\n            <span style=\"color: #008800; font-weight: bold;\">for<\/span> i <span style=\"color: #000000; font-weight: bold;\">in<\/span> <span style=\"color: #007020;\">range<\/span>(<span style=\"color: #0000dd; font-weight: bold;\">0<\/span>, total_samples, batch_size):\n\t\t\t\t\t\t\n\t\t\tbatch_indices <span style=\"color: #333333;\">=<\/span> indices[i:i<span style=\"color: #333333;\">+<\/span>batch_size]\n\t\t\t\t\t\t\n\t\t\tbatch_x, batch_y <span style=\"color: #333333;\">=<\/span> x[batch_indices], y[batch_indices]\n\t\t\t\t\t\t\n\t\t\tbatch_x <span style=\"color: #333333;\">=<\/span> batch_x<span style=\"color: #333333;\">.<\/span>cuda()\n\t\t\t\t\t\t\n\t\t\tbatch_y <span style=\"color: #333333;\">=<\/span> batch_y<span style=\"color: #333333;\">.<\/span>cuda()\n\t\t\t\t\t\t\t\t\n\t\t\toutputs <span style=\"color: #333333;\">=<\/span> model<span style=\"color: #333333;\">.<\/span>forward(batch_x)\n\t\t\t\t\t\t\t\n\t\t\tloss <span style=\"color: #333333;\">=<\/span> loss_fn(outputs, batch_y)\n\t\t\t\t\t\t\t\n\t\t\tmodel<span style=\"color: #333333;\">.<\/span>zero_grad()\n\t\t\t\t\t\t\t   \n\t\t\tloss<span style=\"color: #333333;\">.<\/span>backward()\n\t\t\t\t\t\n\t\t\toptimizer<span style=\"color: #333333;\">.<\/span>step()\n\t\t\t\t\t\t\n\t\t\tmse<span style=\"color: #333333;\">.<\/span>append(loss<span style=\"color: #333333;\">.<\/span>item())\n\t\t\t\t\t\n            <span style=\"color: #008800; font-weight: bold;\">print<\/span>(<span style=\"background-color: #fff0f0;\">\"Epoch:\"<\/span>, j<span style=\"color: #333333;\">+<\/span><span style=\"color: #0000dd; font-weight: bold;\">1<\/span>,<span style=\"background-color: #fff0f0;\">\"\/1000\"<\/span>, <span style=\"background-color: #fff0f0;\">\"[================================] - \"<\/span>,<span style=\"background-color: #fff0f0;\">\"loss: \"<\/span>, statistics<span style=\"color: #333333;\">.<\/span>mean(mse))\n\t\t\t\t\t\n\t\tt1 <span style=\"color: #333333;\">=<\/span> time<span style=\"color: #333333;\">.<\/span>time() <span style=\"color: #333333;\">-<\/span> t0\n\t\t\t\t\t\n            <span style=\"color: #008800; font-weight: bold;\">print<\/span>(<span style=\"background-color: #fff0f0;\">\"Elapsed time: \"<\/span>, <span style=\"color: #007020;\">int<\/span>(<span style=\"color: #007020;\">round<\/span>(t1 )), <span style=\"background-color: #fff0f0;\">\"sec\"<\/span>)\n\t\t\t\t\t\n\tend <span style=\"color: #333333;\">=<\/span> time<span style=\"color: #333333;\">.<\/span>time()\n\t\t\n\telapsed <span style=\"color: #333333;\">=<\/span> end <span style=\"color: #333333;\">-<\/span> start\n\n            <span style=\"color: #008800; font-weight: bold;\">print<\/span>(<span style=\"background-color: #fff0f0;\">\"Training time: \"<\/span>,<span style=\"color: #007020;\">int<\/span>(<span style=\"color: #007020;\">round<\/span>(elapsed )), <span style=\"background-color: #fff0f0;\">\"seconds\"<\/span>)\n\n        <\/pre><\/div><p>Once the TensorFlow, PyTorch and Neural Designer applications have been created, we need to run them.<\/p><\/section><section id=\"Results\"><h2>Results<\/h2><p>The last step is to run the benchmark application on the selected machine with TensorFlow, PyTorch and Neural Designer and to compare the training times provided by those platforms.<\/p><p>The next figure shows the training results with TensorFlow.<\/p><p><img decoding=\"async\" style=\"width: 800px;\" src=\"https:\/\/www.neuraldesigner.com\/images\/Final-training-speed-tensorflow.webp\" \/><\/p><p>As we can see, TensorFlow takes 3,714 seconds (01:01:54) to train the neural network for 1000 epochs. The final mean squared error is 0.0003. With TensorFlow, the average GPU usage during training is 45% approximately.<\/p><p>Similarly, the following figure is a screenshot of PyTorch at the end of the process.<\/p><p><img decoding=\"async\" style=\"width: 800px;\" src=\"https:\/\/www.neuraldesigner.com\/images\/Final-training-speed-pytorch.webp\" \/><\/p><p>In this case, PyTorch takes 6,006 seconds (01:40:06) to train the neural network for 1000 epochs, reaching a mean squared error of 0.00593. With PyTorch, the average GPU usage during training is 40% approximately.<\/p><p>Finally, the following figure shows the training results with Neural Designer.<\/p><p><img decoding=\"async\" style=\"width: 300px;\" src=\"https:\/\/www.neuraldesigner.com\/images\/training-speed-gpu-approximation-time-neural-designer.webp\" \/><\/p><p>Neural Designer takes 2,395 seconds (00:39:55) to train the neural network for 1000 epochs. During that time, it reaches a mean squared error of 0.00981. With Neural Designer, the average GPU usage during training is 95% approximately.<\/p><p>The following table summarizes the the most important metrics that the three machine learning platforms yielded .<\/p><div style=\"overflow-x: auto;\"><table><thead><tr><th>\u00a0<\/th><th>TensorFlow<\/th><th>PyTorch<\/th><th>Neural Designer<\/th><\/tr><\/thead><tbody><tr><th>Training time<\/th><td style=\"text-align: right;\">01:01:54<\/td><td style=\"text-align: right;\">01:40:06<\/td><td style=\"text-align: right;\">00:39:55<\/td><\/tr><tr><th>Epoch time<\/th><td style=\"text-align: right;\">3.714 seconds\/epoch<\/td><td style=\"text-align: right;\">6.006 seconds\/epoch<\/td><td style=\"text-align: right;\">2.395 seconds\/epoch<\/td><\/tr><tr><th>Training speed<\/th><td style=\"text-align: right;\">269,251 samples\/second<\/td><td style=\"text-align: right;\">166,500 samples\/second<\/td><td style=\"text-align: right;\">417,537 samples\/second<\/td><\/tr><\/tbody><\/table><\/div><p>Finally, the following chart depicts the training speeds of TensorFlow, PyTorch and Neural Designer graphically for this case.<\/p><p><img decoding=\"async\" style=\"width: 800px;\" src=\"https:\/\/www.neuraldesigner.com\/images\/training-speed-gpu-approximation-results.svg\" \/><br \/><!--\t\t<img style=\"width:800px\"src=\"https:\/\/www.neuraldesigner.com\/images\/training-speed-test-gpu-approximation.svg\">--><\/p><p>As we can see, the training speed of Neural Designer for this application is <b>x1.55<\/b> times bigger than that of TensorFlow and <b>x2.50<\/b> times bigger than that of PyTorch.<\/p><\/section><section id=\"Conclusions\"><h2>Conclusions<\/h2><p>Neural Designer is entirely written in C ++, uses analytical differentiation, and has been optimized to minimize the number of operations during training.<\/p><p>This means that, for the benchmark described in this post, its training speed is <b>x1.55<\/b> times faster than that of TensorFlow and <b>x2.50<\/b> times faster than that of PyTorch.<\/p><p>To reproduce these results, <a href=\"https:\/\/www.neuraldesigner.com\/downloads\/\">download<\/a> Neural Designer and follow the steps described in this article.<\/p><\/section><section><h2>Related posts<\/h2><\/section>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t<\/div>\n\t\t","protected":false},"author":23,"featured_media":1415,"template":"","categories":[],"tags":[37],"class_list":["post-3422","blog","type-blog","status-publish","has-post-thumbnail","hentry","tag-platforms"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v26.4 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>Training speed of TensorFlow, PyTorch, and Neural Designer<\/title>\n<meta name=\"description\" content=\"Compare using Neural Designer the GPU training speed of TensorFlow, PyTorch, and Neural Designer for an approximation benchmark.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Training speed of TensorFlow, PyTorch, and Neural Designer\" \/>\n<meta property=\"og:description\" content=\"Compare using Neural Designer the GPU training speed of TensorFlow, PyTorch, and Neural Designer for an approximation benchmark.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/\" \/>\n<meta property=\"og:site_name\" content=\"Neural Designer\" \/>\n<meta property=\"article:modified_time\" content=\"2025-11-28T09:47:01+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.neuraldesigner.com\/wp-content\/uploads\/2023\/06\/training-speed-gpu-approximation-results-scaled.webp\" \/>\n\t<meta property=\"og:image:width\" content=\"2560\" \/>\n\t<meta property=\"og:image:height\" content=\"1337\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/webp\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:site\" content=\"@NeuralDesigner\" \/>\n<meta name=\"twitter:label1\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data1\" content=\"7 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/\",\"url\":\"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/\",\"name\":\"Training speed of TensorFlow, PyTorch, and Neural Designer\",\"isPartOf\":{\"@id\":\"https:\/\/www.neuraldesigner.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.neuraldesigner.com\/wp-content\/uploads\/2023\/06\/training-speed-gpu-approximation-results-scaled.webp\",\"datePublished\":\"2023-08-31T10:59:21+00:00\",\"dateModified\":\"2025-11-28T09:47:01+00:00\",\"description\":\"Compare using Neural Designer the GPU training speed of TensorFlow, PyTorch, and Neural Designer for an approximation benchmark.\",\"breadcrumb\":{\"@id\":\"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/#primaryimage\",\"url\":\"https:\/\/www.neuraldesigner.com\/wp-content\/uploads\/2023\/06\/training-speed-gpu-approximation-results-scaled.webp\",\"contentUrl\":\"https:\/\/www.neuraldesigner.com\/wp-content\/uploads\/2023\/06\/training-speed-gpu-approximation-results-scaled.webp\",\"width\":2560,\"height\":1337},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/www.neuraldesigner.com\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Blog\",\"item\":\"https:\/\/www.neuraldesigner.com\/blog\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Training speed of TensorFlow, PyTorch, and Neural Designer\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.neuraldesigner.com\/#website\",\"url\":\"https:\/\/www.neuraldesigner.com\/\",\"name\":\"Neural Designer\",\"description\":\"Explanable AI Platform\",\"publisher\":{\"@id\":\"https:\/\/www.neuraldesigner.com\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.neuraldesigner.com\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/www.neuraldesigner.com\/#organization\",\"name\":\"Neural Designer\",\"url\":\"https:\/\/www.neuraldesigner.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.neuraldesigner.com\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/www.neuraldesigner.com\/wp-content\/uploads\/2023\/05\/logo-neural-1.png\",\"contentUrl\":\"https:\/\/www.neuraldesigner.com\/wp-content\/uploads\/2023\/05\/logo-neural-1.png\",\"width\":1024,\"height\":223,\"caption\":\"Neural Designer\"},\"image\":{\"@id\":\"https:\/\/www.neuraldesigner.com\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/x.com\/NeuralDesigner\",\"https:\/\/es.linkedin.com\/showcase\/neuraldesigner\/\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Training speed of TensorFlow, PyTorch, and Neural Designer","description":"Compare using Neural Designer the GPU training speed of TensorFlow, PyTorch, and Neural Designer for an approximation benchmark.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/","og_locale":"en_US","og_type":"article","og_title":"Training speed of TensorFlow, PyTorch, and Neural Designer","og_description":"Compare using Neural Designer the GPU training speed of TensorFlow, PyTorch, and Neural Designer for an approximation benchmark.","og_url":"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/","og_site_name":"Neural Designer","article_modified_time":"2025-11-28T09:47:01+00:00","og_image":[{"width":2560,"height":1337,"url":"https:\/\/www.neuraldesigner.com\/wp-content\/uploads\/2023\/06\/training-speed-gpu-approximation-results-scaled.webp","type":"image\/webp"}],"twitter_card":"summary_large_image","twitter_site":"@NeuralDesigner","twitter_misc":{"Est. reading time":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/","url":"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/","name":"Training speed of TensorFlow, PyTorch, and Neural Designer","isPartOf":{"@id":"https:\/\/www.neuraldesigner.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/#primaryimage"},"image":{"@id":"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/#primaryimage"},"thumbnailUrl":"https:\/\/www.neuraldesigner.com\/wp-content\/uploads\/2023\/06\/training-speed-gpu-approximation-results-scaled.webp","datePublished":"2023-08-31T10:59:21+00:00","dateModified":"2025-11-28T09:47:01+00:00","description":"Compare using Neural Designer the GPU training speed of TensorFlow, PyTorch, and Neural Designer for an approximation benchmark.","breadcrumb":{"@id":"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/#primaryimage","url":"https:\/\/www.neuraldesigner.com\/wp-content\/uploads\/2023\/06\/training-speed-gpu-approximation-results-scaled.webp","contentUrl":"https:\/\/www.neuraldesigner.com\/wp-content\/uploads\/2023\/06\/training-speed-gpu-approximation-results-scaled.webp","width":2560,"height":1337},{"@type":"BreadcrumbList","@id":"https:\/\/www.neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.neuraldesigner.com\/"},{"@type":"ListItem","position":2,"name":"Blog","item":"https:\/\/www.neuraldesigner.com\/blog\/"},{"@type":"ListItem","position":3,"name":"Training speed of TensorFlow, PyTorch, and Neural Designer"}]},{"@type":"WebSite","@id":"https:\/\/www.neuraldesigner.com\/#website","url":"https:\/\/www.neuraldesigner.com\/","name":"Neural Designer","description":"Explanable AI Platform","publisher":{"@id":"https:\/\/www.neuraldesigner.com\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.neuraldesigner.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/www.neuraldesigner.com\/#organization","name":"Neural Designer","url":"https:\/\/www.neuraldesigner.com\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.neuraldesigner.com\/#\/schema\/logo\/image\/","url":"https:\/\/www.neuraldesigner.com\/wp-content\/uploads\/2023\/05\/logo-neural-1.png","contentUrl":"https:\/\/www.neuraldesigner.com\/wp-content\/uploads\/2023\/05\/logo-neural-1.png","width":1024,"height":223,"caption":"Neural Designer"},"image":{"@id":"https:\/\/www.neuraldesigner.com\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/x.com\/NeuralDesigner","https:\/\/es.linkedin.com\/showcase\/neuraldesigner\/"]}]}},"_links":{"self":[{"href":"https:\/\/www.neuraldesigner.com\/api\/wp\/v2\/blog\/3422","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.neuraldesigner.com\/api\/wp\/v2\/blog"}],"about":[{"href":"https:\/\/www.neuraldesigner.com\/api\/wp\/v2\/types\/blog"}],"author":[{"embeddable":true,"href":"https:\/\/www.neuraldesigner.com\/api\/wp\/v2\/users\/23"}],"version-history":[{"count":3,"href":"https:\/\/www.neuraldesigner.com\/api\/wp\/v2\/blog\/3422\/revisions"}],"predecessor-version":[{"id":21436,"href":"https:\/\/www.neuraldesigner.com\/api\/wp\/v2\/blog\/3422\/revisions\/21436"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.neuraldesigner.com\/api\/wp\/v2\/media\/1415"}],"wp:attachment":[{"href":"https:\/\/www.neuraldesigner.com\/api\/wp\/v2\/media?parent=3422"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.neuraldesigner.com\/api\/wp\/v2\/categories?post=3422"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.neuraldesigner.com\/api\/wp\/v2\/tags?post=3422"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}