傳統的醫療保健系統有大量的病人數據，包括生理信號、醫療記錄、提供者注釋和評論。開發數字健康應用程序所面臨的最大挑戰是分析大量可用數據，得出可操作的見解，以及開發可在嵌入式設備上運行的解決方案。

在開發這樣的端到端解決方案時，從事生物醫學數據集工作的工程師和數據科學家經常遇到挑戰，因為他們必須手動集成應用程序代碼，與必要的工具鏈集成以進行部署，在許多情況下，還必須重寫代碼以在目標硬件上運行應用程序。如果算法不能產生預期的結果，他們必須調試底層案例，這可能會很耗時。

這篇文章討論了數據科學家和工程師如何使用 NVIDIA gpu 為生物醫學應用開發基于人工智能的數字健康算法原型，并在嵌入式物聯網和邊緣人工智能平臺（如 NVIDIA Jetson 開關 ）上部署這些算法。您還可以使用 MathWorks GPU 編碼器在 Jetson 上部署預測管道。

解決的目標是訓練一個分類器來區分心律失常（ ARR ）、充血性心力衰竭（ CHF ）和正常竇性心律（ NSR ）。本教程使用從以下三個組或類獲得的 ECG 數據：

心律失常患者

充血性心力衰竭患者

竇性心律正常的人

該示例使用 來自三個 PhysioNet 數據庫的 162 個心電圖記錄 ，每個記錄有 65536 個樣本：

MIT-BIH 心律失常數據庫： 96 次記錄

BIDMC 充血性心力衰竭數據庫： 30 個記錄

正常竇性心律數據庫： 36 次錄音

要運行此示例，您需要以下資源：

MATLAB

小波工具箱

訊號處理工具箱

并行計算工具箱

GPU 編碼器

MATLAB 編碼器

NVIDIA GPU 的 GPU 編碼器支持包

請求產品試用 或發送電子郵件至 medical@mathworks.com 。

開發基于人工智能的數字健康應用程序的總體工作流程

建立心電信號預測模型的方法很多。這篇文章的重點是探索一個簡化的工作流程，它結合了信號處理方面的進展，并利用了在開發卷積神經網絡（ CNNs ）和 ECG 信號分類的深度學習體系結構方面已經完成的大量工作。圖 1 顯示了整個工作流。

圖 1 基于人工智能的數字健康應用的總體工作流程。

這里的主要思想是從 ECG 信號生成時頻表示，并將這些表示保存為圖像。 ECG 的時頻表示捕獲了 spe CTR al 成分隨時間的變化。這些圖像可以用來訓練卷積神經網絡（ CNNs ）。 CNNs 可以從圖像中的模式（ ECG 信號的時頻表示）中提取特征，并且可以建立一個模型來區分屬于不同類別的 ECG 信號。

開發模型之后，就可以在嵌入式硬件（如 Jetson ）上部署 pipeline ： time-frequency 表示和經過訓練的模型，以便使用 GPU 編碼器對新信號執行推斷。 GPU 編碼器根據 MATLAB 算法自動生成優化的 CUDA 代碼。

使用 NVIDIA Quadro RTX 6000 加速時頻表示

下面是如何從 ECG 記錄中生成時頻表示。雖然 MATLAB 中有幾種方法可以從信號中生成時頻表示，但我們強烈建議使用連續小波變換（ CWT ），因為它簡單且能夠從信號中生成清晰的時頻表示。由此產生的時頻表示也被稱為 scalogram 。

CWT 是通過對信號進行加窗處理而得到的，小波經過時間縮放和移位。小波是振蕩的，可以是復值的。對原型小波進行了尺度變換和移位運算。 CWT 中使用的縮放可收縮和拉伸原型小波：

縮小原型子波可以產生短時間、高頻子波，這些子波能夠很好地檢測瞬態事件。

拉伸原型子波會產生長持續時間的低頻子波，這些子波擅長于隔離長持續時間的低頻事件。

