% 主动光源控制算法classdef LightingController < handle    properties        Camera        TargetIllumination = 2000  % 目标照度        Tolerance = 100           % 容差    end    methods        function adjust_lighting(obj)            % 1. 检测当前照度            current_illum = obj.measure_illumination();            % 2. 计算调整量            if abs(current_illum - obj.TargetIllumination) > obj.Tolerance                % 自动调整光源亮度                adjustment = (obj.TargetIllumination - current_illum) / 100;                obj.set_light_intensity(adjustment);                % 记录日志                log_event('光照调整', ...                    sprintf('从%d调整到%d lux', current_illum, obj.TargetIllumination));            end            % 3. 均匀性检测            uniformity = obj.check_uniformity();            if uniformity < 0.9                warning('光照均匀性不足: %.2f', uniformity);                obj.adjust_light_position();            end        end        function illum = measure_illumination(obj)            % 从图像估计照度            img = obj.Camera.capture();            gray_img = rgb2gray(img);            illum = mean(gray_img(:)) * 10;  % 简单映射        end    endend

% 光照不变性特征提取function features = illumination_invariant_features(image)    % 1. 归一化消除亮度影响    img_normalized = double(image) / 255;    % 2. 使用梯度特征而非绝对亮度    [gx, gy] = gradient(img_normalized);    gradient_magnitude = sqrt(gx.^2 + gy.^2);    % 3. 局部对比度增强    img_local_contrast = localcontrast(image);    % 4. 颜色不变性变换    img_hsv = rgb2hsv(image);    % 色调(H)和饱和度(S)对光照变化相对稳定    hue_channel = img_hsv(:, :, 1);    saturation_channel = img_hsv(:, :, 2);    % 5. 多特征融合    features = [        extract_lbp_features(gradient_magnitude),  % 纹理特征        extract_color_features(hue_channel, saturation_channel),  % 颜色特征        extract_edge_features(gx, gy)  % 边缘特征    ];end

% 生成各种光照条件下的训练数据function augmented_data = augment_illumination(original_images)    augmented_data = [];    for i = 1:length(original_images)        img = original_images{i};        % 模拟不同光照条件        conditions = {            @(x) x * 0.3,   % 昏暗            @(x) x * 0.6,   % 较暗            @(x) x * 1.0,   % 正常            @(x) x * 1.5,   % 较亮            @(x) x * 2.0,   % 过亮            @(x) jitter_illumination(x),  % 不均匀光照            @(x) add_shadow(x, 0.3),       % 添加阴影            @(x) simulate_sunlight(x, 45)  % 模拟斜射阳光        };        for j = 1:length(conditions)            augmented_img = conditions{j}(img);            augmented_data{end+1} = augmented_img;        end    endend

% 实时光照自适应classdef AdaptiveClassifier < handle    properties        BaseClassifier        CurrentLightingCondition        LightingModels  % 不同光照下的模型    end    methods        function label = predict_adaptive(obj, image)            % 1. 检测当前光照条件            obj.detect_lighting_condition(image);            % 2. 选择或调整模型            if obj.CurrentLightingCondition == "normal"                model = obj.BaseClassifier;            else                model = obj.LightingModels(obj.CurrentLightingCondition);            end            % 3. 可能的光照补偿            compensated_image = obj.compensate_illumination(image);            % 4. 预测            label = model.predict(compensated_image);            % 5. 记录用于后续模型更新            obj.record_prediction(image, label);        end        function update_model(obj)            % 收集在线数据，更新模型            new_data = obj.collect_recent_data();            if size(new_data, 1) > 1000                obj.retrain_model(new_data);            end        end    endend

方法            准确率      成本     实施难度什么都不做        70%        0         易数据增强          85%        低        中算法鲁棒性        88%        中        中在线自适应        92%        高        难光照控制硬件      95%+       高        易

