{"id":33,"date":"2017-10-20T07:00:05","date_gmt":"2017-10-20T07:00:05","guid":{"rendered":"https:\/\/blogs.mathworks.com\/deep-learning\/?p=33"},"modified":"2021-04-06T15:52:53","modified_gmt":"2021-04-06T19:52:53","slug":"deep-learning-with-gpus-and-matlab","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/deep-learning\/2017\/10\/20\/deep-learning-with-gpus-and-matlab\/","title":{"rendered":"Deep Learning with GPUs and MATLAB"},"content":{"rendered":"<div class=\"content\"><!--introduction-->\r\n\r\n<p style=\"font-size:14px\">Hi There! While most of the information in this post is correct, this is an original post from 2017 and the world of GPUs changes rapidly. I would encourage you to check out a newer resource on GPUs here:\r\n\r\n<a href=\"https:\/\/explore.mathworks.com\/all-about-gpus\">https:\/\/explore.mathworks.com\/all-about-gpus<\/a>\r\n\r\n<\/p>\r\n\r\n\r\n<p>MATLAB users ask us a lot of questions about GPUs, and today I want to answer some of them. I hope you'll come away with a basic sense of how to choose a GPU card to help you with deep learning in MATLAB.<\/p><p>I asked Ben Tordoff for help. I first met Ben about 12 years ago, when he was giving the Image Processing Toolbox development a LOT of feedback about our functions. Since then, he has moved into software development, and he now leads the team responsible for GPU, distributed, and tall array support in MATLAB and the Parallel Computing Toolbox.<\/p><p><img decoding=\"async\" vspace=\"5\" hspace=\"5\" src=\"https:\/\/www.mathworks.com\/matlabcentral\/profiles\/1297191.jpg\" alt=\"\"> <\/p><!--\/introduction--><h3>Contents<\/h3><div><ul><li><a href=\"#fd7aa554-156e-4c33-b2d2-b097776e28dd\">Getting information about your GPU card<\/a><\/li><li><a href=\"#37158a84-1394-4f18-bee6-a84702706b8e\">GPUBench<\/a><\/li><li><a href=\"#641a45df-2e48-4342-92a3-75eda4d8ac67\">Types of NVIDIA GPU cards<\/a><\/li><li><a href=\"#bcc6fa04-859e-4f38-9cfe-10c0f662cb78\">Comparing CPU and GPU speed for deep learning<\/a><\/li><\/ul><\/div><h4>Getting information about your GPU card<a name=\"fd7aa554-156e-4c33-b2d2-b097776e28dd\"><\/a><\/h4><p>The function <tt>gpuDevice<\/tt> tells you about your GPU hardware. I asked Ben to walk me through the output of <tt>gpuDevice<\/tt> on my computer.<\/p><pre class=\"codeinput\">gpuDevice\r\n<\/pre><pre class=\"codeoutput\">\r\nans = \r\n\r\n  CUDADevice with properties:\r\n\r\n                      Name: 'TITAN Xp'\r\n                     Index: 1\r\n         ComputeCapability: '6.1'\r\n            SupportsDouble: 1\r\n             DriverVersion: 9\r\n            ToolkitVersion: 8\r\n        MaxThreadsPerBlock: 1024\r\n          MaxShmemPerBlock: 49152\r\n        MaxThreadBlockSize: [1024 1024 64]\r\n               MaxGridSize: [2.1475e+09 65535 65535]\r\n                 SIMDWidth: 32\r\n               TotalMemory: 1.2885e+10\r\n           AvailableMemory: 1.0425e+10\r\n       MultiprocessorCount: 30\r\n              ClockRateKHz: 1582000\r\n               ComputeMode: 'Default'\r\n      GPUOverlapsTransfers: 1\r\n    KernelExecutionTimeout: 1\r\n          CanMapHostMemory: 1\r\n           DeviceSupported: 1\r\n            DeviceSelected: 1\r\n\r\n<\/pre><p>Ben: \"That's a Titan Xp card. You've got a pretty good GPU there -- a lot better than the one I've got, at least for deep learning.\" (I'll explain this comment below.)<\/p><p>\"An Index of 1 means that the NVIDIA driver thinks this GPU is the most powerful one installed on your computer. And <tt>ComputeCapability<\/tt> refers to the generation of computation capability supported by this card. The sixth generation is known as Pascal.\" As of the R2017b release, GPU computing with MATLAB and Parallel Computing Toolbox requires a <tt>ComputeCapability<\/tt> of at least 3.0.<\/p><p>The other information provided by <tt>gpuDevice<\/tt> is mostly useful to the developers writing low-level GPU computation routines, or for troubleshooting. There's one other number, though, that might be helpful to you when comparing GPUs. The <tt>MultiprocessorCount<\/tt> is effectively the number of chips on the GPU. \"The difference between a high end card and a low end card within the same generation often comes down to the number of chips available.\"<\/p><h4>GPUBench<a name=\"37158a84-1394-4f18-bee6-a84702706b8e\"><\/a><\/h4><p>The next thing Ben and I discussed was the output of GPUBench, a GPU performance measurement tool maintained by Ben's team. You can get it from the <a href=\"https:\/\/www.mathworks.com\/matlabcentral\/fileexchange\/340-saveppt-gpubench\">MATLAB Central File Exchange<\/a>. Here's a portion of the report:<\/p><p><img decoding=\"async\" vspace=\"5\" hspace=\"5\" src=\"https:\/\/blogs.mathworks.com\/deep-learning\/files\/2017\/10\/gpu-report-snap.png\" alt=\"\"> <\/p><p><i>GFLOP<\/i> is a unit of computational speed. 1 GFLOP is roughly 1 billion floating point operations per second. The report measures computational speed for both double-precision and single-precision floating point. Some cards excel at double precision, and some do better at single precision. The report shows the best double precision cards at the top because that is most important for general MATLAB computing.<\/p><p>The report includes three different computational benchmarks: MTimes (matrix multiplication), backslash (linear system solving), and FFT. The matrix multiplication benchmark is best at measuring pure computation speed, and so it has the highest GFLOP numbers. The FFT and backslash benchmarks, on the other hand, involve more of a mixture of computation and I\/O, so the reported GFLOP rates are lower.<\/p><p>My Titan Xp card is better than my CPU (\"Host PC\" in the table above) for double precision computing, but it's definitely slower than the top cards listed. So, why did Ben tell me that my card was so good for deep learning? It's because of the right-hand column of the report, which focuses on <i>single-precision computation<\/i>. For image processing and deep learning, single-precision speed is more important than double-precision speed.<\/p><p>And the Titan Xp is blazingly fast at single-precision computation, with a whopping 11,000 GFLOPS for matrix multiplication with large matrices. If you're interested, you can drill into the GPUBench report for more details, like this:<\/p><p><img decoding=\"async\" vspace=\"5\" hspace=\"5\" src=\"https:\/\/blogs.mathworks.com\/deep-learning\/files\/2017\/10\/device4-MTimes-single.png\" alt=\"\"> <\/p><h4>Types of NVIDIA GPU cards<a name=\"641a45df-2e48-4342-92a3-75eda4d8ac67\"><\/a><\/h4><p>I asked Ben for a little help understanding the wide variety of GPU cards made by NVIDIA. \"Well, for deep learning, you can probably focus just on three lines of cards: GeForce, Titan, and Tesla. The GeForce cards are the cheapest ones with decent compute performance, but you have to keep in mind that they don't work if you are using remote desktop software. The Titan is kind of a souped-up version of GeForce that does have remote desktop support. And the Tesla cards are intended as high-performance cards for compute servers in double-precision applications.\"<\/p><h4>Comparing CPU and GPU speed for deep learning<a name=\"bcc6fa04-859e-4f38-9cfe-10c0f662cb78\"><\/a><\/h4><p>Many of the deep learning functions in Neural Network Toolbox and other products now support an option called <tt>'ExecutionEnvironment'<\/tt>. The choices are: <tt>'auto'<\/tt>, <tt>'cpu'<\/tt>, <tt>'gpu'<\/tt>, <tt>'multi-gpu'<\/tt>, and <tt>'parallel'<\/tt>. You can use this option to try some network training and prediction computations to measure the practical GPU impact on deep learning on your own computer.<\/p><p>I'm going to experiment with this option using the <a href=\"https:\/\/www.mathworks.com\/help\/nnet\/examples\/train-a-convolutional-neural-network-for-regression.html\">\"Train a Convolutional Neural Network for Regression\" example<\/a>. I'm just going to do the training step here, not the full example. First, I'll use my GPU.<\/p><pre class=\"codeinput\">options = trainingOptions(<span class=\"string\">'sgdm'<\/span>,<span class=\"string\">'InitialLearnRate'<\/span>,0.001, <span class=\"keyword\">...<\/span>\r\n    <span class=\"string\">'MaxEpochs'<\/span>,15);\r\nnet = trainNetwork(trainImages,trainAngles,layers,options);\r\n<\/pre><pre class=\"codeoutput\">Training on single GPU.\r\nInitializing image normalization.\r\n|=========================================================================================|\r\n|     Epoch    |   Iteration  | Time Elapsed |  Mini-batch  |  Mini-batch  | Base Learning|\r\n|              |              |  (seconds)   |     Loss     |     RMSE     |     Rate     |\r\n|=========================================================================================|\r\n|            1 |            1 |         0.01 |     352.3131 |        26.54 |       0.0010 |\r\n|            2 |           50 |         0.75 |     114.6249 |        15.14 |       0.0010 |\r\n|            3 |          100 |         1.40 |      69.1581 |        11.76 |       0.0010 |\r\n|            4 |          150 |         2.04 |      52.7575 |        10.27 |       0.0010 |\r\n|            6 |          200 |         2.69 |      54.4214 |        10.43 |       0.0010 |\r\n|            7 |          250 |         3.33 |      40.6091 |         9.01 |       0.0010 |\r\n|            8 |          300 |         3.97 |      29.9065 |         7.73 |       0.0010 |\r\n|            9 |          350 |         4.63 |      28.4160 |         7.54 |       0.0010 |\r\n|           11 |          400 |         5.28 |      28.4920 |         7.55 |       0.0010 |\r\n|           12 |          450 |         5.92 |      21.7896 |         6.60 |       0.0010 |\r\n|           13 |          500 |         6.56 |      22.7835 |         6.75 |       0.0010 |\r\n|           15 |          550 |         7.20 |      24.8388 |         7.05 |       0.0010 |\r\n|           15 |          585 |         7.66 |      17.7162 |         5.95 |       0.0010 |\r\n|=========================================================================================|\r\n<\/pre><p>You can see in the \"Elapsed Time\" column that the training for this simple example took about 8 seconds.<\/p><p>Now let's repeat the training using just the CPU.<\/p><pre class=\"codeinput\">options = trainingOptions(<span class=\"string\">'sgdm'<\/span>,<span class=\"string\">'InitialLearnRate'<\/span>,0.001, <span class=\"keyword\">...<\/span>\r\n    <span class=\"string\">'MaxEpochs'<\/span>,15,<span class=\"string\">'ExecutionEnvironment'<\/span>,<span class=\"string\">'cpu'<\/span>);\r\nnet = trainNetwork(trainImages,trainAngles,layers,options);\r\n<\/pre><pre class=\"codeoutput\">Initializing image normalization.\r\n|=========================================================================================|\r\n|     Epoch    |   Iteration  | Time Elapsed |  Mini-batch  |  Mini-batch  | Base Learning|\r\n|              |              |  (seconds)   |     Loss     |     RMSE     |     Rate     |\r\n|=========================================================================================|\r\n|            1 |            1 |         0.17 |     354.9253 |        26.64 |       0.0010 |\r\n|            2 |           50 |         6.74 |     117.6613 |        15.34 |       0.0010 |\r\n|            3 |          100 |        13.31 |      92.0581 |        13.57 |       0.0010 |\r\n|            4 |          150 |        20.10 |      57.7432 |        10.75 |       0.0010 |\r\n|            6 |          200 |        26.66 |      50.4582 |        10.05 |       0.0010 |\r\n|            7 |          250 |        33.35 |      35.4191 |         8.42 |       0.0010 |\r\n|            8 |          300 |        40.06 |      30.0699 |         7.75 |       0.0010 |\r\n|            9 |          350 |        46.70 |      24.5073 |         7.00 |       0.0010 |\r\n|           11 |          400 |        53.35 |      28.2483 |         7.52 |       0.0010 |\r\n|           12 |          450 |        59.95 |      23.1092 |         6.80 |       0.0010 |\r\n|           13 |          500 |        66.54 |      18.9768 |         6.16 |       0.0010 |\r\n|           15 |          550 |        73.10 |      15.1666 |         5.51 |       0.0010 |\r\n|           15 |          585 |        77.78 |      20.5303 |         6.41 |       0.0010 |\r\n|=========================================================================================|\r\n<\/pre><p>That took about 10 times longer than training using the GPU. For realistic networks, we expect the difference to be even greater. With more powerful deep learning networks that take hours or days to train, you can see why we recommend using a good GPU for substantial deep learning work.<\/p><p>I hope you find this information helpful. Good luck setting up your own deep learning system with MATLAB!<\/p><p>PS. Thanks, Ben!<\/p><script language=\"JavaScript\"> <!-- \r\n    function grabCode_7a02c326deef405a8f9a26dbad638b7b() {\r\n        \/\/ Remember the title so we can use it in the new page\r\n        title = document.title;\r\n\r\n        \/\/ Break up these strings so that their presence\r\n        \/\/ in the Javascript doesn't mess up the search for\r\n        \/\/ the MATLAB code.\r\n        t1='7a02c326deef405a8f9a26dbad638b7b ' + '##### ' + 'SOURCE BEGIN' + ' #####';\r\n        t2='##### ' + 'SOURCE END' + ' #####' + ' 7a02c326deef405a8f9a26dbad638b7b';\r\n    \r\n        b=document.getElementsByTagName('body')[0];\r\n        i1=b.innerHTML.indexOf(t1)+t1.length;\r\n        i2=b.innerHTML.indexOf(t2);\r\n \r\n        code_string = b.innerHTML.substring(i1, i2);\r\n        code_string = code_string.replace(\/REPLACE_WITH_DASH_DASH\/g,'--');\r\n\r\n        \/\/ Use \/x3C\/g instead of the less-than character to avoid errors \r\n        \/\/ in the XML parser.\r\n        \/\/ Use '\\x26#60;' instead of '<' so that the XML parser\r\n        \/\/ doesn't go ahead and substitute the less-than character. \r\n        code_string = code_string.replace(\/\\x3C\/g, '\\x26#60;');\r\n\r\n        copyright = 'Copyright 2017 The MathWorks, Inc.';\r\n\r\n        w = window.open();\r\n        d = w.document;\r\n        d.write('<pre>\\n');\r\n        d.write(code_string);\r\n\r\n        \/\/ Add copyright line at the bottom if specified.\r\n        if (copyright.length > 0) {\r\n            d.writeln('');\r\n            d.writeln('%%');\r\n            if (copyright.length > 0) {\r\n                d.writeln('% _' + copyright + '_');\r\n            }\r\n        }\r\n\r\n        d.write('<\/pre>\\n');\r\n\r\n        d.title = title + ' (MATLAB code)';\r\n        d.close();\r\n    }   \r\n     --> <\/script><p style=\"text-align: right; font-size: xx-small; font-weight:lighter;   font-style: italic; color: gray\"><br><a href=\"javascript:grabCode_7a02c326deef405a8f9a26dbad638b7b()\"><span style=\"font-size: x-small;        font-style: italic;\">Get \r\n      the MATLAB code <noscript>(requires JavaScript)<\/noscript><\/span><\/a><br><br>\r\n      Published with MATLAB&reg; R2017b<br><\/p><\/div><!--\r\n7a02c326deef405a8f9a26dbad638b7b ##### SOURCE BEGIN #####\r\n%% GPU Cards and Deep Learning with MATLAB\r\n% MATLAB users ask us a lot of questions about GPUs, and today I want to answer\r\n% some of them. I hope you'll come away with a basic sense of how to choose\r\n% a GPU card to help you with deep learning in MATLAB.\r\n%\r\n% I asked Ben Tordoff for help. I first met Ben about 12\r\n% years ago, when he was giving the Image Processing Toolbox development a\r\n% LOT of feedback about our functions. Since then, he has moved into software\r\n% development, and he now leads the team responsible for GPU,\r\n% distributed, and tall array support in MATLAB and the Parallel Computing\r\n% Toolbox.\r\n%\r\n% <<https:\/\/www.mathworks.com\/matlabcentral\/profiles\/1297191.jpg>>\r\n%\r\n%% Getting information about your GPU card\r\n% The function |gpuDevice| tells you about your GPU hardware.\r\n% I asked Ben to walk me through the output of |gpuDevice| on my computer.\r\n\r\ngpuDevice\r\n\r\n%%\r\n% Ben: \"That's a Titan Xp card. You've got a pretty good GPU there REPLACE_WITH_DASH_DASH a lot\r\n% better than the one I've got, at least for deep learning.\" (I'll explain\r\n% this comment below.)\r\n%\r\n% \"An Index of 1 means that the NVIDIA driver thinks this GPU is the most\r\n% powerful one installed on your computer. And |ComputeCapability|\r\n% refers to the generation of computation capability supported by this\r\n% card. The sixth generation is known as Pascal.\" As of the R2017b release, GPU\r\n% computing with MATLAB and Parallel Computing Toolbox requires a\r\n% |ComputeCapability| of at least 3.0.\r\n%\r\n% The other information provided by |gpuDevice| is mostly useful to\r\n% the developers writing low-level GPU computation routines, or for\r\n% troubleshooting. There's one other number, though, that might be helpful to you\r\n% when comparing GPUs. The |MultiprocessorCount| is effectively the number\r\n% of chips on the GPU. \"The difference between a high end card and a low\r\n% end card within the same generation often comes down to the number of\r\n% chips available.\"\r\n%\r\n%% GPUBench\r\n% The next thing Ben and I discussed was the output of GPUBench, a GPU\r\n% performance measurement tool maintained by Ben's team. You can get it\r\n% from the <https:\/\/www.mathworks.com\/matlabcentral\/fileexchange\/340-saveppt-gpubench \r\n% MATLAB Central File Exchange>. Here's a portion of the report:\r\n%\r\n% <<..\/gpu-report-snap.png>>\r\n%\r\n% _GFLOP_ is a unit of computational speed. 1 GFLOP is roughly 1 billion \r\n% floating point operations per second. The report measures computational\r\n% speed for both double-precision and single-precision floating point. Some\r\n% cards excel at double precision, and some do better at single precision.\r\n% The report shows the best double precision cards at the top because that\r\n% is most important for general MATLAB computing.\r\n%\r\n% The report includes three different computational benchmarks: MTimes\r\n% (matrix multiplication), backslash (linear system solving), and FFT.\r\n% The matrix multiplication benchmark is best at measuring pure\r\n% computation speed, and so it has the highest GFLOP numbers. The FFT and\r\n% backslash benchmarks, on the other hand, involve more of a mixture of\r\n% computation and I\/O, so the reported GFLOP rates are lower.\r\n%\r\n% My Titan Xp card is better than my CPU (\"Host PC\" in the table above) for double precision\r\n% computing, but it's definitely slower than the top cards listed. \r\n% So, why did Ben tell me\r\n% that my card was so good for deep learning? It's because of the\r\n% right-hand column of the report, which focuses on _single-precision\r\n% computation_. For image processing and deep learning, \r\n% single-precision speed is more important than double-precision speed. \r\n%\r\n% And the Titan Xp is blazingly fast at single-precision computation, with a whopping\r\n% 1,100 GFLOPS for matrix multiplication. If you're interested, you can\r\n% drill into the GPUBench report for more details, like this:\r\n%\r\n% <<..\/device4-MTimes-single.png>>\r\n%\r\n%% Types of NVIDIA GPU cards\r\n% I asked Ben for a little help understanding the wide variety of GPU cards\r\n% made by NVIDIA. \"Well, for deep learning, you can probably focus just on\r\n% three lines of cards: GeForce, Titan, and Tesla. The GeForce cards are\r\n% the cheapest ones with decent compute performance, but you have to keep\r\n% in mind that they don't work if you are using remote desktop software.\r\n% The Titan is kind of a souped-up version of GeForce that does have remote\r\n% desktop support. And the Tesla cards are intended as high-performance\r\n% cards for compute servers in double-precision applications.\"\r\n%\r\n%% Comparing CPU and GPU speed for deep learning\r\n% Many of the deep learning functions in Neural Network Toolbox and other\r\n% products now support an option called |'ExecutionEnvironment'|. The\r\n% choices are: |'auto'|, |'cpu'|, |'gpu'|, |'multi-gpu'|, and |'parallel'|.\r\n% You can use this option to try some network training and prediction\r\n% computations to measure the practical GPU impact on deep learning on your\r\n% own computer.\r\n%\r\n% I'm going to experiment with this option using the\r\n% <https:\/\/www.mathworks.com\/help\/nnet\/examples\/train-a-convolutional-neural-network-for-regression.html \r\n% \"Train a Convolutional Neural Network for Regression\" example>. I'm just\r\n% going to do the training step here, not the full example. First, I'll use\r\n% my GPU.\r\n\r\noptions = trainingOptions('sgdm','InitialLearnRate',0.001, ...\r\n    'MaxEpochs',15);\r\nnet = trainNetwork(trainImages,trainAngles,layers,options);\r\n\r\n%%\r\n% You can see in the \"Elapsed Time\" column that the training for this\r\n% simple example took about 8 seconds.\r\n%\r\n% Now let's repeat the training using just the CPU.\r\n\r\noptions = trainingOptions('sgdm','InitialLearnRate',0.001, ...\r\n    'MaxEpochs',15,'ExecutionEnvironment','cpu');\r\nnet = trainNetwork(trainImages,trainAngles,layers,options);\r\n\r\n%%\r\n% That took about 10 times longer than training using the GPU. For\r\n% realistic networks, we expect the difference to be even greater. With\r\n% more powerful deep learning networks that take hours or days to train,\r\n% you can see why we recommend using a good GPU for substantial deep\r\n% learning work.\r\n%\r\n% I hope you find this information helpful. Good luck setting up your own\r\n% deep learning system with MATLAB!\r\n%\r\n% PS. Thanks, Ben!\r\n##### SOURCE END ##### 7a02c326deef405a8f9a26dbad638b7b\r\n-->","protected":false},"excerpt":{"rendered":"<div class=\"overview-image\"><img src=\"https:\/\/blogs.mathworks.com\/deep-learning\/files\/2017\/10\/device4-MTimes-single.png\" class=\"img-responsive attachment-post-thumbnail size-post-thumbnail wp-post-image\" alt=\"\" decoding=\"async\" loading=\"lazy\" \/><\/div><p>\r\n\r\nHi There! While most of the information in this post is correct, this is an original post from 2017 and the world of GPUs changes rapidly. I would encourage you to check out a newer resource on... <a class=\"read-more\" href=\"https:\/\/blogs.mathworks.com\/deep-learning\/2017\/10\/20\/deep-learning-with-gpus-and-matlab\/\">read more >><\/a><\/p>","protected":false},"author":42,"featured_media":38,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[9],"tags":[],"_links":{"self":[{"href":"https:\/\/blogs.mathworks.com\/deep-learning\/wp-json\/wp\/v2\/posts\/33"}],"collection":[{"href":"https:\/\/blogs.mathworks.com\/deep-learning\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blogs.mathworks.com\/deep-learning\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blogs.mathworks.com\/deep-learning\/wp-json\/wp\/v2\/users\/42"}],"replies":[{"embeddable":true,"href":"https:\/\/blogs.mathworks.com\/deep-learning\/wp-json\/wp\/v2\/comments?post=33"}],"version-history":[{"count":10,"href":"https:\/\/blogs.mathworks.com\/deep-learning\/wp-json\/wp\/v2\/posts\/33\/revisions"}],"predecessor-version":[{"id":6466,"href":"https:\/\/blogs.mathworks.com\/deep-learning\/wp-json\/wp\/v2\/posts\/33\/revisions\/6466"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blogs.mathworks.com\/deep-learning\/wp-json\/wp\/v2\/media\/38"}],"wp:attachment":[{"href":"https:\/\/blogs.mathworks.com\/deep-learning\/wp-json\/wp\/v2\/media?parent=33"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blogs.mathworks.com\/deep-learning\/wp-json\/wp\/v2\/categories?post=33"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blogs.mathworks.com\/deep-learning\/wp-json\/wp\/v2\/tags?post=33"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}