Main Content

Generate Code that Preserves RUL Model State for System Restart

This example shows how to generate code for predicting remaining useful life (RUL) that preserves the state of the RUL model when the prediction algorithm is stopped and restarted. This workflow is useful when you use incoming data to update the RUL model during system operation. When you do so, on system shutdown, you risk losing any updates you make to the model. This example shows how to use the readState and restoreState commands in your entry-point function to preserve updates made to the model at run time.

This example builds on the workflow shown in Generate Code for Predicting Remaining Useful Life. You can use the workflow of this example to generate code for predicting remaining useful life with degradation-based RUL models, linearDegradationModel and exponentialDegradationModel.

Fit RUL Model

Before generating code for RUL prediction, you must fit an RUL model using historical data. For this example, load the data in linTrainTables.mat. This file contains measurements of some condition indicator taken over time, organized into tables with column labels "Time" and "Condition". Use this data to train a linear degradation model. (For more information about configuring and training this type of RUL model, see linearDegradationModel.)

load('linTrainTables.mat')

mdl = linearDegradationModel;
fit(mdl,linTrainTables,"Time","Condition")

Prepare Model for Code Generation

As described in Generate Code for Predicting Remaining Useful Life, to prepare the model for code generation, use saveRULModelForCoder to store the RUL model as a data structure in a MAT file. Later, in the entry-point function, use loadRULModelForCoder to load and reconstruct the linearDegradationModel object.

saveMATfilename = 'savedModel.mat';
saveRULModelForCoder(mdl,saveMATfilename);

Optionally, you can update the model parameters using additional data collected after the training data. For this example, load linTestData1, which is a 121-row table of times and condition-indicator values. Use the first two entries in this table to update the model.

load('linTestData.mat','linTestData1')
updateData = linTestData1(1:2,:);
update(mdl,updateData);

Next, read the model state using readState. This command converts the RUL model object into a structure that you can pass to the entry-point function as an input argument.

savedState = readState(mdl);

Define Entry-Point Function

The entry-point function is the function for which you want to generate code. For this example, create the entry-point function degradationRULPreserveState.m, as shown here.

type degradationRULPreserveState.m
function [estRULOut,ciOut,newState] = degradationRULPreserveState(data,restoreStateFlag,savedState)
%#codegen

persistent mdl

% Load the model the first time function is called
if isempty(mdl)
   mdl = loadRULModelForCoder('savedModel');  
end

% Restore the saved model parameters if needed
if restoreStateFlag
   restoreState(mdl,savedState);
end

% Update model and prediction with new data
threshold = 60;
update(mdl,data);
[estRULOut,ciOut] = predictRUL(mdl,threshold);

% Read the updated model parameters 
newState = readState(mdl);

end

This function updates the RUL prediction model using the update command each time it is called with new input data. Declaring mdl as a persistent variable preserves the updated model parameters between calls while the function remains in memory. This function writes the updated model parameters to the output argument newState. You can use this output argument to preserve the updated model state when the function is cleared from memory. Thus, for example, when restarting the prediction algorithm after a system shutdown, you can set restoreStateFlag to true and pass in the most recently saved savedState, ensuring that the system resumes prediction using the most recently updated model parameters.

Generate Code

To generate code, you must provide sample data having the data type and format of each input argument expected by the entry-point function. For this example, use the next entry in linTestData1. Also, set restoreStateFlag to the logical value true.

testData = linTestData1(3,:);
restoreStateFlag = true;

Now you can generate code using the following codegen (MATLAB Coder) command.

codegen degradationRULPreserveState -args {testData,restoreStateFlag,savedState} -nargout 3
Code generation successful.

This command generates a MEX file, which is an executable that you can call from within MATLAB®. You can use procedures similar to this example to generate code for any other target that codegen supports. Alternatively, you can use the MATLAB Coder app, as shown in Generate Code for Predicting Remaining Useful Life.

Validate the Generated Code

To validate the generated code, at the MATLAB command prompt, run the entry-point MATLAB function on the test data. Then, run the generated MEX file on the same data and confirm that the results are the same.

[estRUL,ci,newState] = degradationRULPreserveState(testData,restoreStateFlag,savedState);
[estRUL_mex,ci_mex,newState_mex] = degradationRULPreserveState_mex(testData,restoreStateFlag,savedState);

For example, compare the estimated RUL obtained with the MATLAB function and the generated MEX file.

estRUL,ci
estRUL = 113.8920
ci = 1×2

   83.0901  172.5393

estRUL_mex,ci_mex
estRUL_mex = 113.8920
ci_mex = 1×2

   83.0901  172.5393

You can now use the generated code as part of your deployed system for predicting remaining useful life. Store the value of newState to use when you need to restart the system. For example, take the next data point in linTestData1 and use it to update the prediction, starting with newState_mex, the model state generated in the previous call to the MEX file.

testData2 = linTestData1(4,:);
[estRUL2_mex,ci2_mex,newState2_mex] = degradationRULPreserveState_mex(testData2,restoreStateFlag,newState_mex);

estRUL2_mex,ci2_mex
estRUL2_mex = 104.4336
ci2_mex = 1×2

   77.8216  154.1263

Note that the MATLAB function and the MEX file each manage their own persistent variables. Therefore, the MEX file value of mdl now incorporates the update from testData2, which the function value of mdl does not. To reset the values of these persistent variables, explicitly clear the function and the MEX file from memory.

clear degradationRULPreserveState;
clear degradationRULPreserveState_mex;

See Also

| | |

Related Topics