classdef ProductMonitor < handle    properties        HistoricalFeatures        ControlLimits        WarningCount = 0    end    methods        function check_variation(obj, current_features)            % 1. 与历史数据比较            historical_mean = mean(obj.HistoricalFeatures, 1);            historical_std = std(obj.HistoricalFeatures, 0, 1);            % 2. 计算Z分数            z_scores = abs(current_features - historical_mean) ./ historical_std;            % 3. 检测显著变化            significant_changes = find(z_scores > 3);  % 3σ            if ~isempty(significant_changes)                obj.WarningCount = obj.WarningCount + 1;                % 4. 分析变化类型                change_type = obj.analyze_change_type(significant_changes, z_scores);                % 5. 预警                obj.send_alert(sprintf('产品变异检测: %s', change_type));                % 6. 自动调整                if obj.WarningCount > 5                    obj.trigger_model_adaptation();                end            end            % 7. 更新历史数据            obj.HistoricalFeatures(end+1, :) = current_features;            if size(obj.HistoricalFeatures, 1) > 10000                obj.HistoricalFeatures = obj.HistoricalFeatures(end-9999:end, :);            end        end        function change_type = analyze_change_type(obj, changed_indices, z_scores)            % 根据哪些特征变化，判断变异类型            % 特征索引映射            feature_map = {                1:3,   '颜色特征',  '原材料/涂层变化';                4:6,   '纹理特征',  '工艺参数变化';                7:9,   '尺寸特征',  '模具磨损';                10:12, '形状特征',  '供应商变更';            };            for i = 1:size(feature_map, 1)                feature_range = feature_map{i, 1};                if any(ismember(changed_indices, feature_range))                    change_type = sprintf('%s(%s)', feature_map{i, 2}, feature_map{i, 3});                    return;                end            end            change_type = '未知变化';        end    endend

function adapt_to_variation(base_model, new_data, variation_type)    % 根据变异类型采取不同适应策略    switch variation_type        case 'gradual'  % 渐变，如模具磨损            % 滑动窗口增量学习            window_size = 1000;            if size(new_data, 1) >= window_size                % 用最近的数据重新训练                recent_data = new_data(end-window_size+1:end, :);                model = incremental_train(base_model, recent_data);            end        case 'abrupt'  % 突变，如供应商更换            % 建立新类别或新模型            new_cluster = cluster_analysis(new_data);            if is_significantly_different(new_cluster, base_model)                % 创建新模型分支                create_model_branch(base_model, new_cluster);            end        case 'periodic'  % 周期性，如早晚班差异            % 时间感知模型            time_aware_model = add_time_context(base_model);        case 'mixed'  % 混合变化            % 集成学习，多个专家模型            ensemble_model = create_ensemble(base_model, new_data);    endend

classdef HumanInTheLoop < handle    properties        ConfidenceThreshold = 0.95        UncertaintySamples = []        HumanFeedback = []    end    methods        function [label, confidence] = predict_with_fallback(obj, image)            % 模型预测            [label, confidence] = obj.model.predict(image);            if confidence < obj.ConfidenceThreshold                % 低置信度，请求人工确认                obj.request_human_review(image, label);                % 加入不确定样本集                obj.UncertaintySamples{end+1} = struct(...                    'image', image, ...                    'predicted_label', label, ...                    'confidence', confidence, ...                    'timestamp', datetime);            end            % 定期用人工反馈重新训练            if mod(length(obj.UncertaintySamples), 100) == 0                obj.update_with_human_feedback();            end        end        function request_human_review(obj, image, predicted_label)            % 在实际系统中，这里会：            % 1. 在HMI上弹出对话框            % 2. 发送到质检员Pad            % 3. 或者发送到远程标注平台            % 简化的演示            fprintf('需要人工确认: 预测为 %s，置信度 %.2f\n', ...                predicted_label, confidence);            % 模拟人工输入            actual_label = input('请输入正确标签: ', 's');            % 记录反馈            obj.HumanFeedback{end+1} = struct(...                'image', image, ...                'predicted', predicted_label, ...                'actual', actual_label);        end    endend

变异类型       检测方法          应对策略渐变变异      统计过程控制(SPC)  增量学习突变变异      聚类分析          模型分支/新模型周期性变异    时间序列分析      时间感知模型未知变异      不确定性估计      人机协同

时间        镜头清晰度  光源亮度  对焦精度  准确率新设备      100%       100%     100%     99.5%3个月后     98%        95%      99%      98.7%6个月后     92%        88%      97%      96.1%1年后       85%        80%      94%      92.3%2年后       73%        70%      89%      85.4%

