雷达源识别笔记

问AI话术和AI分析总结

我需要用模式识别算法对雷达源进行分类和识别，数据集为30个特定场景，每一个场景有几万条接收端依次接收到的雷达信号，每一条数据包括频率、脉冲宽度、到达时间、到达角度、幅度和脉内数据(复数序列表示)，但是不知道每条数据究竟是哪种雷达发出的，只告诉一个场景下雷达的种类和个数。比如第一个场景给了几万条数据，但是只告诉第一个场景下有种类1雷达2个，种类2雷达3个。我该怎么选择算法，实现通过训练数据，得到任意给定一个场景下几万条数据，可以识别出雷达的种类和个数？

%% 雷达辐射源识别系统 - 完整实现
% 包含30个训练场景和10个测试场景的完整处理流程
clear; clc; close all;
rng(42); % 固定随机种子
if isempty(gcp('nocreate')), parpool('threads'); end % 启动并行计算

%% 全局参数配置
fs = 5e6;                % 采样频率
nRadarTypes = 50;        % 雷达型号总数
stableFeatures = [1,3,5,7,9:12,14:17]; % 稳定特征索引
spatialFeatures = [4,8,13,18:19];      % 空间特征索引

%% ====================== 完整场景定义 ======================
[scene_radars, scene_counts] = init_scene_definitions();

%% ====================== 训练阶段 ======================
[trainData, trainMasks] = parallel_feature_processing('Train_data', scene_radars, scene_counts);
[model, normParams] = train_advanced_model(trainData, trainMasks, scene_radars, scene_counts);
save('radar_model.mat', 'model', 'normParams', 'scene_radars');

%% ====================== 测试阶段 ======================
testResults = cell(10,1);
parfor testIdx = 1:10
    testFeatures = process_test_scene(testIdx, 'Test_data', normParams);
    predLabels = radar_predictor(testFeatures, model, scene_radars);
    testResults{testIdx} = results_postprocessor(predLabels, scene_radars);
end

%% 结果可视化
generate_analysis_report(testResults);

%% ====================== 核心函数定义 ======================
function [scene_radars, scene_counts] = init_scene_definitions()
    scene_radars = cell(30,1);
    scene_counts = cell(30,1);
    
    % 场景1-19 (简单组合)
    scene_radars{1} = [1,5,12];    scene_counts{1} = [3,2,2];
    scene_radars{2} = [2,8];       scene_counts{2} = [3,3];
    scene_radars{3} = [3,9,17];    scene_counts{3} = [3,3,2];
    scene_radars{4} = [4,11];      scene_counts{4} = [3,3];
    scene_radars{5} = [6,15,21];   scene_counts{5} = [3,2,2];
    scene_radars{6} = [7,19,28];   scene_counts{6} = [3,2,2];
    scene_radars{7} = [10,18,25];  scene_counts{7} = [3,2,2];
    scene_radars{8} = [13,23,30];  scene_counts{8} = [3,2,2];
    scene_radars{9} = [14,24,32];  scene_counts{9} = [3,2,2];
    scene_radars{10} = [16,33];    scene_counts{10} = [3,3];
    scene_radars{11} = [20,27,35]; scene_counts{11} = [3,2,2];
    scene_radars{12} = [22,28,29]; scene_counts{12} = [3,2,2];
    scene_radars{13} = [26,31,40]; scene_counts{13} = [3,2,2];
    scene_radars{14} = [34,43,48]; scene_counts{14} = [3,2,2];
    scene_radars{15} = [36,41,49]; scene_counts{15} = [3,2,2];
    scene_radars{16} = [37,44];    scene_counts{16} = [3,3];
    scene_radars{17} = [39,45];    scene_counts{17} = [3,3];
    scene_radars{18} = [42,47];    scene_counts{18} = [3,3];
    scene_radars{19} = [46,50];    scene_counts{19} = [3,3];

    % 场景20-30 (复杂组合)
    scene_radars{20} = [5,7,12,16,18];  scene_counts{20} = [2,2,2,1,1];
    scene_radars{21} = [1,22,23,24,25]; scene_counts{21} = [2,2,2,1,1];
    scene_radars{22} = [2,4,9,31,33];   scene_counts{22} = [2,2,2,1,1];
    scene_radars{23} = [3,6,8,15,21];   scene_counts{23} = [2,2,2,1,1];
    scene_radars{24} = [10,17,27,30,35]; scene_counts{24} = [2,2,2,1,1];
    scene_radars{25} = [11,19,25,29,38]; scene_counts{25} = [2,2,2,1,1];
    scene_radars{26} = [13,20,28,32,40]; scene_counts{26} = [2,2,2,1,1];
    scene_radars{27} = [14,26,32,42,47]; scene_counts{27} = [2,2,2,1,1];
    scene_radars{28} = [16,29,33,37,41]; scene_counts{28} = [2,2,2,1,1];
    scene_radars{29} = [34,36,40,45,49]; scene_counts{29} = [2,2,2,1,1];
    scene_radars{30} = [35,39,41,46,50]; scene_counts{30} = [2,2,2,1,1];