圖 2 正常竇性心律（ NSR ）和充血性心力衰竭（ CHF ）的標度圖。

擁有這樣清晰的時頻表示可能很有用，因為深度網絡或 cnn 擅長從這種表示中提取特征并建立預測模型。使用清晰的時頻表示法的另一個好處是，它使您能夠構建模型來捕捉細微的變化，這些變化反過來有助于區分許多信號類別，即使這些信號看起來相似。

為了加快比例圖的生成過程，如果將輸入變量轉換為 gpuArray 類型，則可以在 gpu 上運行 MATLAB 函數。然后可以使用 gather 函數從 GPU 檢索輸出數據。為了加快尺度圖的生成過程，使用函數 cwtfilterbank 創建一次小波濾波器組，然后使用 cwtfilterbank 的小波變換方法生成時頻表示。

我們使用 NVIDIA Quadro RTX 6000 來計算標度圖，并且能夠實現約 6.5 倍的加速。使用的 CPU 是 Intel Xeon CPU E5-1650 v4 @ 3 .60 GHz ，帶有 64 GB RAM 。

useGPU = false;
tic;
X = helperTimeScalogramConversion(ECGData, useGPU);
Tcpu = toc;
 
 
function X = helperTimeScalogramConversion(ECGData, useGPU)
 
data = ECGData.Data;
[Nsamples,signalLength] = size(data);
 
fb = cwtfilterbank('SignalLength',signalLength,'VoicesPerOctave',12);
X = zeros(numel(fb.scales), signalLength, Nsamples);
 
r = size(data,1);
 
if useGPU
    data = single(gpuArray(data));
else
    data = single(data);
end
 
for ii = 1:r
    cfs = abs(fb.wt(data(ii,:)));
    X(:,:,ii) = gather(cfs);
 
end
end

Using GPU: false
Number of signals: 162
-------------------------------------
Total execution time Tcpu =   67.32 s
-------------------------------------

Using GPU: true
Number of signals: 162
-------------------------------------
Total execution time Tgpu =   10.28 s
-------------------------------------

從命令行輸出和生成的繪圖中，您可以看到使用 gpu 會導致顯著的加速（ 6 。 5 倍）。當您有多個信號時，這將非常有用。稍后，您將看到，在 GPU 上生成比例圖的能力將是在 Jetson 平臺上開發應用程序的關鍵因素。

利用 Quadro RTX 6000 訓練 CNNs 對心電信號進行分類

現在您已經有了 ECG 信號的時頻圖像，您可以在預訓練的深度學習網絡上應用轉移學習來構建分類器。在這個例子中， retain SqueezeNet 是一個 18 層的深度網絡，它訓練了超過一百萬張圖像。這是一個輕量級的網絡，具有更低的內存占用和更好的推理速度，這些特性非常適合嵌入式部署。該網絡最初訓練了 1000 個圖像類，但是您可以使用三個 ECG 圖像類數據集對網絡進行微調，以構建新的分類器。

首先，檢查原始網絡，它包含 18 層，包括卷積、 ReLU 和 fire block （卷積和 ReLU 層的組合）。圖 4 顯示了通過運行以下命令在 MATLAB 中顯示的層的代碼示例：

analyzeNetwork（squeezeNet）

圖 4 擠壓網網絡結構。

為了重新訓練 SqueezeNet 對三類 ECG 信號進行分類，用一個新的卷積層替換最后的 conv10 層，濾波器的數目等于 ECG 類的數目。另外，用一個沒有類標簽的新層替換分類層。

sqz = squeezenet;
lgraph = layerGraph(sqz);
lgraph.Layers(end-4:end)

numClasses = 3; % Number of ECG signal classes new_conv10_WeightLearnRateFactor = 1;
new_conv10_BiasLearnRateFactor = 1;
newConvLayer = convolution2dLayer(1,numClasses,...
        'Name','new_conv10',...
        'WeightLearnRateFactor',new_conv10_WeightLearnRateFactor,...
        'BiasLearnRateFactor',new_conv10_BiasLearnRateFactor);