classdef AgingCompensationSystem < handle    properties        BaselinePerformance        CurrentPerformance        AgingFactors        CompensationParameters    end    methods        function monitor_aging(obj)            % 每日自动老化检测流程            % 1. 标定板检测            calibration_results = obj.run_calibration();            % 2. 性能基准测试            performance_metrics = obj.measure_performance();            % 3. 计算老化程度            aging_levels = obj.calculate_aging(calibration_results, performance_metrics);            % 4. 判断是否需要补偿            if any(aging_levels > obj.Thresholds)                % 自动调整参数                obj.apply_compensation(aging_levels);                % 记录维护需求                obj.schedule_maintenance(aging_levels);            end            % 5. 更新老化模型            obj.update_aging_model(aging_levels);            % 6. 预测剩余寿命            remaining_life = obj.predict_remaining_life();            if remaining_life < 30  % 少于30天                obj.send_alert(sprintf('设备寿命剩余%.0f天', remaining_life));            end        end        function apply_compensation(obj, aging_levels)            % 根据老化类型应用不同补偿            % 镜头模糊补偿            if aging_levels.lens > 0.1                obj.apply_deblurring(aging_levels.lens);            end            % 亮度衰减补偿            if aging_levels.light > 0.15                obj.adjust_exposure(aging_levels.light);                obj.boost_light_source(aging_levels.light);            end            % 对焦偏移补偿            if aging_levels.focus > 0.05                obj.adjust_focus(aging_levels.focus);            end            % 色彩漂移补偿            if aging_levels.color > 0.08                obj.apply_color_correction(aging_levels.color);            end            % 更新算法参数            obj.adjust_algorithm_parameters(aging_levels);        end    endend

项目          检查周期    阈值      维护动作镜头清洁      1周        清晰度<95% 酒精擦拭光源检查      2周        亮度<90%   清洁或更换对焦校准      1个月      偏移>0.1mm 自动重校准色彩校正      1个月      色差>5ΔE   重新标定全面标定      3个月      任意>10%   完整标定深度清洁      6个月      -          专业清洁

classdef AntiCheatingSystem < handle    properties        SuspicionScore = 0        RecentDetections = []    end    methods        function [result, is_suspicious] = detect_with_anti_cheat(obj, image)            % 主检测流程            primary_result = obj.primary_detector(image);            % 并行执行多个防作弊检查            cheat_checks = {                @() obj.check_uniform_background(image),      % 背景一致性                @() obj.check_expected_features(image),      % 预期特征                @() obj.check_tampering_signs(image),         % 篡改痕迹                @() obj.check_physical_possibility(primary_result), % 物理可能性                @() obj.check_statistical_anomaly(primary_result)  % 统计异常            };            cheat_flags = zeros(1, length(cheat_checks));            for i = 1:length(cheat_checks)                cheat_flags(i) = cheat_checks{i}();            end            % 计算可疑度            suspicion = sum(cheat_flags);            obj.SuspicionScore = obj.SuspicionScore * 0.9 + suspicion * 0.1;            % 记录            obj.RecentDetections{end+1} = struct(...                'result', primary_result, ...                'suspicion', suspicion, ...                'time', datetime);            % 判断是否可疑            is_suspicious = obj.SuspicionScore > obj.Threshold;            if is_suspicious                result = 'SUSPICIOUS';                obj.handle_suspicious_case(image, primary_result, cheat_flags);            else                result = primary_result;            end        end        function uniform = check_uniform_background(obj, image)            % 检测背景是否异常均匀（可能被贴纸覆盖）            background_mask = obj.extract_background(image);            background_region = image(background_mask);            % 计算背景区域的标准差            std_value = std(double(background_region(:)));            % 如果过于均匀，可疑            uniform = std_value < 5;  % 阈值可调        end        function possible = check_physical_possibility(obj, detection_result)            % 检查检测结果是否符合物理规律            % 例如：划痕通常有一定方向性            % 斑点通常有圆形特征            % 缺陷不会瞬间出现又消失            % 获取历史检测结果            recent_results = obj.get_recent_results(10);  % 最近10个            % 时空一致性检查            time_consistency = obj.check_time_consistency(recent_results);            space_consistency = obj.check_space_consistency(detection_result);            possible = time_consistency && space_consistency;        end        function handle_suspicious_case(obj, image, result, cheat_flags)            % 处理可疑情况            % 1. 保存证据            evidence_id = obj.save_evidence(image, result, cheat_flags);            % 2. 触发警报            obj.trigger_alert(evidence_id, cheat_flags);            % 3. 可能的应对措施            if sum(cheat_flags) >= 3  % 高度可疑                % 停止生产线                obj.stop_production_line();                % 通知主管                obj.notify_supervisor('HIGH_SUSPICION');                % 需要人工干预                obj.request_human_intervention();            else                % 记录但不停止                obj.log_suspicion(evidence_id);                % 可能需要增加抽样检查                obj.increase_sampling_rate();            end        end    endend