end

function [features, masks] = parallel_feature_processing(dataDir, sceneRadars, sceneCounts)
    features = cell(30,1);
    masks = cell(30,1);
    
    parfor sceneIdx = 1:30
        % 数据读取
        pdwFile = fullfile(dataDir, sprintf('Train_PDW%d.csv', sceneIdx));
        pdwData = readmatrix(pdwFile);
        pdwData = fillmissing(pdwData, 'movmedian', 10);
        
        % 脉内特征提取
        plFile = fullfile(dataDir, sprintf('Train_PL%d.mat', sceneIdx));
        plData = load(plFile);
        plFeatures = extract_invariant_features(plData.IntrapulseSignal1, fs);
        
        % 特征融合
        combined = [pdwData, plFeatures];
        features{sceneIdx} = combined;
        
        % 生成场景掩码
        masks{sceneIdx} = create_scene_mask(size(combined,1), sceneRadars{sceneIdx}, sceneCounts{sceneIdx});
    end
    
    features = vertcat(features{:});
    masks = vertcat(masks{:});
end

function features = extract_invariant_features(plCell, fs)
    features = zeros(numel(plCell), 15);
    
    parfor i = 1:numel(plCell)
        signal = plCell{i};
        if numel(signal) < 10
            features(i,:) = nan;
            continue;
        end
        
        % 相位特征
        phase = angle(hilbert(signal));
        phaseFeatures = [mean(cos(phase)), std(diff(unwrap(phase))), sum(abs(diff(phase)) > pi/4)/numel(signal)];
        
        % 形状特征
        env = abs(hilbert(signal))/max(abs(hilbert(signal)));
        shapeFeatures = [trapz(env.^2), find(env > 0.5,1)/numel(env), sum(diff(env) > 0)/numel(env)];
        
        % 时频特征
        [wt, ~] = cwt(signal, 'amor', fs);
        wtEnergy = sum(abs(wt).^2, 2);
        wtFeatures = [entropy(wtEnergy), sum(wtEnergy > 0.5*max(wtEnergy))];
        
        features(i,:) = [phaseFeatures, shapeFeatures, wtFeatures];
    end
    
    features = fillmissing(features, 'movmedian', 10);
end

function mask = create_scene_mask(nSamples, radars, counts)
    mask = zeros(nSamples, nRadarTypes);
    ptr = 1;
    for k = 1:length(radars)
        mask(ptr:ptr+counts(k)-1, radars(k)) = 1;
        ptr = ptr + counts(k);
    end
end

function [model, normParams] = train_advanced_model(features, masks, sceneRadars, sceneCounts)
    % 特征标准化
    [stableData, spatialData] = feature_normalizer(features);
    
    % 稳定特征聚类
    [typeCenters, ~] = kmeans(stableData, nRadarTypes, 'Replicates',5, 'Options',statset('UseParallel',1));
    
    % 空间特征建模
    spatialModel = train_spatial_model(spatialData, masks);
    
    % 全局优化
    model = global_optimizer(typeCenters, spatialModel, sceneRadars, sceneCounts);
    normParams = struct('stableMu',mean(stableData), 'stableSigma',std(stableData));
end

function [stableData, spatialData] = feature_normalizer(features)
    stableData = (features(:, stableFeatures) - mean(features(:, stableFeatures))) ./ std(features(:, stableFeatures));
    spatialData = features(:, spatialFeatures);
    spatialData(:,1) = (spatialData(:,1) - median(spatialData(:,1))) / mad(spatialData(:,1));
    spatialData(:,2) = (spatialData(:,2) - trimmean(spatialData(:,2),10)) / iqr(spatialData(:,2));