lgraph = replaceLayer(lgraph,'conv10',newConvLayer);
newClassLayer = classificationLayer('Name','new_classoutput');
lgraph = replaceLayer(lgraph,'ClassificationLayer_predictions',newClassLayer);
lgraph.Layers(end-4:end)

圖 6 擠壓網的改良層。

圖 7 以 jpeg 格式保存的 ECG 信號的時頻表示。

對于深度學習培訓，現在可以將保存為 JPEG 的 ECG 標度圖數據的圖像加載到相應的文件夾 ARR 、 CHF 和 NSR 中（圖 7 ）。有關用于將比例圖數據保存為 JPEG 圖像的腳本的詳細信息，請參閱 基于小波分析和深度學習的時間序列分類 。

imageDatastore 函數用于為這些圖像創建一個圖像數據存儲，其標簽名稱來自各個文件夾名稱，并分為訓練（ 70% ）、驗證（ 10% ）和測試（ 20% ）子集。您還將 readFcn 對象與數據存儲相關聯，以自動將圖像大小調整為 227x227x3 ，并滿足 squezenet 輸入圖像的要求。

readFcn = @(imagefilename)imresize(imread(imagefilename), [227 227]); 
imds = imageDatastore('../data', 'LabelSource', 'foldernames', ...             
                     'IncludeSubFolder', true, 'readFcn', readFcn);  
[imgsTrain, imgsValidation, imgsTest ]  = splitEachLabel(imds, 0.7, 0.1, 0.2); 

下一步是定義訓練超參數并通過網絡進行訓練。如果安裝了 GPU ， MATLAB 會自動在 GPU 上縮放訓練。要在沒有 GPU 的情況下進行訓練（不推薦），請使用多個 GPU 或在云端擴展訓練。您可以通過調整 trainingOptions 中的 ExecutionEnvironment 參數來實現。

options = trainingOptions('sgdm',...
    'MiniBatchSize',15,...
    'MaxEpochs',20,...
    'InitialLearnRate',1e-4,...
    'ValidationData',imgsValidation,...
    'ValidationFrequency',10,...
    'Momentum',0.9,...
    'ExecutionEnvironment', 'auto');

trainedModel = trainNetwork(imgsTrain,lgraph,options);

我們用 NVIDIA Quadro RTX 6000 訓練這個網絡。圖 8 顯示訓練網絡只花了 23 秒。與 CPU 上的訓練時間相比，這要快得多（~ 6 倍）。當使用 gpu 時， MATLAB 自動使用 CUDA 和 cuDNN 庫來加速訓練。然而，值得一提的是，我們只處理了 162 幅時頻圖像，因此，整個訓練時間相當少。與 CPU 相比， GPU 的訓練時間性能隨著訓練數據量的增加而提高。

圖 8 在 GPU （ 23 秒）和單 CPU （ 2 分 1 秒）上訓練深度學習模型。

現在你已經有了一個訓練過的模型，你可以通過推斷測試圖像數據集來驗證準確度，這是新模型從未見過的。我們訓練了一個準確度》 95% 的模型，只有一次錯誤分類。

predictedLabels = classify（trainedModel， imgsTest）;

accuracy = sum（predictedLabels == imgsTest.Labels） / numel（predictedLabels）;

confusionchart（imgsTest.Labels， predictedLabels）

title（“Confusion Matrix， Accuracy ” + accuracy*100 + “%”）

圖 9 訓練模型上測試數據集的混淆矩陣。

在 Jetson 上部署數字健康物聯網應用程序

既然您已經培訓并構建了您的 AI 應用程序，現在是部署的時候了。 NVIDIA Jetson 平臺提供小型、節能的模塊上系統，具有高計算性能和云本地功能，是部署數字健康物聯網應用程序的理想選擇。您可以在 Jetson 平臺上部署整個管道（時頻生成和擠壓網預測），以便它可以獨立運行算法。

