{"id":7722,"date":"2021-08-24T08:59:38","date_gmt":"2021-08-24T12:59:38","guid":{"rendered":"https:\/\/blogs.mathworks.com\/deep-learning\/?p=7722"},"modified":"2022-01-13T10:23:25","modified_gmt":"2022-01-13T15:23:25","slug":"auto-categorization-of-content-using-deep-learning","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/deep-learning\/2021\/08\/24\/auto-categorization-of-content-using-deep-learning\/","title":{"rendered":"Auto-Categorization of Content using Deep Learning"},"content":{"rendered":"<em>This post is from Anshul Varma, developer at MathWorks, who will talk about a project where MATLAB is used for a real production application: Applying Deep Learning to categorize MATLAB Answers.<\/em>\r\n<h6><\/h6>\r\n<p style=\"font-size: 14px;\">In the Spring of 2019, I had a serious problem. I had just been given the task of putting individual <a href=\"https:\/\/www.mathworks.com\/matlabcentral\/answers\/index\">MATLAB Answers<\/a> into categories for the new <a href=\"https:\/\/www.mathworks.com\/help\/\">Help Center<\/a> that integrates different documentation and community resources into a single, categorical-based design. The categories help organize content based on topics and enable you to find information easily.<\/p>\r\n<p style=\"font-size: 14px;\">Let me give you an example: Here's an answer related to ANOVA statistical analysis:<\/p>\r\n<p style=\"text-align: center;\"><img decoding=\"async\" loading=\"lazy\" width=\"1024\" height=\"279\" class=\"alignnone size-large wp-image-7728\" src=\"https:\/\/blogs.mathworks.com\/deep-learning\/files\/2021\/08\/Image1-1024x279.jpg\" alt=\"\" \/><\/p>\r\n\r\n<h6><\/h6>\r\n<p style=\"font-size: 14px;\">I put it in the ANOVA category under the <em>AI, Data Science, and Statistics &gt; Statistics and Machine Learning Toolbox &gt; ANOVA &gt; Analysis of Variance and Covariance. <\/em>Easy enough, right?<\/p>\r\n<p style=\"font-size: 14px;\">This wouldn't be so hard except for one thing: I had more than 300,000 MATLAB Answers that needed to be slotted into more than 3,500 categories.<\/p>\r\n<p style=\"font-size: 14px;\">There are over 40,000 pages of MathWorks product documentation, spread across the 90+ products MathWorks offers. These documentation pages are organized into over 3,500 categories, to make topics and reference pages easy to find and parse. You've probably used these categories, in the left-hand navigation, when viewing a documentation page:<\/p>\r\n<p style=\"text-align: center;\"><img decoding=\"async\" loading=\"lazy\" width=\"1024\" height=\"785\" class=\"alignnone size-large wp-image-7731\" src=\"https:\/\/blogs.mathworks.com\/deep-learning\/files\/2021\/08\/image2-1024x785.jpg\" alt=\"\" \/><\/p>\r\n\r\n<h6><\/h6>\r\n<p style=\"font-size: 14px;\">Building Help Center required the integration of over 300,000 MATLAB Answers, aligning them by category to the existing documentation pages.<\/p>\r\n<p style=\"text-align: center;\"><img decoding=\"async\" loading=\"lazy\" width=\"585\" height=\"653\" class=\"alignnone size-large wp-image-7734\" src=\"https:\/\/blogs.mathworks.com\/deep-learning\/files\/2021\/08\/image3.jpg\" alt=\"\" \/><\/p>\r\n<p style=\"font-size: 14px;\">Obviously, manually assigning categories to 300,000+ Answers wasn't a realistic solution:<\/p>\r\n\r\n<ul>\r\n \t<li>How do I go through thousands of Answers in a short amount of time?<\/li>\r\n \t<li>How do I get help from content experts who were knowledgeable on the entire Category Taxonomy?<\/li>\r\n \t<li>How do I manually categorize thousands of new Answers created each week and make it a scalable process?<\/li>\r\n<\/ul>\r\n<p style=\"font-size: 14px;\">I needed a lot of help. Fortunately for me, the help I needed was right here: Deep Learning Toolbox and Text Analytics Toolbox. Working with my team, we put together a plan to pull off this remarkable feat in a short amount of time to automatically categorize thousands of Answers. And it worked! It worked even better than we could have hoped.<\/p>\r\n<p style=\"font-size: 14px;\">Let me tell you the story of how we did it...<\/p>\r\n\r\n<h2>Deep Learning for Auto-Categorization<\/h2>\r\n<p style=\"font-size: 14px;\">I chose MATLAB with Deep Learning and Text Analytics Toolboxes to build my solution because of the following two main reasons:<\/p>\r\n\r\n<ul>\r\n \t<li><a href=\"https:\/\/en.wikipedia.org\/wiki\/Eating_your_own_dog_food\">Eating your own dog food<\/a> \ud83d\ude42<\/li>\r\n \t<li><a href=\"https:\/\/www.mathworks.com\/help\/deeplearning\/ug\/deep-learning-in-matlab.html\">High-quality documentation<\/a> and technical support<\/li>\r\n<\/ul>\r\n<p style=\"font-size: 14px;\">There are 3 steps to solving a classic <a href=\"https:\/\/www.mathworks.com\/discovery\/supervised-learning.html\">supervised learning<\/a> text classification problem, where we want to classify text content to the most relevant class:<\/p>\r\n\r\n<ol>\r\n \t<li>Prepare the data that you want to use for training<\/li>\r\n \t<li>Train a model using the training data<\/li>\r\n \t<li>Validate the trained model<\/li>\r\n<\/ol>\r\n<h2>Step 1: Prepare the data for training<\/h2>\r\n<p style=\"font-size: 14px;\">I used the following MathWorks resources that have content categorized into categories (manually curated) for building a model:<\/p>\r\n\r\n<ul>\r\n \t<li><a href=\"https:\/\/www.mathworks.com\/help\/index.html?s_tid=CRUX_topnav\">Documentation <\/a>(about 30k documents)<\/li>\r\n \t<li><a href=\"https:\/\/www.mathworks.com\/matlabcentral\/fileexchange\/\">File Exchange<\/a> (about 18k documents)<\/li>\r\n \t<li><a href=\"https:\/\/www.mathworks.com\/matlabcentral\/answers\/index\">MATLAB Answers<\/a> (about 12k documents)<\/li>\r\n<\/ul>\r\n<p style=\"font-size: 14px;\">I used Text Analytics Toolbox for the data preparation. The first part of the text data preparation pipeline is mainly needed for data cleaning where we do things like decoding HTML entities into characters, convert documents to lowercase, erase HTTP and HTTPS URLs, erase HTML and XML tags, and lastly remove all email addresses from the text:<\/p>\r\n\r\n<pre>rawTextArray = decodeHTMLEntities(rawTextArray); <span class=\"comment\">% Convert HTML and XML entities into characters<\/span>\r\nrawTextArray = lower(rawTextArray); <span class=\"comment\">% Convert documents to lowercase<\/span>\r\nrawTextArray = eraseURLs(rawTextArray); <span class=\"comment\">% Erase HTTP and HTTPS URLs from text<\/span>\r\nrawTextArray = eraseTags(rawTextArray); <span class=\"comment\">% Erase HTML and XML tags from text<\/span>\r\nrawTextArray = regexprep(rawTextArray, '[^@\\s]*@[^@\\s]*\\.[^@\\s]*', ''); <span class=\"comment\">% Erase email addresses<\/span>\r\n<\/pre>\r\n<p style=\"font-size: 14px;\">The next step in data preparation is needed to clean and preserve valuable information about content that can be easily lost if we perform text analysis to remove all punctuations. The removal of punctuations will erase a term like 'c++' completely. We preserve programming language-specific terms and some MathWorks data-specific terms in this part of the text data preparation pipeline. An example excerpt from this part of the pipeline is shown below:<\/p>\r\n\r\n<pre><span class=\"comment\">% Preserve programming language before removing all punctuations <\/span>\r\nrawTextArray = replace(rawTextArray, 'c++',' cplusplus ');\r\nrawTextArray = replace(rawTextArray, 'c#',' csharp ');\r\nrawTextArray = replace(rawTextArray, '.net',' dotnet ');\r\n \r\n <span class=\"comment\">% Do more custom preservation of terms specific to MathWorks data... <\/span>\r\n \r\nrawTextArray = regexprep(rawTextArray, '[\\n\\r]+',' '); <span class=\"comment\">% Erase \\n and \\r from text<\/span>\r\nrawTextArray = erasePunctuation(rawTextArray); <span class=\"comment\">% Erase punctuation from text<\/span>\r\n<\/pre>\r\n<p style=\"font-size: 14px;\">The last part of the text data preparation pipeline is tokenizing and analyzing the text data. We tokenize the documents, remove stop words, remove short and long words, and lastly normalize the words:<\/p>\r\n\r\n<pre>preprocessed_tokens = tokenizedDocument(rawTextArray, 'Language', 'en'); <span class=\"comment\">% Array of tokenized documents for text analysis<\/span>\r\npreprocessed_tokens = removeWords(preprocessed_tokens, stopWords); <span class=\"comment\">% Remove selected words from documents<\/span>\r\npreprocessed_tokens = removeShortWords(preprocessed_tokens, 2); <span class=\"comment\">% Remove short words from documents<\/span>\r\npreprocessed_tokens = removeLongWords(preprocessed_tokens, 15); <span class=\"comment\">% Remove long words from documents<\/span>\r\noutput_analyzed_text = normalizeWords(preprocessed_tokens); <span class=\"comment\">% Stem or lemmatize words<\/span>\r\n<\/pre>\r\n<p style=\"font-size: 14px;\">Once all documents are preprocessed, we can use them to create a deep learning text classifier.<\/p>\r\n\r\n<h2>Step 2: Train the model using the training data<\/h2>\r\n<p style=\"font-size: 14px;\">I referred to the <a href=\"https:\/\/www.mathworks.com\/help\/textanalytics\/ug\/classify-text-data-using-deep-learning.html\">Classify Text Data Using Deep Learning<\/a> example to create a deep learning LSTM text classifier. I use the preprocessed and analyzed data to train the model.<\/p>\r\n<p style=\"font-size: 14px;\">Prepare data for training, testing, and validation:<\/p>\r\n\r\n<pre><span class=\"comment\">% Remove the rows of the table with empty documents.<\/span>\r\nidxEmpty = strlength(data.preprocessed_text) == 0; \r\ndata(idxEmpty, :) = [];\r\n \r\n<span class=\"comment\">% To divide the data into classes, convert these labels to categorical.<\/span>\r\ndata.id = categorical(data.id);\r\n \r\n<span class=\"comment\">% Find the classes containing fewer than ten observations.<\/span>\r\nidxLowCounts = classCounts &lt; 10;\r\ninfrequentClasses = classNames(idxLowCounts);\r\n \r\n<span class=\"comment\">% Remove these infrequent classes from the data. Use removecats to remove the unused categories from the categorical data.<\/span>\r\nidxInfrequent = ismember(data.id, infrequentClasses);\r\ndata(idxInfrequent,:) = [];\r\ndata.id = removecats(data.id);\r\n \r\n<span class=\"comment\">% Partition the data into a training partition and a held-out partition for validation and testing.<\/span>\r\ncvp = cvpartition(data.id,'Holdout', 0.1);\r\ndataTrain = data(training(cvp),:);\r\ndataHeldOut = data(test(cvp),:);\r\ncvp = cvpartition(dataHeldOut.id,'HoldOut', 0.5);\r\ndataValidation = dataHeldOut(training(cvp),:);\r\ndataTest = dataHeldOut(test(cvp),:);\r\n \r\n<span class=\"comment\">% Extract the preprocessed text data and labels from the partitioned tables.<\/span>\r\ndocumentsTrain = tokenizedDocument(dataTrain.preprocessed_text, 'Language', 'en');\r\ndocumentsValidation = tokenizedDocument(dataValidation.preprocessed_text, 'Language', 'en');\r\ndocumentsTest = tokenizedDocument(dataTest.preprocessed_text, 'Language', 'en');\r\n \r\nYTrain = dataTrain.id;\r\nYValidation = dataValidation.id;\r\nYTest = dataTest.id;\r\n<\/pre>\r\n<p style=\"font-size: 14px;\">The training data excerpt is shown below:<\/p>\r\n\r\n<pre><span class=\"comment\">% View the first few preprocessed training documents.<\/span>\r\ndocumentsTrain(1:5)\r\n\r\n5\u00d71 tokenizedDocument:\r\n \r\n    26 tokens: integr fire neuron model simulink integr fire neuron model simulink shufan simulink hdl coder simulink model integr fire neuron network model simulink integr fire neuron model\r\n    33 tokens: audio watermark selvakarna audio watermark selvakarna audio process selva extract forman frequenc extract process wave selva karna matlab simulink dsp system fixedpoint design matlab coder signal process audio watermark selvakarna audio watermark selvakarna\r\n    45 tokens: simulink initi schedul simulink initi sequenti block execut exampl enabl execut initi schedul sequenti trigger giampiero campa simulink file contain simpl exampl base enabl subsystem block show execut simulink block initi execut block initi sequenti schedul execut differ subsystem simulink initi sequenti block execut exampl\r\n    10 tokens: power transfer limit simul kathir vel simulink simul paper simul\r\n    19 tokens: matlab graphic simulink techniqu matlab graphic simulink simul graphic simulink live script mike garriti techniqu matlab graphic simulink simul\r\n<\/pre>\r\n<p style=\"font-size: 14px;\">Generate a word cloud.<\/p>\r\n\r\n<pre><span class=\"comment\">% Visualize the training text data using a word cloud<\/span>\r\nfigure\r\nwordcloud(documentsTrain);\r\ntitle(\"Training Data\")<\/pre>\r\n<p style=\"text-align: center;\"><img decoding=\"async\" loading=\"lazy\" class=\"alignnone wp-image-7737 size-medium\" src=\"https:\/\/blogs.mathworks.com\/deep-learning\/files\/2021\/08\/image4-300x264.png\" alt=\"\" width=\"300\" height=\"264\" \/><\/p>\r\n<p style=\"font-size: 14px;\">Set documents to sequences.<\/p>\r\n\r\n<pre><span class=\"comment\">% Create a word encoding.<\/span>\r\nenc = wordEncoding(documentsTrain);\r\n \r\n<span class=\"comment\">% Convert the documents to sequences of numeric indices using doc2sequence.<\/span>\r\nseq_length = 800;\r\nXTrain = doc2sequence(enc, documentsTrain, 'Length', seq_length);\r\nXValidation = doc2sequence(enc, documentsValidation, 'Length', seq_length);\r\n<\/pre>\r\n<p style=\"font-size: 14px;\">Prepare training options, configure LSTM network layers, and perform training.<\/p>\r\n\r\n<pre><span class=\"comment\">% Create and Train LSTM Network<\/span>\r\n<span class=\"comment\">% Set training configuration.<\/span>\r\ninputSize = 1; \r\nembeddingDimension = 100;\r\nnumHiddenUnits = enc.NumWords;\r\nhiddenSize = 180;\r\nnumClasses = numel(categories(YTrain));\r\n \r\nlayers = [ ...\r\n    sequenceInputLayer(inputSize)\r\n    wordEmbeddingLayer(embeddingDimension, numHiddenUnits)\r\n    lstmLayer(hiddenSize, 'OutputMode', 'last')\r\n    dropoutLayer(0.4)\r\n    fullyConnectedLayer(numClasses)\r\n    softmaxLayer\r\n    classificationLayer];\r\n \r\noptions = trainingOptions('adam', ...\r\n    'LearnRateSchedule', 'piecewise', ...\r\n    'LearnRateDropFactor', 0.1, ...\r\n    'LearnRateDropPeriod', 20, ...\r\n    'MaxEpochs', 25, ...    \r\n    'GradientThreshold', 1, ...\r\n    'InitialLearnRate', 0.01, ...\r\n    'ValidationData', {XValidation, YValidation}, ...\r\n    'Plots', 'training-progress', ...\r\n    'Verbose', true, ...\r\n    'shuffle', 'every-epoch');\r\n\r\n\r\n<span class=\"comment\">% Train the LSTM network using the trainNetwork function.<\/span>\r\nnet = trainNetwork(XTrain, YTrain, layers, options);<\/pre>\r\n<h2>Step 3: Validate the trained model<\/h2>\r\n<p style=\"font-size: 14px;\">We used both Objective and Subjective validation to verify the model worked as expected.<\/p>\r\n\r\n<h3>Objective Validation<\/h3>\r\n<p style=\"font-size: 14px;\">Test the accuracy of the LSTM network using the test documents<\/p>\r\n\r\n<pre><span class=\"comment\">%% Test the LSTM network<\/span>\r\n<span class=\"comment\">% Convert the test documents to sequences using doc2sequence with the same options <\/span>\r\n<span class=\"comment\">as when creating the training sequences.<\/span>\r\nXTest = doc2sequence(enc, documentsTest, 'Length', seq_length);\r\n \r\n<span class=\"comment\">% Classify the test documents using the trained LSTM network.<\/span>\r\n[YPred, PBScore] = classify(net, XTest);\r\n \r\n<span class=\"comment\">% Extract top 3 predictions.<\/span>\r\nclasses = net.Layers(end).Classes;\r\nclasses_matrix = repmat(classes, size(classes')); <span class=\"comment\">% 'create matrix to represent all classes <\/span>\r\n[~, I] = sort(PBScore, 2, 'descend');\r\nTop3_YPred = classes_matrix(I(:,1:3));\r\n \r\n<span class=\"comment\">% Calculate model accuracy.<\/span>\r\nmodel_accuracy = nnz(table2array(rowfun(@ismember, table(YTest, Top3_YPred))))\/numel(YPred);\r\n<\/pre>\r\n<p style=\"font-size: 14px;\">The category prediction accuracy of our model is about 70%. We compute the accuracy by evaluating if the category of the test document matches with any of the top 3 categories predicted by the model. We selected this approach to compute accuracy since the categories data is hierarchical. The categorization is very subjective because an answer could live in multiple categories. In most cases, the categorization is not black and white due to the nature of categories and parent-child relationships. We cannot rely exclusively on the objective analysis of accuracy computation for validation. So, we did subjective validation as described below.<\/p>\r\n\r\n<h3>Subjective Validation<\/h3>\r\n<p style=\"font-size: 14px;\">We enlisted the help of our employees to help test the accuracy of our predictions. We performed numerous bashes, tempting employees with pizza, chocolate, and prizes, to ensure participation would be statistically significant.<\/p>\r\n<strong>Testing predictions<\/strong>\r\n<ol>\r\n \t<li>First, we set up a list of common phrases that might be used by customers in our MATLAB Central Community. These came from search phrases captured during customer visits.<\/li>\r\n \t<li>Then, we invited staff members who are familiar with our product line, our customer base, or how AI works, in general, to participate in a bash. We asked them to use our internal Categorizations Tool to search for content in a particular topic space. We then asked them to examine the suggested categories for each result and make a subjective judgment on the categories being proposed. We asked them to capture:\r\n<ol type=\"a\">\r\n \t<li>What they searched for.<\/li>\r\n \t<li>Score the overall predictions as 1 for \"good suggestions\" or a 0 for \"poor suggestions\".<\/li>\r\n \t<li>What category, in general, they were examining.<\/li>\r\n \t<li>Anything else they wanted to share as an observation.<\/li>\r\n<\/ol>\r\n<\/li>\r\n<\/ol>\r\n<strong>Testing categorizations<\/strong>\r\n<ol>\r\n \t<li>We assembled a list of the categories in use and the number of community-asked questions that had been auto-categorized for that topic.<\/li>\r\n \t<li>Then, we invited technical support staff who are familiar with our product line to participate in another bash. This time, we asked them to go to the website and navigate to a category for which they had technical expertise. They were to look at the top 10-20 answers shown for that category, and assess whether the results were good, bad, or unclear. They captured:\r\n<ol type=\"a\">\r\n \t<li>What category they examined.<\/li>\r\n \t<li>A score of 1 (good), 0 (poor), or unknown.<\/li>\r\n \t<li>Specific reasons why they chose the score they chose.<\/li>\r\n \t<li>Suggestions for more applicable answers, if known, for the category, if they said it was poorly categorized.<\/li>\r\n<\/ol>\r\n<\/li>\r\n<\/ol>\r\nAfter performing the subjective assessments, we then performed a numerical analysis on the data captured and identified:\r\n<ul>\r\n \t<li>Areas where we felt confident in our categorization.<\/li>\r\n \t<li>Areas where the algorithm could be improved.<\/li>\r\n \t<li>Areas where we needed additional testing.<\/li>\r\n<\/ul>\r\n<p style=\"font-size: 14px;\">We generated metrics and analyzed the data using objective and subjective validations to gauge the quality of categorizations. Overall, we were happy with the results.<\/p>\r\n<p style=\"text-align: center;\"><img decoding=\"async\" loading=\"lazy\" width=\"480\" height=\"270\" class=\"alignnone size-full wp-image-7725\" src=\"https:\/\/blogs.mathworks.com\/deep-learning\/files\/2021\/08\/image_gif.gif\" alt=\"\" \/><\/p>\r\n\r\n<h6><\/h6>\r\n&nbsp;\r\n<h6><\/h6>\r\n<p style=\"font-size: 14px;\">That's it! \ud83d\ude42 We have created a text classification model using MATLAB Deep Learning and Text Analytics Toolboxes that can automatically assign categories to more than 300,000 Answers. Using MATLAB, we can automatically categorize the in-flow of new and updated Answers daily as well. It was a unique solution that helped save us a lot of time and manual effort. It made our processes scalable and manageable.<\/p>\r\n<p style=\"font-size: 14px;\">Let me end this blog by sharing some interesting challenges of using AI techniques in the production environment, pro tips, and resources with you:<\/p>\r\n<strong>Interesting challenges of using AI techniques in the production environment<\/strong>\r\n<ul>\r\n \t<li>\r\n<p style=\"font-size: 14px;\"><em>Refreshing the model regularly to prevent model decay<\/em>: The MathWorks Documentation and the Category Taxonomy are updated every 6 months as part of the new release of MATLAB. We retrain the model with the updated training data and category labels. The updated model is then deployed to production so that the content is classified into the correct categories.<\/p>\r\n<\/li>\r\n \t<li>\r\n<p style=\"font-size: 14px;\"><em>Identifying the categories that need our attention for optimal user experience<\/em>: There are categories where we would like to enhance our model for better prediction outcomes. One way we are identifying such categories is by looking into the training data set. We find categories that lack manual training input provided by a human. The quality of classification in such categories is sub-optimal. We are looking at this data every 6 months when we re-train the model. We take help from the content experts within our organization to help with curation. This activity provides feedback to the model for improvements in future classification.<\/p>\r\n<\/li>\r\n \t<li>\r\n<p style=\"font-size: 14px;\"><em>Developing automatic quality measurements and relevancy tests<\/em>: We are developing ways to automate the validation of the model and classification process. We envision a process to execute our relevancy testing suite to analyze metrics automatically and notify us if there is an anomaly. The automation will help us save development time during data refreshes and model upgrades.<\/p>\r\n<\/li>\r\n<\/ul>\r\n<strong>Pro Tips<\/strong>\r\n<ul>\r\n \t<li>\r\n<p style=\"font-size: 14px;\">My general recommendation when you are thinking of using AI in production to solve a problem would be to start with something that is easy to understand and debug, and then evolve to a more complicated process (like using neural networks) if it yields better results.<\/p>\r\n<\/li>\r\n \t<li>\r\n<p style=\"font-size: 14px;\">Prototype, prototype, and prototype! Don't be afraid of failing. AI can be complicated. Applying AI to solve the complicated problems is even harder. You need to get your hands in the clay sometimes to understand if AI techniques can or cannot work for you.<\/p>\r\n<\/li>\r\n \t<li>\r\n<p style=\"font-size: 14px;\">The truth about your data might surprise you. Using AI techniques often reveals some interesting patterns about your data. The patterns could help to identify interesting use-cases\/issues that you might not have thought about.<\/p>\r\n<\/li>\r\n<\/ul>\r\n<h2>Resources to learn more<\/h2>\r\n<ul>\r\n \t<li><a href=\"https:\/\/www.mathworks.com\/help\/textanalytics\/ug\/create-simple-text-model-for-classification.html\">Create Simple Text Model for Classification<\/a> is an excellent example to get started with a simple text classification model. It is a simple text classifier that uses a bag-of-words model.<\/li>\r\n \t<li><a href=\"https:\/\/www.mathworks.com\/help\/textanalytics\/ug\/classify-text-data-using-deep-learning.html\">Classify Text Data Using Deep Learning<\/a> is another excellent example to classify text data using an LSTM network. It is a complex text classifier but can return some great results even for cold-start problems.<\/li>\r\n<\/ul>","protected":false},"excerpt":{"rendered":"<div class=\"overview-image\"><img decoding=\"async\"  class=\"img-responsive\" src=\"https:\/\/blogs.mathworks.com\/deep-learning\/files\/2021\/08\/Image1-1024x279.jpg\" onError=\"this.style.display ='none';\" \/><\/div><p>This post is from Anshul Varma, developer at MathWorks, who will talk about a project where MATLAB is used for a real production application: Applying Deep Learning to categorize MATLAB... <a class=\"read-more\" href=\"https:\/\/blogs.mathworks.com\/deep-learning\/2021\/08\/24\/auto-categorization-of-content-using-deep-learning\/\">read more >><\/a><\/p>","protected":false},"author":156,"featured_media":0,"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\/7722"}],"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\/156"}],"replies":[{"embeddable":true,"href":"https:\/\/blogs.mathworks.com\/deep-learning\/wp-json\/wp\/v2\/comments?post=7722"}],"version-history":[{"count":23,"href":"https:\/\/blogs.mathworks.com\/deep-learning\/wp-json\/wp\/v2\/posts\/7722\/revisions"}],"predecessor-version":[{"id":8926,"href":"https:\/\/blogs.mathworks.com\/deep-learning\/wp-json\/wp\/v2\/posts\/7722\/revisions\/8926"}],"wp:attachment":[{"href":"https:\/\/blogs.mathworks.com\/deep-learning\/wp-json\/wp\/v2\/media?parent=7722"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blogs.mathworks.com\/deep-learning\/wp-json\/wp\/v2\/categories?post=7722"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blogs.mathworks.com\/deep-learning\/wp-json\/wp\/v2\/tags?post=7722"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}