end

function spatialModel = train_spatial_model(spatialData, masks)
    spatialModel = cell(nRadarTypes,1);
    parfor r = 1:nRadarTypes
        idx = find(masks(:,r));
        if numel(idx) < 10
            spatialModel{r} = [];
            continue;
        end
        
        maxClusters = min(5, floor(numel(idx)/20));
        bic = inf(1,maxClusters);
        for k = 1:maxClusters
            try
                gm = fitgmdist(spatialData(idx,:), k, 'RegularizationValue',1e-6);
                bic(k) = gm.BIC;
            catch
                bic(k) = inf;
            end
        end
        [~, optimalK] = min(bic);
        
        try
            gm = fitgmdist(spatialData(idx,:), optimalK, 'Replicates',3);
            spatialModel{r} = gm;
        catch
            spatialModel{r} = [];
        end
    end
end

function model = global_optimizer(typeCenters, spatialModel, sceneRadars, sceneCounts)
    Aeq = zeros(30, nRadarTypes);
    for s = 1:30
        Aeq(s, sceneRadars{s}) = 1;
    end
    beq = cellfun(@sum, sceneCounts))';
    
    f = zeros(nRadarTypes,1);
    for r = 1:nRadarTypes
        if ~isempty(spatialModel{r})
            f(r) = spatialModel{r}.NumComponents;
        else
            f(r) = 1;
        end
    end
    
    options = optimoptions('intlinprog', 'Display','final', 'Heuristics','advanced');
    model.counts = intlinprog(f, 1:nRadarTypes, [],[],Aeq,beq, zeros(nRadarTypes,1), []);
    model.typeCenters = typeCenters;
    model.spatialModel = spatialModel;
end

function testFeatures = process_test_scene(testIdx, dataDir, normParams)
    pdwFile = fullfile(dataDir, sprintf('Test_PDW%d.csv', testIdx));
    pdwData = readmatrix(pdwFile);
    pdwData = fillmissing(pdwData, 'movmedian', 10);
    
    plFile = fullfile(dataDir, sprintf('Test_PL%d.mat', testIdx));
    plData = load(plFile);
    plFeatures = extract_invariant_features(plData.IntrapulseSignal1, fs);
    
    combined = [pdwData, plFeatures];
    stableTest = (combined(:, stableFeatures) - normParams.stableMu) ./ normParams.stableSigma;
    testFeatures = [stableTest, combined(:, spatialFeatures)];
end

function predLabels = radar_predictor(testFeatures, model, sceneRadars)
    stableTest = testFeatures(:,1:length(stableFeatures));
    spatialTest = testFeatures(:,length(stableFeatures)+1:end);
    
    typeDist = pdist2(stableTest, model.typeCenters);
    spatialDist = zeros(size(testFeatures,1), nRadarTypes);
    
    for r = 1:nRadarTypes
        if ~isempty(model.spatialModel{r})
            spatialDist(:,r) = mahal(model.spatialModel{r}, spatialTest);
        else
            spatialDist(:,r) = inf;
        end
    end
    
    angleVar = var(spatialTest(:,1));
    weight = 1 / (1 + exp(-10*(angleVar-0.3)));
    combinedScore = (1-weight)*typeDist + weight*spatialDist;
    
    [~, predLabels] = min(combinedScore, [], 2);
    possibleTypes = unique([sceneRadars{:}]));
    predLabels = predLabels(ismember(predLabels, possibleTypes));
end

function results = results_postprocessor(predLabels, sceneRadars)
    [counts, types] = histcounts(predLabels, 1:nRadarTypes+1);
    validIdx = counts > 0;
    results = [types(validIdx)', counts(validIdx)'];
end

function generate_analysis_report(results)
    figure('Position',[100 100 1200 800])
    for i = 1:10
        subplot(3,4,i)
        bar(results{i}(:,2))
        set(gca, 'XTickLabel', results{i}(:,1))
        title(sprintf('测试场景%d',i))
        xlabel('雷达型号'), ylabel('数量')
    end
    exportgraphics(gcf, 'Radar_Report.pdf')
end

初步想法

• 角度-时间用DBSCAN得到轨迹分类个体，然后在确定的个体上提取特征得到分类，再之后进行聚类，对于Test集体用聚类中心进行分类，或直接上神经网络

• 先分种类再分个体，需要特征工程做好