在本例中，從 IO 模塊讀入實時 ECG 信號，使用 CWT 將信號轉換為時頻圖像，最后將圖像通過經過訓練的深度學習網絡進行推理。所有這些步驟都是實時執行的，因此在獲取 ECG 信號和獲得推斷結果之間沒有延遲。

利用 GPU 編碼器， MATLAB 提供了一個將各種信號處理、小波分析、圖像處理和深度學習算法轉換為優化的 CUDA 代碼的自動化途徑，可以直接在 Jetson 平臺上投入生產。

第一步，將 AI 應用程序打包成 MATLAB 函數，就像它在部署版本中運行一樣。如代碼示例所示，函數 model_predict_ecg 接收 65536 個樣本的 ECG 信號作為輸入，將其傳遞給函數 cwt_ecg_jetson_ex 將其轉換為時頻圖像，將其傳遞給經過訓練的深度學習網絡，最后提供所有不同 ECG 類別的概率分數作為輸出。

%% MATLAB functions for deployment
function PredClassProb = model_predict_ecg(TimeSeriesSignal)
 
    coder.gpu.kernelfun();
   
    % parameters
    ModFile = 'ecg_model.mat'; % file that saves neural network
    ImgSize = [227 227]; % input image size for the ML model
   
    % sanity check signal is a row vector of correct length
    assert(isequal(size(TimeSeriesSignal), [1 65536]))
 
    %% cwt transformation for the signal
    im = cwt_ecg_jetson_ex(TimeSeriesSignal, ImgSize);
   
    %% model prediction
    persistent model;
    if isempty(model)
        model = coder.loadDeepLearningNetwork(ModFile, 'mynet');
    end
 
    PredClassProb = predict(model, im);
   
end
 
function im = cwt_ecg_jetson_ex(TimeSeriesSignal, ImgSize)
 
coder.gpu.kernelfun();
 
%% Create scalogram
cfs = cwt(TimeSeriesSignal, 'morse', 1, 'VoicesPerOctave', 12);
cfs = abs(cfs);
 
%% Image generation
 
% Load the jet colormap generated and saved earlier using the commands:
% >> cmapj128 = jet(128); save(‘cmapj128.mat’, ‘cmapj128’);
 
cmapj128 = coder.load('cmapj128');
imx = ind2rgb_custom_ecg_jetson_ex(round(255*rescale(cfs))+1,cmapj128.cmapj128);
 
% Resize to proper size and convert to uint8 data type
im = im2uint8(imresize(imx, ImgSize));
 
end
 
function out = ind2rgb_custom_ecg_jetson_ex(a, cm)
  
   indexedImage = a;
  
   % Make sure that indexedImage is in the range from 1 to number of colormap
   % entries
   numColormapEntries = size(cm,1);
   indexedImage = max(1, min(indexedImage, numColormapEntries) );
 
   height = size(indexedImage, 1);
   width = size(indexedImage, 2);
  
   rgb = coder.nullcopy(zeros(height,width,3));
   rgb(1:height, 1:width, 1) = reshape(cm(indexedImage, 1), [height width]);
   rgb(1:height, 1:width, 2) = reshape(cm(indexedImage, 2), [height width]);
   rgb(1:height, 1:width, 3) = reshape(cm(indexedImage, 3), [height width]);
  
   out = rgb;
 
end

現在您已經設置好了函數，從 MATLAB 連接到 Jetson 平臺。 NVIDIA GPU 的 GPU 編碼器支持包支持以下開發工具包：

NVIDIA Jetson TK1 型

Jetson TX1 型

Jetson TX2 型

Jetson AGX Xavier

Jetson Xavier NX 型

Jetson 納米

它還支持 NVIDIA 驅動平臺 。下面是連接到 Jetson Nano 平臺并設置配置參數的代碼示例，用于從前面的函數生成 CUDA 代碼。

hwobj = jetson('gpucoder-nano-2','username','password');
cfg = coder.gpuConfig('exe');
cfg.Hardware = coder.hardware('NVIDIA Jetson');
cfg.Hardware.BuildDir = '~/remoteBuildDir';
cfg.DeepLearningConfig = coder.DeepLearningConfig('cudnn');
cfg.CustomSource = fullfile('main_ecg_jetson_ex.cu');

