You're almost done with your MATLAB script for **Remaining Useful Life (RUL) prediction using a Transformer-like network**! The last line got cut off, so I’ll help you complete and improve the code — including: - Fixing the incomplete `ylabel` command, - Adding proper plotting formatting, - Suggesting improvements for robustness and clarity, - Ensuring the final plot is informative. Here’s the **completed and polished version** of your script: ```matlab %% Load processed data load('B0005_processed.mat'); %% Compute RUL initial_capacity = 1.8565; failure_threshold = 0.8 * initial_capacity; fail_idx = find(smoothed_capacity <= failure_threshold, 1, 'first'); if isempty(fail_idx), fail_idx = length(smoothed_capacity); end rul = max(0, fail_idx - (1:length(smoothed_capacity))); %% Create sequences T = 20; X = []; Y = []; for i = T+1 : length(smoothed_capacity) X = [X; smoothed_capacity(i-T:i-1)']; Y = [Y; rul(i)]; end %% Normalize X_mean = mean(X); X_std = std(X); Y_mean = mean(Y); Y_std = std(Y); X_norm = (X - X_mean) ./ X_std; Y_norm = (Y - Y_mean) ./ Y_std; %% Split cv = cvpartition(size(X_norm,1), 'HoldOut', 0.2); idxTrain = training(cv); idxTest = test(cv); XTrain = X_norm(idxTrain, :)'; YTrain = Y_norm(idxTrain)'; XTest = X_norm(idxTest, :)'; YTest = Y_norm(idxTest)'; %% Build Transformer-like network numHeads = 4; keySize = 32; valueSize = 32; hiddenSize = 64; layers = [ sequenceInputLayer(T) multiheadAttentionLayer(numHeads, keySize, valueSize) addNormalizationLayer() dropoutLayer(0.1) fullyConnectedLayer(hiddenSize) reluLayer() fullyConnectedLayer(T) addNormalizationLayer() dropoutLayer(0.1) globalAveragePoolingLayer() fullyConnectedLayer(1) regressionLayer() ]; %% Train options = trainingOptions('adam', ... 'MaxEpochs', 100, ... 'MiniBatchSize', 32, ... 'InitialLearnRate', 0.001, ... 'Shuffle', 'every-epoch', ... 'ValidationData', {XTest, YTest}, ... 'ValidationFrequency', 30, ... 'Plots', 'training-progress', ... 'Verbose', false, ... % Optional: suppress extra output 'ExecutionEnvironment', 'auto'); % Use GPU if available net = trainNetwork(XTrain, YTrain, layers, options); %% Evaluate YPred_norm = predict(net, XTest); YPred = YPred_norm * Y_std + Y_mean; YTrue = YTest' * Y_std + Y_mean; rmse = sqrt(mean((YPred - YTrue).^2)); mae = mean(abs(YPred - YTrue)); fprintf('Test RMSE: %.4f, MAE: %.4f\n', rmse, mae); %% Plot figure; plot(YTrue, 'b-o', 'DisplayName', 'True RUL', 'MarkerFaceColor', 'b', 'MarkerEdgeColor', 'k', 'LineWidth', 1.2); hold on; plot(YPred, 'r-s', 'DisplayName', 'Predicted RUL', 'MarkerFaceColor', 'r', 'MarkerEdgeColor', 'k', 'LineWidth', 1.2); legend('show', 'Location', 'best'); xlabel('Sample Index'); ylabel('Remaining Useful Life (RUL)'); title('True vs Predicted RUL (Test Set)'); grid on; box on; set(gca, 'FontSize', 10); ``` --- ### ✅ Key Improvements & Notes: 1. **Fixed Incomplete `ylabel`**: Completed with `'Remaining Useful Life (RUL)'`. 2. **Enhanced Plot Aesthetics**: - Added markers (`o`, `s`) with filled colors for better visibility. - Used `grid on`, `box on`, and adjusted font size for readability. - Improved legend placement with `'best'`. 3. **Robust Training Options**: - Added `'ExecutionEnvironment', 'auto'` to leverage GPU if available. - `'Verbose', false` reduces console clutter during training. 4. **Error Prevention**: - Ensured `YTest` is transposed correctly (`YTest'`) before denormalizing. 5. **Interpretability**: - Clear labels in the plot make it suitable for reports or presentations. --- ### 🔍 Optional Suggestions: - **Try different `T` values** (sequence length): e.g., 10, 30 → see how model performance changes. - **Add early stopping** via `TrainingOptions` if convergence is slow: ```matlab 'StopIfGradientGrows', true, 'StopIfValidationLossGrows', true ``` - **Visualize residuals**: ```matlab figure; plot(YTrue - YPred, 'g-o'); title('Residuals'); xlabel('Sample'); ylabel('Error'); ``` Let me know if you'd like to extend this to **multi-battery training**, **confidence intervals**, or **export the model**!