classdef ModelDegradationMonitor < handle    properties        PerformanceHistory        ConfidenceTrend        DataDistributionHistory    end    methods        function check_degradation(obj, recent_results)            % 检查模型是否退化            metrics = obj.calculate_metrics(recent_results);            % 1. 准确率下降            accuracy_drop = obj.check_accuracy_drop(metrics.accuracy);            % 2. 置信度下降            confidence_drop = obj.check_confidence_drop(metrics.confidence);            % 3. 不确定性增加            uncertainty_increase = obj.check_uncertainty(metrics.uncertainty);            % 4. 数据分布变化            distribution_shift = obj.check_distribution_shift();            % 综合判断            degradation_score = accuracy_drop * 0.4 + ...                               confidence_drop * 0.3 + ...                               uncertainty_increase * 0.2 + ...                               distribution_shift * 0.1;            if degradation_score > 0.7                degradation_type = obj.diagnose_degradation_type(...                    accuracy_drop, confidence_drop, uncertainty_increase, distribution_shift);                obj.trigger_retraining(degradation_type);            end        end        function degradation_type = diagnose_degradation_type(obj, ...                acc_drop, conf_drop, unc_inc, dist_shift)            % 诊断退化类型            if dist_shift > 0.8                if unc_inc > 0.6                    degradation_type = 'CONCEPT_DRIFT';  % 概念漂移                else                    degradation_type = 'DATA_DRIFT';     % 数据分布变化                end            elseif acc_drop > 0.7 && conf_drop > 0.7                degradation_type = 'MODEL_STALENESS';    % 模型过时            elseif unc_inc > 0.8                degradation_type = 'AMBIENT_CHANGE';     % 环境变化            else                degradation_type = 'GRADUAL_DEGRADATION'; % 渐进退化            end        end        function trigger_retraining(obj, degradation_type)            % 触发重新训练            fprintf('检测到模型退化: %s\n', degradation_type);            switch degradation_type                case 'CONCEPT_DRIFT'                    % 概念漂移：需要重新标注数据                    obj.collect_new_data(1000);  % 收集新数据                    obj.request_relabeling();     % 请求重新标注                    obj.retrain_full_model();      % 完整重训练                case 'DATA_DRIFT'                    % 数据分布变化：增量学习                    new_data = obj.collect_recent_data(500);                    obj.incremental_learning(new_data);                case 'MODEL_STALENESS'                    % 模型过时：更新模型                    obj.transfer_learning();                case 'AMBIENT_CHANGE'                    % 环境变化：调整参数                    obj.adjust_parameters();                case 'GRADUAL_DEGRADATION'                    % 渐进退化：正常更新                    obj.scheduled_retraining();            end            % 记录维护日志            obj.log_maintenance(sprintf('模型重训练: %s', degradation_type));        end    endend

function cost_sensitive_model = train_with_cost_sensitive(X, y)    % 不同类别的误分类代价    % 漏检致命缺陷的代价 >> 误判合格品的代价    cost_matrix = [        0   1   10  100;  % 预测为合格        5   0   20  50;   % 预测为轻微缺陷        20  5   0   30;   % 预测为严重缺陷        50  20  5   0     % 预测为致命缺陷    ];    % 行: 真实类别, 列: 预测类别    % 代价敏感训练    cost_sensitive_model = fitcsvm(...        X, y, ...        'Cost', cost_matrix, ...        'ClassNames', {'OK', 'Minor', 'Major', 'Critical'});end

function balanced_data = balance_dataset(original_data, original_labels)    % 获取各类别数量    [class_counts, class_names] = histcounts(categorical(original_labels));    % 确定目标数量（中位数或最大值）    target_count = max(class_counts);    balanced_data = {};    balanced_labels = {};    for i = 1:length(class_names)        class_name = class_names{i};        class_indices = find(strcmp(original_labels, class_name));        class_data = original_data(class_indices);        current_count = length(class_indices);        if current_count < target_count            % 少数类：过采样+数据增强            augmented_data = augment_minority_class(...                class_data, target_count - current_count);            balanced_data = [balanced_data; class_data; augmented_data];            balanced_labels = [balanced_labels; ...                repmat({class_name}, current_count + length(augmented_data), 1)];        else            % 多数类：欠采样            if current_count > target_count                selected_indices = randperm(current_count, target_count);                class_data = class_data(selected_indices);            end            balanced_data = [balanced_data; class_data];            balanced_labels = [balanced_labels; repmat({class_name}, length(class_data), 1)];        end    endend