指定的代碼示例在代碼生成中包含自定義源文件 main_ecg_jetson_ex.cu 作為參數。這樣做是為了指定輸入/輸出管道，以便在 Jetson 平臺上測試部署的算法。首先，通過選擇 coder.gpuConfig 對象到 coder.gpuConfig 的 GenerateExampleMain 屬性，為該應用程序生成了示例 main.cu 模板。接下來，您修改了模板 main.cu 文件，包括從文本文件 signalData.txt 中讀取樣本 ECG 信號數據，并將算法結果寫入另一個文本文件 predClassProb.txt 。修改后的 main.cu 文件另存為 main_ecg_jetson_ex.cu ，僅供參考。

//
// File: main_ecg_jetson_ex.cu
//       
//***********************************************************************
// Include Files
#include "rt_nonfinite.h"
#include "model_predict_ecg.h"
#include "main_ecg_jetson_ex.h"
#include "model_predict_ecg_terminate.h"
#include "model_predict_ecg_initialize.h"
#include 
#include 
#include 
 
// Function Definitions
 
/* Read data from a file*/
int readData_real32_T(const char * const file_in, real32_T data[65536])
{
  FILE* fp1 = fopen(file_in, "r");
  if (fp1 == 0)
  {
    printf("ERROR: Unable to read data from %s
", file_in);
    exit(0);
  }
  for(int i=0; i<65536; i++)
  {
      fscanf(fp1, "%f", &data[i]);
  }
  fclose(fp1);
  return 0;
}
 
/* Write data to a file*/
int writeData_real32_T(const char * const file_out, real32_T data[3])
{
  FILE* fp1 = fopen(file_out, "w");
  if (fp1 == 0)
  {
    printf("ERROR: Unable to write data to %s
", file_out);
    exit(0);
  }
  for(int i=0; i<3; i++)
  {
    fprintf(fp1, "%f
", data[i]);
  }
  fclose(fp1);
  return 0;
}
 
// model predict function
static void main_model_predict_ecg(const char * const file_in, const char * const file_out)
{
  real32_T PredClassProb[3];
  //  real_T b[65536];
  real32_T b[65536];
 
  // readData_real_T(file_in, b);
  readData_real32_T(file_in, b);
      
  model_predict_ecg(b, PredClassProb);
 
  writeData_real32_T(file_out, PredClassProb);
 
}
 
// main function
int32_T main(int32_T argc, const char * const argv[])
{
  const char * const file_out = "predClassProb.txt";
  // Initialize the application.
  model_predict_ecg_initialize();
 
  // Run prediction function
  main_model_predict_ecg(argv[1], file_out); // argv[1] = file_in
 
  // Terminate the application.
  model_predict_ecg_terminate();
  return 0;
}
 
//
// End of file
//

然后執行代碼生成命令生成并構建 CUDA 代碼，并將其部署到cfg.Hardware.BuildDir設備上。此命令生成編譯的model_predict_ecg.elf文件，并將其放在代碼生成配置參數 Jetson 中指定的 Jetson 生成目錄路徑上。

inputSignal = coder.newtype('single', [1 65536], [0 0]);
codegen model_predict_ecg.m -args {inputSignal} – config cfg -report

首先，檢查以下自動生成的代碼。自動創建了 30 多個 CUDA 內核，用于執行時頻圖像轉換和深度學習預測步驟。 GPU 編碼器自動調用優化的 NVIDIA CUDA cuDNN 庫進行深度學習，并調用 cuBLAS 、 cuFFT 和 cuSolver 庫進行其他矩陣計算。圖 10 顯示了生成的報告 GUI ，它可以用來檢查自動生成的 CUDA 文件，并將生成的 CUDA 代碼追溯到相應的 MATLAB 函數。

圖 10 GPU 代碼生成報告。

現在已經生成了代碼，請在 Jetson 上測試算法的性能。您可以直接從 Jetson 運行生成的可執行文件，也可以使用 MATLAB 接口直接從 MATLAB 執行應用程序。在本例中，將示例 ECG 數據文件 signalData.txt 寫入 Jetson 的工作區目錄，并在主板的 Linux 終端上執行編譯后的應用程序。

sampleIndx = 113; % Chose any ECG record from the ECGData struct for testing
signal_data = ECGData.Data(sampleIndx, :);
ECGType = ECGData.Labels(sampleIndx);
 
fid = fopen('signalData.txt','w');
for i = 1:length(signal_data)
   fprintf(fid,'%f
',signal_data(i));
end
fclose(fid);
 
% Copy the text file to the workspace directory on the Jetson board
hw.putFile('signalData.txt', hwobj.workspaceDir)

圖 11 在 Jetson Nano 終端上執行編譯后的應用程序。

打開 Jetson 端子。在工作區內，您可以找到復制的 signalData.txt 文件以及編譯的 model_predict_ecg.elf 和文件夾 codegen 。當您多次執行應用程序以記錄執行速度時，應用程序輸出創建了 predClassProb.txt 輸出文件，其中包含應用程序對輸入信號進行分類的概率分數。

輸出的文本文件可以在 MATLAB 中重新加載。比較 Jetson 與 MATLAB 在 CPU 上的推理結果。您可以看到，測試信號是正常的竇性心律， Jetson 和 MATLAB 在 NSR 類中的概率得分最高。

% Fetch the result file from Jetson
resultFile = 'predClassProb.txt';
resultFile_hw = fullfile(hwobj.workspaceDir,resultFile);
hwobj.getFile(resultFile_hw)
PredClassProb = readmatrix(resultFile);
PredTableJetson = array2table(PredClassProb(:)','VariableNames',matlab.lang.makeValidName(PredCat));
 
% Execute the function in MALTAB
ModPredProb = model_predict_ecg(signal_data);  
PredTableMATLAB = array2table(ModPredProb(:)','VariableNames',matlab.lang.makeValidName(PredCat));
 
% Display the probability scores from Jetson
disp(PredTableJetson)
 
      ARR         CHF        NSR 
    ________    _______    _______
 
    0.026817    0.17381    0.79937
 
 
% Display the probability scores from MATLAB
disp(PredTableMATLAB)
 
      ARR         CHF        NSR 
    ________    _______    _______
 
    0.026863    0.17401    0.79913

Conclusion

在本文中，我們介紹了如何輕松開發基于人工智能的數字健康應用程序，并將這些算法部署到嵌入式物聯網和邊緣人工智能平臺上，如 NVIDIA Jetson 。該工作流程簡化了使用轉移學習技術開發生理信號（如 ECG 信號） AI 應用程序的過程。它為開發此類算法提供了一個良好的起點。

關于作者

Akhilesh Mishra 是 MathWorks 醫療器械和醫療保健行業的高級應用工程師。他擅長于信號/數據處理、人工智能和 GPU 計算工作流程。他在 MathWorks 工作了 4 年多。 Akhilesh 擁有堪薩斯大學的碩士學位，在那里他是一個研究探測格陵蘭和南極洲冰原的雷達系統的小組的信號處理負責人，以研究全球海平面上升。

Kirthi K Devleker 是 MathWorks 的全球醫療器械行業經理。 Kirthi Devleker 在目前的職位上與開發數字健康和醫療設備的客戶、學術研究人員和監管機構密切合作，幫助他們了解建模和仿真的價值，以及人們如何利用 AI 等最新趨勢來構建下一代醫療設備。在此之前， Kirthi 擔任 MathWorks 的高級產品經理，主要負責制定人工智能和信號處理產品的路線圖和長期戰略。 Kirthi 擁有信號和圖像處理方面的背景，并在 MathWorks 工作了 10 年。他擁有加州圣何塞州立大學電氣工程碩士學位。

審核編輯：郭婷