{"id":3422,"date":"2026-04-08T12:55:35","date_gmt":"2026-04-08T10:55:35","guid":{"rendered":"https:\/\/neuraldesigner.com\/blog\/training-speed-comparison-gpu-approximation\/"},"modified":"2026-07-28T11:55:05","modified_gmt":"2026-07-28T09:55:05","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":"<style>.ndb{width:100vw;margin-left:calc(50% - 50vw);background:#eeeeee;padding:22px 24px 14px;font-family:\"Outfit\",\"Roboto\",Arial,sans-serif;color:#1b2635}.ndb *{box-sizing:border-box}.ndb a{text-decoration:none}.ndb-wrap{width:min(100%,1200px);margin:0 auto}.ndb-lead{font-size:18px;line-height:1.6;color:#3a4a5a;font-weight:300;margin:0 0 22px}.ndb-lead a{color:#2d799f;font-weight:600}.ndb-highlight{margin:0 0 36px;padding:28px 34px;border-radius:18px;background:linear-gradient(135deg,#56a1c8 0%,#245e80 100%);color:#fff;box-shadow:0 16px 34px rgba(30,83,116,.22)}.ndb-highlight p{margin:0;color:#fff;font-size:20px;line-height:1.5;font-weight:400}.ndb-highlight b{font-weight:800}.ndb-toc{list-style:none;display:flex;flex-wrap:wrap;gap:10px;justify-content:center;margin:0 0 42px;padding:0}.ndb-toc a{padding:10px 18px;background:#f2f2f2;border-radius:22px;color:#12354b!important;font-size:14px;font-weight:600;box-shadow:-6px -6px 12px rgba(255,255,255,.9),6px 6px 12px rgba(30,83,116,.10)}.ndb-toc a:hover{color:#2d799f!important}.ndb-card{margin:0 0 26px;padding:32px 40px;background:#f5f6f7;border-radius:20px;box-shadow:-12px -12px 24px rgba(255,255,255,.9),12px 12px 24px rgba(30,83,116,.10);scroll-margin-top:90px}.ndb-card h2{margin:0 0 20px;padding-bottom:12px;color:#001233;font-size:24px;font-weight:700;position:relative;border-bottom:1px solid #dbe5ec}.ndb-card h2:after{content:\"\";position:absolute;left:0;bottom:-1px;width:62px;height:3px;background:#56a1c8;border-radius:2px}.ndb-card p{margin:0 0 14px;font-size:16.5px;line-height:1.62;color:#33424f}.ndb-card a{color:#2d799f;font-weight:500}.ndb-card ul{margin:0 0 14px;padding-left:22px}.ndb-card li{margin:5px 0;font-size:16px;line-height:1.5;color:#33424f}.ndb-card img:not([src$=\".svg\"]):not([data-src$=\".svg\"]){display:block;width:auto;max-width:min(560px,100%);height:auto;margin:22px auto;border-radius:12px;box-shadow:0 12px 28px rgba(0,18,51,.12)}.ndb-card th img[src$=\".svg\"],.ndb-card th img[data-src$=\".svg\"],.ndb-card img[src$=\".svg\"],.ndb-card img[data-src$=\".svg\"]{display:inline-block;max-width:24px;height:auto;margin:0 6px -4px 0;box-shadow:none}.ndb-card table{border-collapse:separate;border-spacing:0;width:100%;max-width:100%;margin:22px 0;font-size:15px;background:#fbfcfd;border-radius:12px;overflow:hidden;box-shadow:0 10px 24px rgba(0,18,51,.08)}.ndb-card th,.ndb-card td{padding:11px 16px;border-bottom:1px solid #e6ecf0;text-align:left;vertical-align:top}.ndb-card thead th{background:#12354b;color:#fff;font-weight:600;text-align:center}.ndb-card tbody th{background:#e9f1f6;color:#12354b;font-weight:600}.ndb-card td{color:#33424f}.ndb-card table ul{margin:0;padding-left:18px}.ndb-card table li{font-size:14px}.ndb-card pre{margin:22px 0;padding:22px 24px;background:#0b1830!important;color:#e6eef5!important;border-radius:14px;overflow-x:auto;font-family:Consolas,Menlo,monospace;font-size:12.5px;line-height:1.5;white-space:pre}.ndb-card--accent{background:#e9f2f8}@media(max-width:820px){.ndb-card{padding:26px 22px}.ndb-card h2{font-size:21px}.ndb-toc{gap:8px}}@media(max-width:640px){.ndb{padding:12px 14px}}<\/style><div class=\"ndb\"><div class=\"ndb-wrap\"><div class=\"ndb-lead\"><p>Although all that frameworks are based on neural networks, they present some important differences in functionality, usability, performance, etc.<\/p>\n<p data-start=\"50\" data-end=\"154\">In this article, we outline all the steps required to reproduce the results using Neural Designer.<\/p>\n<\/div><div class=\"ndb-highlight\"><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>\n<\/div><ul class=\"ndb-toc\"><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><div class=\"ndb-card\" 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>\n<p><img decoding=\"async\" style=\"width: 600px;\" src=\"https:\/\/www.neuraldesigner.com\/images\/training-speed-test-gpu-approximation.svg\" \/><\/p>\n<p>Major machine learning tools use GPU computing techniques, such as NVIDIA CUDA, to speed up model training.<\/p>\n<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>\n<p>The following table summarizes the technical features of these tools that might impact their GPU performance.<\/p>\n<table>\n<thead>\n<tr>\n<th>\u00a0<\/th>\n<th>TensorFlow<\/th>\n<th>PyTorch<\/th>\n<th>Neural Designer<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<th>Written in<\/th>\n<td>C++, CUDA, Python<\/td>\n<td>C++, CUDA, Python<\/td>\n<td>C++, CUDA<\/td>\n<\/tr>\n<tr>\n<th>Interface<\/th>\n<td>Python<\/td>\n<td>Python<\/td>\n<td>Graphical User Interface<\/td>\n<\/tr>\n<tr>\n<th>Differentiation<\/th>\n<td>Automatic<\/td>\n<td>Automatic<\/td>\n<td>Analytical<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>The above table shows that TensorFlow and PyTorch are programmed in C++ and Python, while Neural Designer is entirely programmed in C++.<\/p>\n<p>Interpreted languages like Python have some advantages over compiled languages like C ++, such as their ease of use.<\/p>\n<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>\n<p>On the other hand, TensorFlow and PyTorch use automatic differentiation, while Neural Designer uses analytical differentiation.<\/p>\n<p>As before, automatic differentiation has some advantages over analytical differentiation. Indeed, it simplifies obtaining the gradient for new architectures or loss indices.<\/p>\n<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>\n<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>\n<\/div><div class=\"ndb-card\" 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>\n<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>\n<table>\n<tbody>\n<tr>\n<th>Data set<br \/><img decoding=\"async\" src=\"https:\/\/www.neuraldesigner.com\/images\/data_set.svg\" \/><\/th>\n<td>\n<ul>\n<li>Benchmark: Rosenbrock<\/li>\n<li>Inputs number: 1000<\/li>\n<li>Targets number: 1<\/li>\n<li>Samples number: 1000000<\/li>\n<\/ul>\n<\/td>\n<\/tr>\n<tr>\n<th>Neural network<br \/><img decoding=\"async\" src=\"https:\/\/www.neuraldesigner.com\/images\/neural_network.svg\" \/><\/th>\n<td>\n<ul>\n<li>Layers number: 2<\/li>\n<li>Layer 1:\n<ul style=\"list-style-type: none;\">\n<li>-Type: Perceptron (Dense)<\/li>\n<li>-Inputs number: 1000<\/li>\n<li>-Neurons number: 1000<\/li>\n<li>-Activation function: Hyperbolic tangent (tanh)<\/li>\n<\/ul>\n<\/li>\n<li>Layer 2:\n<ul style=\"list-style-type: none;\">\n<li>-Type: Perceptron (Dense)<\/li>\n<li>-Inputs number: 1000<\/li>\n<li>-Neurons number: 1<\/li>\n<li>-Activation function: Linear<\/li>\n<\/ul>\n<\/li>\n<li>Initialization: Random uniform [-1,1]<\/li>\n<\/ul>\n<\/td>\n<\/tr>\n<tr>\n<th>Training strategy<br \/><img decoding=\"async\" src=\"https:\/\/www.neuraldesigner.com\/images\/training_strategy.svg\" \/><\/th>\n<td>\n<ul>\n<li>Loss index:\n<ul style=\"list-style-type: none;\">\n<li>-Error: Mean Squared Error (MSE)<\/li>\n<li>-Regularization: None<\/li>\n<\/ul>\n<\/li>\n<li>Optimization algorithm:\n<ul style=\"list-style-type: none;\">\n<li>-Algorithm: Adaptive Moment Estimation (Adam)<\/li>\n<li>-Batch size: 1000<\/li>\n<li>-Maximum epochs: 1000<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Once the TensorFlow, PyTorch and Neural Designer applications have been created, we need to run them.<\/p>\n<\/div><div class=\"ndb-card\" 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>\n<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>\n<table>\n<thead>\n<tr>\n<th>Instance type:<\/th>\n<td><a href=\"https:\/\/aws.amazon.com\/es\/ec2\/instance-types\/g4\/\">AWS g4dn.xlarge<\/a><\/td>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<th>Operating system:<\/th>\n<td>Windows 10 Enterprise<\/td>\n<\/tr>\n<tr>\n<th>Processor:<\/th>\n<td>CPU Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz<\/td>\n<\/tr>\n<tr>\n<th>Physical RAM:<\/th>\n<td>16.0 GB<\/td>\n<\/tr>\n<tr>\n<th>Device (GPU):<\/th>\n<td>NVIDIA Tesla T4<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<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>\n<\/p>\n<pre style=\"margin: 0; line-height: 125%;\">#TENSORFLOW CODE\n                import tensorflow as tf\n                import pandas as pd\n                import time\n                import numpy as np\n                #read data float32\n\tstart_time = time.time() \n\tfilename = \"C:\/R_new.csv\"\n\tdf_test = pd.read_csv(filename, nrows=100)\n\tfloat_cols = [c for c in df_test if df_test[c].dtype == \"float64\"]\n\tfloat32_cols = {c: np.float32 for c in float_cols}\n\tdata = pd.read_csv(filename, engine='c', dtype=float32_cols)\n                print(\"Loading time: \", round(time.time() - start_time), \" seconds\")\n\tx = data.iloc[:,:-1].values\n\ty = data.iloc[:,[-1]].values\n\tinitializer = tf.keras.initializers.RandomUniform(minval=-1., maxval=1.)\n                #build model\n\tmodel = tf.keras.models.Sequential([tf.keras.layers.Dense(1000, \n\t\t\t\t\t\t\t\t\t    activation = 'tanh', \n\t\t\t\t\t\t\t\t\t    kernel_initializer = initializer, \n\t\t\t\t\t\t\t\t\t    bias_initializer=initializer),\n\t\t\t\t\t\t\ttf.keras.layers.Dense(1, \n\t\t\t\t\t\t\t\t\t    activation = 'linear', \n\t\t\t\t\t\t\t\t\t    kernel_initializer = initializer, \n\t\t\t\t\t\t\t\t\t    bias_initializer=initializer)])\n                #compile model\n\tmodel.compile(optimizer='adam', loss = 'mean_squared_error')\n                #train model\n\tstart_time = time.time()\n\thistory = model.fit(x, y, batch_size = 1000, epochs = 1000)\n                print(\"Training time: \", round(time.time() - start_time), \" seconds\")\n            <\/pre>\n<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>\n<pre style=\"margin: 0; line-height: 125%;\">#PYTORCH CODE\t\n            import pandas as pd\n            import time\n            import torch\n            import numpy as np\n            import statistics\n            def init_weights(m):\n            if type(m) == torch.nn.Linear:\t\t\n\t\t\ttorch.nn.init.uniform_(m.weight, a=-1.0, b=1.0)\n\t\t\ttorch.nn.init.uniform_(m.bias.data, a=-1.0, b=1.0)\n\tepoch = 1000\n\ttotal_samples, batch_size, input_variables, hidden_neurons, output_variables = 1000000, 1000, 1000, 1000, 1\n\tdevice = torch.device(\"cuda:0\") \n            # read data float32\n\tstart_time = time.time()\n\tfilename = \"C:\/R_new.csv\"\n\tdf_test = pd.read_csv(filename, nrows=100)\n\tfloat_cols = [c for c in df_test if df_test[c].dtype == \"float64\"]\n\tfloat32_cols = {c: np.float32 for c in float_cols}\n\tdataset = pd.read_csv(filename, engine='c', dtype=float32_cols)\n            print(\"Loading time: \", round(time.time() - start_time), \" seconds\")\n\tx = torch.tensor(dataset.iloc[:,:-1].values, dtype = torch.float32)\n\ty = torch.tensor(dataset.iloc[:,[-1]].values, dtype = torch.float32)\n            # build model\n\tmodel = torch.nn.Sequential(torch.nn.Linear(input_variables, hidden_neurons),\n\t\t\t\t\t\t\t\ttorch.nn.Tanh(),\n\t\t\t\t\t\t\t\ttorch.nn.Linear(hidden_neurons, output_variables)).cuda()\n            # initialize weights\n\tmodel.apply(init_weights)\n            # compile model\n\tlearning_rate = 0.001\n\tloss_fn = torch.nn.MSELoss(reduction = 'mean')\n\toptimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n\tindices = np.arange(0,total_samples)\n\tstart = time.time()\n            for j in range(epoch):\n\t\tmse=[]\n\t\tt0 = time.time()\n            for i in range(0, total_samples, batch_size):\n\t\t\tbatch_indices = indices[i:i+batch_size]\n\t\t\tbatch_x, batch_y = x[batch_indices], y[batch_indices]\n\t\t\tbatch_x = batch_x.cuda()\n\t\t\tbatch_y = batch_y.cuda()\n\t\t\toutputs = model.forward(batch_x)\n\t\t\tloss = loss_fn(outputs, batch_y)\n\t\t\tmodel.zero_grad()\n\t\t\tloss.backward()\n\t\t\toptimizer.step()\n\t\t\tmse.append(loss.item())\n            print(\"Epoch:\", j+1,\"\/1000\", \"[================================] - \",\"loss: \", statistics.mean(mse))\n\t\tt1 = time.time() - t0\n            print(\"Elapsed time: \", int(round(t1 )), \"sec\")\n\tend = time.time()\n\telapsed = end - start\n            print(\"Training time: \",int(round(elapsed )), \"seconds\")\n        <\/pre>\n<p>Once the TensorFlow, PyTorch and Neural Designer applications have been created, we need to run them.<\/p>\n<\/div><div class=\"ndb-card\" 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>\n<p>The next figure shows the training results with TensorFlow.<\/p>\n<p><img decoding=\"async\" style=\"width: 800px;\" src=\"https:\/\/www.neuraldesigner.com\/images\/Final-training-speed-tensorflow.webp\" \/><\/p>\n<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>\n<p>Similarly, the following figure is a screenshot of PyTorch at the end of the process.<\/p>\n<p><img decoding=\"async\" style=\"width: 800px;\" src=\"https:\/\/www.neuraldesigner.com\/images\/Final-training-speed-pytorch.webp\" \/><\/p>\n<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>\n<p>Finally, the following figure shows the training results with Neural Designer.<\/p>\n<p><img decoding=\"async\" style=\"width: 300px;\" src=\"https:\/\/www.neuraldesigner.com\/images\/training-speed-gpu-approximation-time-neural-designer.webp\" \/><\/p>\n<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>\n<p>The following table summarizes the the most important metrics that the three machine learning platforms yielded .<\/p>\n<table>\n<thead>\n<tr>\n<th>\u00a0<\/th>\n<th>TensorFlow<\/th>\n<th>PyTorch<\/th>\n<th>Neural Designer<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<th>Training time<\/th>\n<td style=\"text-align: right;\">01:01:54<\/td>\n<td style=\"text-align: right;\">01:40:06<\/td>\n<td style=\"text-align: right;\">00:39:55<\/td>\n<\/tr>\n<tr>\n<th>Epoch time<\/th>\n<td style=\"text-align: right;\">3.714 seconds\/epoch<\/td>\n<td style=\"text-align: right;\">6.006 seconds\/epoch<\/td>\n<td style=\"text-align: right;\">2.395 seconds\/epoch<\/td>\n<\/tr>\n<tr>\n<th>Training speed<\/th>\n<td style=\"text-align: right;\">269,251 samples\/second<\/td>\n<td style=\"text-align: right;\">166,500 samples\/second<\/td>\n<td style=\"text-align: right;\">417,537 samples\/second<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Finally, the following chart depicts the training speeds of TensorFlow, PyTorch and Neural Designer graphically for this case.<\/p>\n<p><img decoding=\"async\" style=\"width: 800px;\" src=\"https:\/\/www.neuraldesigner.com\/images\/training-speed-gpu-approximation-results.svg\" \/><\/p>\n<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>\n<\/div><div class=\"ndb-card ndb-card--accent\" 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>\n<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>\n<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>\n<\/div><\/div><\/div>","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=\"2026-07-28T09:55:05+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\":\"2026-04-08T10:55:35+00:00\",\"dateModified\":\"2026-07-28T09:55:05+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,\"caption\":\"GPU approximation training speed results\"},{\"@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":"2026-07-28T09:55:05+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":"2026-04-08T10:55:35+00:00","dateModified":"2026-07-28T09:55:05+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,"caption":"GPU approximation training speed results"},{"@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":5,"href":"https:\/\/www.neuraldesigner.com\/api\/wp\/v2\/blog\/3422\/revisions"}],"predecessor-version":[{"id":22798,"href":"https:\/\/www.neuraldesigner.com\/api\/wp\/v2\/blog\/3422\/revisions\/22798"}],"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}]}}