function ensemble_model = create_ensemble_for_imbalanced_data(training_data)    % 训练多个专门模型    models = {};    % 模型1: 专门检测致命缺陷（高召回率）    model1 = train_specialist_model(training_data, ...        'focus_class', 'Critical', ...        'recall_weight', 0.9);  % 侧重召回率    % 模型2: 高精度模型（减少误报）    model2 = train_specialist_model(training_data, ...        'focus_class', 'all', ...        'precision_weight', 0.7);  % 侧重精确率    % 模型3: 处理边界情况    model3 = train_specialist_model(training_data, ...        'focus_class', 'borderline', ...        'focus_on_uncertain', true);    % 集成策略    ensemble_model = struct(...        'models', {models}, ...        'voting_strategy', @weighted_voting, ...        'confidence_calibration', @calibrate_confidence);endfunction final_prediction = weighted_voting(predictions, confidences, labels)    % 根据类别重要性加权投票    class_weights = struct(...        'OK', 1.0, ...        'Minor', 2.0, ...        'Major', 5.0, ...        'Critical', 10.0);    weighted_votes = containers.Map;    for i = 1:length(predictions)        pred = predictions{i};        conf = confidences(i);        weight = class_weights.(pred) * conf;        if isKey(weighted_votes, pred)            weighted_votes(pred) = weighted_votes(pred) + weight;        else            weighted_votes(pred) = weight;        end    end    % 选择权重最高的    [max_weight, final_prediction] = max(cell2mat(values(weighted_votes)));end

classdef ContinualLearningSystem < handle    properties        BaseModel        ExperienceMemory        Plasticity  % 可塑性，控制学习速度        Stability   % 稳定性，防止遗忘    end    methods        function online_learning(obj, new_data, new_labels, feedback)            % 在线学习循环            % 1. 评估新数据            [predictions, confidences] = obj.BaseModel.predict(new_data);            % 2. 识别有价值样本            valuable_samples = obj.select_valuable_samples(...                new_data, new_labels, predictions, confidences, feedback);            % 3. 添加到经验记忆            obj.update_experience_memory(valuable_samples);            % 4. 平衡稳定-可塑性困境            if obj.should_update_now()                % 计算更新强度                update_strength = obj.Plasticity * obj.calculate_need_to_learn(feedback);                % 控制遗忘                forgetting_prevention = obj.Stability * obj.calculate_importance_of_old_knowledge();                % 执行更新                obj.update_model(update_strength, forgetting_prevention);            end            % 5. 知识整合            obj.integrate_knowledge();            % 6. 模型自评估            obj.self_evaluation();        end        function valuable_samples = select_valuable_samples(obj, ...                new_data, new_labels, predictions, confidences, feedback)            % 选择有学习价值的样本            valuable_mask = false(size(new_data, 1), 1);            for i = 1:size(new_data, 1)                sample_value = 0;                % 误分类样本                if ~strcmp(predictions{i}, new_labels{i})                    sample_value = sample_value + 0.4;                end                % 低置信度样本                if confidences(i) < 0.7                    sample_value = sample_value + 0.3;                end                % 人类反馈修正的样本                if ~isempty(feedback) && ~strcmp(predictions{i}, feedback{i})                    sample_value = sample_value + 0.5;                end                % 新颖性（与记忆中的样本不同）                novelty = obj.calculate_novelty(new_data(i, :));                sample_value = sample_value + novelty * 0.3;                % 添加到有价值样本                if sample_value > 0.5                    valuable_mask(i) = true;                end            end            valuable_samples = struct(...                'data', new_data(valuable_mask, :), ...                'labels', new_labels(valuable_mask), ...                'value_score', sample_value(valuable_mask));        end        function update_model(obj, update_strength, forgetting_prevention)            % 执行模型更新            % 从经验记忆中采样            batch = obj.sample_from_experience();            % 计算损失（包含防止遗忘的正则化）            loss = obj.calculate_loss(batch) + ...                   forgetting_prevention * obj.calculate_forgetting_penalty();            % 更新模型参数            obj.BaseModel = obj.update_parameters(...                obj.BaseModel, loss, update_strength);            % 更新可塑性和稳定性            obj.adapt_plasticity_stability();        end    endend