The main asset for solving this challenge are the videos themselves! Each video is identified by its filename<\/em>, which is a numeric string followed by .mp4, e.g., 100000.mp4<\/em>. All videos are hosted in a public s3 bucket.<\/strong><\/p>\n The full training dataset contains over 580,000 videos, which is around 1.5 terabytes! To help facilitate faster model prototyping, there are two subset versions of the dataset, referred to as nano <\/em>and micro.<\/em><\/p>\n In addition to the videos, you are provided with “train_metadata.csv<\/em>” and “test_metadata.csv<\/em>” files. These files consist of the information like filename, URL of each file, number of frames of each video, nano<\/em> and micro<\/em> subsets indication. “train_labels.csv<\/em>” is the file of labels of training data.<\/p>\n For further details about the dataset check out the Problem Description<\/a> on the competition webpage.<\/p>\n We are providing a basic Benchmark starter code in MATLAB on the Nano<\/em>subset version of the dataset. In this code, we walk through a basic classification model, where we are combining a pre-trained image classification model and an LSTM network. Then, we will use this model to predict the type of the vessel on test data and save a CSV file in the format required for the challenge. You can also download this MATLAB benchmark code here.<\/a><\/p>\n This can serve as basic code where you can start analyzing the data and work towards developing a more efficient, optimized, and accurate model using more of the training data available. Additionally, we have provided a few tips and tricks to work on the complete 1.5TB dataset. On the challenge’s Problem Description<\/a> page, all required details for videos, labels performance and submission metrics are provided.<\/p>\n So, let’s get started with this dataset!<\/p>\n To access the variable values from the file train_metadata.csv<\/em>, load the file in the form of a tabulartext datastore<\/a> in the workspace.<\/p>\n We can then preview the datastore. This visualizes the first 8 rows of the file.<\/p>\n You can also import csv files in MATLAB using readtable<\/a> function. Here, we create training labels from the train_labels.csv<\/em> file and store it in a form of table. We then convert the values of the variable stalled to categorical, as most deep leaning functions used accept categorical values.<\/p>\n In this starter code, we will be using the nano subset of the database. Here, we retrieve the files and labels for nano subset from the tables created above and save it in variables nanotrain<\/em> and nanotrainlabels<\/em>. (To work with the complete dataset, you will not need this step.)<\/p>\n Datastores in MATLAB are a convenient way of working with and representing collections of data that are too large to fit in memory at one time. It is an object for reading a single file or a collection of files or data. The datastore acts as a repository for data that has the same structure and formatting. To learn more about different datastores, check out the documents below:<\/p>\n In this blog,<\/u> we used the filedatastore<\/a> to read each file using its URL. Each file is then processed using the readVideo<\/a> helper functions, defined at the end of this blog.<\/p>\n We save the datastore in a MAT-file in tempdir<\/em> or current folder before proceeding to next sections. If the MAT file already exists, then load the datastore from the MAT-file without reassessing them.<\/p>\n Tip:<\/strong> For working with complete dataset (~1.5TB),<\/u>create the datastore with the folder location of the training data (‘s3:\/\/drivendata-competition-clog-loss\/train<\/em>‘) and not with each url URL <\/u>to save time and memory. This step can take a long time to run.<\/p>\n (Optional) We can preview the datastore and assure that each video frame is now cropped at the outlined segment.<\/p>\n To create a deep learning network for video classification:<\/p>\n The following diagram illustrates the network architecture.<\/p>\n To convert frames of videos to feature vectors, we use the activations of a pretrained network. Load a pretrained GoogLeNet model using the googlenet<\/a> function. This function requires the Deep Learning Toolbox\u2122 Model for <\/em>GoogLeNet Network support package<\/a>.<\/p>\n Use the convolutional network as a feature extractor by getting the activations when inputting the video frames to the network.<\/p>\n This diagram illustrates the data flow through the network.<\/p>\n The input size should match the input size of the pretrained network, here the GoogLeNet network.\u00a0 The datastore is then resized to the input size using the transform<\/em><\/a> function.<\/p>\n Convert the videos to sequences of feature vectors, where the feature vectors are the output of the activations<\/a><\/em> function on the last pooling layer of the GoogLeNet network (“pool5-7x7_s1<\/em>“). To analyze every size and location of the clogged vessels within the outlined segment, we do not modify the lengths of the sequences here.<\/p>\n Tip:<\/strong> After converting the videos to sequences, save the sequences in a MAT-file in the tempdir<\/em> folder. If the MAT file already exists, then load the sequences from the MAT-file without reconverting them. This step can take a long time to run.<\/p>\n We then view the sizes of the first few sequences. Each sequence is a D<\/em>-by-S<\/em> array, where D<\/em> is the number of features (the output size of the pooling layer) and S<\/em> is the number of frames of the video.<\/p>\n Here, we prepare the data for training by partitioning the data into training and validation partitions. We assign 90% of the data to the training partition and 10% to the validation partition.<\/p>\n We then get the sequence lengths of the training data and visualize them in a histogram plot.<\/p>\n Next, create an Long Short Term Memory (LSTM)<\/a> network that can classify the sequences of feature vectors representing the videos.<\/p>\n We then define the LSTM network architecture and specify the following network layers.<\/p>\n As the next step, we specify the training options using the trainingOptions<\/a> function:<\/p>\n We then train the network using the trainNetwork<\/a> function. Note that this function can take a long time to run due to the computations involved.<\/p>\n As the next step, we calculate the classification accuracy of the network on the validation set using classify<\/a> <\/em>function. You can use the same mini-batch size as you used for the training option.<\/p>\n To create a network that classifies videos directly, assemble a network using layers from both of the created networks. Use the layers from the convolutional network to transform the videos into vector sequences and the layers from the LSTM network to classify the vector sequences.<\/p>\n The following diagram illustrates the network architecture.<\/p>\n Add Convolutional Layers<\/strong><\/p>\n First, we create a layer graph of the GoogLeNet network.<\/p>\n Then we remove the input layer (“data<\/em>“) and the layers after the pooling layer used for the activations (“pool5-drop_7x7_s1<\/em>“, “loss3-classifier<\/em>“, “prob<\/em>“, and “output<\/em>“).<\/p>\n Add Sequence Input Layer<\/strong><\/p>\n We create a sequence input layer<\/a> that accepts image sequences containing images of the same input size as the GoogLeNet network. To normalize the images using the same average image as the GoogLeNet network, set the ‘Normalization<\/em>‘ option of the sequence input layer to ‘zerocenter<\/em>‘ and the ‘Mean<\/em>‘ option to the average image of the input layer of GoogLeNet.<\/p>\n We then add the sequence input layer to the layer graph. To apply the convolutional layers to the images of the sequences independently, we remove the sequence structure of the image sequences by including a sequence folding layer between the sequence input layer and the convolutional layers. We then connect the output of the sequence folding layer to the input of the first convolutional layer (“conv1-7x7_s2<\/em>“).<\/p>\n Add LSTM Layers<\/strong><\/p>\n The next step is to add the LSTM layers to the layer graph by removing the sequence input layer of the LSTM network. To restore the sequence structure removed by the sequence folding layer, we can include a sequence unfolding layer after the convolution layers. The LSTM layers expect sequences of vectors. To reshape the output of the sequence unfolding layer to vector sequences, we include a flatten layer after the sequence unfolding layer.<\/p>\n We take the layers from the LSTM network and remove the sequence input layer.<\/p>\n Add the sequence folding layer<\/a>, the flatten layer, and the LSTM layers to the layer graph. Connect the last convolutional layer (“pool5-7x7_s1<\/em>“) to the input of the sequence unfolding layer (“unfold\/in<\/em>“).<\/p>\n To enable the unfolding layer to restore the sequence structure, connect the “miniBatchSize<\/em>” output of the sequence folding layer to the corresponding input of the sequence unfolding layer.<\/p>\n Assemble Network<\/strong><\/p>\n We then check that the network\u00a0 is valid using the analyzeNetwork<\/a> function.<\/p>\n And, assemble the network so that it is ready for prediction using the assembleNetwork<\/em> function.<\/p>\n Just as we did with the training data, we will now read the test files in a filedatastore and crop the frames using the readVideo<\/em> function. The cropped files datastore is then resized as per the inputSize using the transform function.<\/p>\n When we use all the files from a folder, we can directly give the\u00a0<\/span><\/span>s3 folder\u00a0<\/span><\/span>url<\/span><\/span>\u202fwhile creating the datastore.\u00a0<\/span><\/span>This speed<\/span><\/span>\u00a0up the creation of the datastore.<\/span><\/span>\u00a0<\/span><\/span><\/p>\n Once we have our trained network, we can perform predictions on our test set. To do so, we classify the test set videos using the assembled network. The classify<\/a> <\/em>function expects a cell array containing the input videos, so you must input a 1-by-1 cell array containing the video.<\/p>\n We create a table of the results based on the filenames and prediction scores. The desired file format for submission is a csv file with coulmn names: filename<\/em> and stalled<\/em>.<\/p>\n We will place all the test results in a MATLAB table, which makes it easy to visualize and to write to the desired file format.<\/p>\n We then write the results to a CSV file. This is the file you will submit for the challenge.<\/p>\n The readVideofunction<\/em> reads the video in filename and returns a cropped 4-D frame.<\/p>\n The area of interest in the entire video is the orange colored area in each frame of the video which we would want to extract to use for the rest of our training. Hence, each frame is cropped as per the bounding box of the segment, calculated using the detectROI<\/em> function.<\/p>\n The detectROIfunction<\/em> detects the outlined segment and thresholds the image based on threshold values defined. This function is generated using MATLAB’s color thresholder app<\/a>. For detecting the area specified by the orange colured markers, we used Blob Analysis<\/a>. We chose to keep the area of interest as the blob with the largest major axis. Check out the following videos to learn more.<\/p>\n Thanks for following along with this blog. We are excited to find out how you will modify this starter code and make it yours. We strongly recommend looking at our Deep Learning Tips & Tricks page<\/a> for more ideas on how you can improve the benchmark model. You can also check out this blog: Are you ready for a Video Classification Challenge<\/a>, to learn 5 different methods for Video Classification.<\/p>\n Feel free to reach out to us in the DrivenData forum<\/a> if you have any further questions.<\/p>\n","protected":false},"excerpt":{"rendered":" Today\u2019s blog is written by Neha Goel, Deep Learning Technical Evangelist on the Student Competition team at MathWorks.![\"gif\"](\"https:\/\/blogs.mathworks.com\/racing-lounge\/files\/2020\/05\/StallCatchers_gif2.gif\")
<\/p>\nGetting Started with MATLAB<\/h1>\n
Load Training Data<\/h1>\n
ttds = tabularTextDatastore(\"train_metadata.csv\",\"ReadSize\",'file',\"TextType\",\"string\");\r\ntrain =read(ttds);<\/pre>\n
preview(ttds)\r\n<\/pre>\n
![\"table\"](\"https:\/\/blogs.mathworks.com\/racing-lounge\/files\/2020\/05\/preview_ttds-1024x224.png\")
<\/p>\ntrainlabels = readtable(\"train_labels.csv\");\r\ntrainlabels.stalled = categorical(trainlabels.stalled);<\/pre>\n
nanotrain = train(train.nano == 'True',:);\r\nnanotrainlabels = trainlabels(train.nano == 'True',:);<\/pre>\n
Access & Process Video Files<\/h1>\n
\n
tempfds = fullfile(tempdir,\"fds_nano.mat\");\r\n\r\nif exist(tempfds,'file')\r\n \u00a0\u00a0 load(tempfds,'fds')\r\nelse\r\n\r\n \u00a0\u00a0 fds = fileDatastore(nanotrain.url,'ReadFcn', @readVideo);\r\n\u00a0\u00a0\u00a0 files = fds.Files;\r\n\r\n \u00a0\u00a0 save(tempfds,\"fds\");\r\nend<\/pre>\n
dataOut = preview(fds);\r\ntile = imtile(dataOut);\r\nimshow(tile);<\/pre>\n
![\"screenshot\"](\"https:\/\/blogs.mathworks.com\/racing-lounge\/files\/2020\/05\/preview_fds.png\")
<\/p>\nClassification<\/h1>\n
\n
\n
![\"flowchart\"](\"https:\/\/blogs.mathworks.com\/racing-lounge\/files\/2020\/05\/Image_1.png\")
<\/p>\nLoad Pretrained Convolutional Network<\/h2>\n
netCNN = googlenet;<\/pre>\n
Convert Frames to Feature Vectors<\/h2>\n
![\"flowchart\"](\"https:\/\/blogs.mathworks.com\/racing-lounge\/files\/2020\/05\/Image_2.png\")
<\/p>\ninputSize = netCNN.Layers(1).InputSize(1:2);\r\nfdsReSz = transform(fds,@(x) imresize(x,inputSize));<\/pre>\n
layerName = \"pool5-7x7_s1\";\r\n\r\ntempFile = fullfile(tempdir,\"sequences_nano.mat\");\r\n\r\nif exist(tempFile,'file')\r\n \u00a0\u00a0 load(tempFile,\"sequences\")\r\nelse\r\n \u00a0\u00a0 numFiles = numel(files);\r\n \u00a0\u00a0 sequences = cell(numFiles,1);\r\n\r\n for <\/span>i = 1:numFiles<\/span> \r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 fprintf(<\/span>\"Reading file %d of %d...\\n\"<\/span>, i, numFiles);<\/span> \r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 sequences{i,1} = activations(netCNN,read(fdsReSz),layerName,<\/span>'OutputAs'<\/span>,<\/span>'columns'<\/span>,<\/span>'ExecutionEnvironment'<\/span>,<\/span>\"auto\"<\/span>);<\/span> \r\n\u00a0\u00a0\u00a0\u00a0<\/span>end<\/span>\r\n\r\n save(tempFile,\"sequences\");\r\nend<\/pre>\nsequences(1:10)<\/pre>\n
![\"table\"](\"https:\/\/blogs.mathworks.com\/racing-lounge\/files\/2020\/05\/preview_sequences-1-189x300.png\")
<\/p>\nPrepare Training Data<\/h2>\n
labels = nanotrainlabels.stalled;\r\n\r\nnumObservations = numel(sequences);\r\nidx = randperm(numObservations);\r\nN = floor(0.9 * numObservations);\r\n\r\nidxTrain = idx(1:N);\r\nsequencesTrain = sequences(idxTrain);\r\nlabelsTrain = labels(idxTrain);\r\n\r\nidxValidation = idx(N+1:end);\r\nsequencesValidation = sequences(idxValidation);\r\nlabelsValidation = labels(idxValidation);<\/pre>\n
numObservationsTrain = numel(sequencesTrain);\r\nsequenceLengths = zeros(1,numObservationsTrain);\r\n\r\nfor i = 1:numObservationsTrain\r\n \u00a0\u00a0 sequence = sequencesTrain{i};\r\n \u00a0\u00a0 sequenceLengths(i) = size(sequence,2);\r\nend\r\n\r\nfigure\r\nhistogram(sequenceLengths)\r\ntitle(\"Sequence Lengths\")\r\nxlabel(\"Sequence Length\")\r\nylabel(\"Frequency\")\r\n<\/pre>\n![\"graph\"](\"https:\/\/blogs.mathworks.com\/racing-lounge\/files\/2020\/05\/sequence-lengths.png\")
<\/p>\nCreate LSTM Network<\/h2>\n
\n
numFeatures = size(sequencesTrain{1},1);\r\nnumClasses = 2;\r\n\r\nlayers = [\r\n \u00a0\u00a0 sequenceInputLayer(numFeatures,'Name','sequence')\r\n \u00a0\u00a0 bilstmLayer(2000,'OutputMode','last','Name','bilstm')\r\n \u00a0\u00a0 dropoutLayer(0.5,'Name','drop')\r\n \u00a0\u00a0 fullyConnectedLayer(numClasses,'Name','fc')\r\n\u00a0\u00a0\u00a0 softmaxLayer('Name','softmax')\r\n\u00a0\u00a0\u00a0 classificationLayer('Name','classification')];<\/pre>\nSpecify Training Options<\/h2>\n
\n
miniBatchSize = 16;\r\nnumObservations = numel(sequencesTrain);\r\nnumIterationsPerEpoch = floor(numObservations \/ miniBatchSize);\r\n\r\noptions = trainingOptions('adam', ...\r\n\u00a0\u00a0\u00a0 'MiniBatchSize',miniBatchSize, ...\r\n\u00a0\u00a0\u00a0 'InitialLearnRate',1e-4, ...\r\n\u00a0\u00a0\u00a0 'GradientThreshold',2, ...\r\n\u00a0\u00a0\u00a0 'Shuffle','every-epoch', ...\r\n\u00a0\u00a0\u00a0 'ValidationData',{sequencesValidation,labelsValidation}, ...\r\n\u00a0\u00a0\u00a0 'ValidationFrequency',numIterationsPerEpoch, ...\r\n\u00a0\u00a0\u00a0 'Plots','training-progress', ...\r\n\u00a0\u00a0\u00a0 'Verbose',false, ...\r\n\u00a0\u00a0\u00a0 'ExecutionEnvironment','auto');<\/pre>\nTrain LSTM Network<\/h2>\n
[netLSTM,info] = trainNetwork(sequencesTrain,labelsTrain,layers,options);<\/pre>\n
![\"graph\"](\"https:\/\/blogs.mathworks.com\/racing-lounge\/files\/2020\/05\/TP_GPU_5_19-1024x532.png\")
<\/p>\nYPred = classify(netLSTM,sequencesValidation,'MiniBatchSize',miniBatchSize);\r\nYValidation = labelsValidation;\r\naccuracy = mean(YPred == YValidation)<\/pre>\n
Assemble Video Classification Network<\/h2>\n
\n
![\"flowchart\"](\"https:\/\/blogs.mathworks.com\/racing-lounge\/files\/2020\/05\/Image_3.png\")
<\/p>\ncnnLayers = layerGraph(netCNN);<\/pre>\n
layerNames = [\"data\" \"pool5-drop_7x7_s1\" \"loss3-classifier\" \"prob\" \"output\"];\r\ncnnLayers = removeLayers(cnnLayers,layerNames);<\/pre>\n
inputSize = netCNN.Layers(1).InputSize(1:2);\r\naverageImage = netCNN.Layers(1).Mean;\r\n\r\ninputLayer = sequenceInputLayer([inputSize 3], ...\r\n\u00a0\u00a0\u00a0 'Normalization','zerocenter', ...\r\n\u00a0\u00a0\u00a0 'Mean',averageImage, ...\r\n\u00a0\u00a0\u00a0 'Name','input');<\/pre>\n
layers = [\r\n\u00a0\u00a0\u00a0 inputLayer\r\n\u00a0\u00a0\u00a0 sequenceFoldingLayer('Name','fold')];\r\n\r\nlgraph = addLayers(cnnLayers,layers);\r\nlgraph = connectLayers(lgraph,\"fold\/out\",\"conv1-7x7_s2\");<\/pre>\nlstmLayers = netLSTM.Layers;\r\nlstmLayers(1) = [];<\/pre>\n
layers = [\r\n\u00a0\u00a0\u00a0 sequenceUnfoldingLayer('Name','unfold')\r\n\u00a0\u00a0\u00a0 flattenLayer('Name','flatten')\r\n\u00a0\u00a0\u00a0 lstmLayers];\r\n\r\nlgraph = addLayers(lgraph,layers);\r\nlgraph = connectLayers(lgraph,\"pool5-7x7_s1\",\"unfold\/in\");<\/pre>\nlgraph = connectLayers(lgraph,\"fold\/miniBatchSize\",\"unfold\/miniBatchSize\");<\/pre>\n
analyzeNetwork(lgraph)\r\n<\/pre>\n
![\"screenshot\"](\"https:\/\/blogs.mathworks.com\/racing-lounge\/files\/2020\/05\/net_v1_5_19-1024x647.png\")
<\/p>\n![\"screenshot\"](\"https:\/\/blogs.mathworks.com\/racing-lounge\/files\/2020\/05\/net_v2_5_19-1024x565.png\")
<\/p>\nnet = assembleNetwork(lgraph)\r\n\r\n<\/pre>\n
![\"code](\"https:\/\/blogs.mathworks.com\/racing-lounge\/files\/2020\/05\/DAG_network-300x113.png\")
<\/p>\nPrepare Test Data<\/h2>\n
testfds = fileDatastore('s3:\/\/drivendata-competition-clog-loss\/test\/','ReadFcn', @readVideo);\r\ntestfdsReSz = transform(testfds,@(x) {imresize(x,inputSize)});<\/pre>\nClassify Using Test Data<\/h2>\n
testFiles = testfds.Files;\r\nnumTestFiles = numel(testFiles);\r\n\r\nYPred = cell(numTestFiles,1);\r\n\r\nfor i = 1:numTestFiles\r\n \u00a0\u00a0 fprintf(\"Reading file %d of %d...\\n\", i, numTestFiles);\r\n \u00a0\u00a0 YPred{i,1} = classify(net,read(testfdsReSz),'ExecutionEnvironment','auto');\r\nend<\/pre>\nSave Submission to File<\/h1>\n
test = readtable(\"test_metadata.csv\");\r\ntestResults = table(test.filename,YPred(:,1),'VariableNames',{'filename','stalled'});<\/pre>\nwritetable(testResults,'testResults.csv');<\/pre>\n
Helper Functions<\/h1>\n
function video = readVideo(filename)\r\n\r\nvr = VideoReader(filename);\r\ni = 0;\r\n% video = zeros;\r\n\r\nwhile hasFrame(vr)\r\n\u00a0\u00a0\u00a0 i = i+1;\r\n\u00a0\u00a0\u00a0 frame = readFrame(vr);\r\n\u00a0\u00a0\u00a0 if i < 2\r\n\u00a0\u00a0\u00a0 \u00a0\u00a0 Bbox = detectROI(frame);\r\n\u00a0\u00a0\u00a0 end\r\n \u00a0\u00a0 frame = imcrop(frame, Bbox);\r\n \u00a0\u00a0 video(:,:,:,i)=frame;\r\nend\r\n\r\nend<\/pre>\n
\n
function [Bbox] = detectROI(frameIn)\r\n\r\n%% Setup the detector and initialize variables\r\npersistent detector\r\nif isempty(detector)\r\n \u00a0\u00a0 detector = vision.BlobAnalysis('BoundingBoxOutputPort',true,'MajorAxisLengthOutputPort',true);\r\nend\r\n\r\nthreshold = [104 255; 13 143; 9 98];\r\n\r\nmask = (frameIn (:,:,1) >= threshold(1,1))& (frameIn (:,:,1) <= threshold(1,2))&...\r\n(frameIn (:,:,2) >= threshold(2,1))& (frameIn (:,:,2) <= threshold(2,2))&...\r\n(frameIn (:,:,3) >= threshold(3,1))& (frameIn (:,:,3) <= threshold(3,2));\r\n\r\n[~, ~, Bbox1, majorAxis] = detector(mask);\r\n\r\nif ~isempty(majorAxis)\r\n% Identify Largest Blob\r\n \u00a0\u00a0 [~,mIdx] = max(majorAxis);\r\n \u00a0\u00a0 Bbox = Bbox1(mIdx,:);\r\n\r\nend\r\n\r\nend<\/pre>\n![\"gif\"](\"https:\/\/blogs.mathworks.com\/student-lounge\/files\/2020\/05\/StallCatchers_gif2.gif\")
<\/div>\n
\nHello all! We at MathWorks, in collaboration with DrivenData, are excited to… read more >><\/a><\/p>\n","protected":false},"author":163,"featured_media":4111,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[365],"tags":[399,363,104,401,128,397,395],"_links":{"self":[{"href":"https:\/\/blogs.mathworks.com\/student-lounge\/wp-json\/wp\/v2\/posts\/4015"}],"collection":[{"href":"https:\/\/blogs.mathworks.com\/student-lounge\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blogs.mathworks.com\/student-lounge\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blogs.mathworks.com\/student-lounge\/wp-json\/wp\/v2\/users\/163"}],"replies":[{"embeddable":true,"href":"https:\/\/blogs.mathworks.com\/student-lounge\/wp-json\/wp\/v2\/comments?post=4015"}],"version-history":[{"count":37,"href":"https:\/\/blogs.mathworks.com\/student-lounge\/wp-json\/wp\/v2\/posts\/4015\/revisions"}],"predecessor-version":[{"id":4737,"href":"https:\/\/blogs.mathworks.com\/student-lounge\/wp-json\/wp\/v2\/posts\/4015\/revisions\/4737"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blogs.mathworks.com\/student-lounge\/wp-json\/wp\/v2\/media\/4111"}],"wp:attachment":[{"href":"https:\/\/blogs.mathworks.com\/student-lounge\/wp-json\/wp\/v2\/media?parent=4015"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blogs.mathworks.com\/student-lounge\/wp-json\/wp\/v2\/categories?post=4015"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blogs.mathworks.com\/student-lounge\/wp-json\/wp\/v2\/tags?post=4015"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}