如何在MATLAB中设置迭代优化：自行计算代价并获取新变量

你的需求本质是要交互式/分步式的优化控制——让优化过程的变量生成、代价计算解耦，而非把代价逻辑封装成句柄传给工具箱函数。下面提供两种可行的实现方案：

方案一：基于MATLAB优化工具箱的迭代拦截与控制 #

针对工具箱中的优化函数（如fmincon、ga），可以通过自定义输出函数（OutputFcn）拦截每一步变量，手动完成黑盒计算与代价反馈，变相实现分步控制：

1. 初始化优化配置
   先定义变量边界、约束，设置优化选项，指定输出函数拦截迭代：

   % 变量边界
   lb = [0; 0]; % 下界
   ub = [10; 10]; % 上界
   % 优化选项：关闭默认显示，指定自定义输出函数
   opts = optimoptions('fmincon', 'Display', 'off', 'OutputFcn', @customOutputFcn);
   % 全局变量传递当前变量与代价
   global currentX currentCost;
   currentCost = Inf;
   

2. 自定义输出函数（拦截变量+暂停优化）
   该函数在每次迭代时触发，返回true让优化暂停，供外部处理黑盒计算：

   function stop = customOutputFcn(x, optimValues, state)
       stop = false;
       if state == 'iter'
           global currentX;
           currentX = x; % 保存当前变量
           stop = true; % 暂停优化，等待外部反馈代价
       end
   end
   

3. 分步执行优化流程
   启动循环，每次获取变量、计算代价、更新后继续优化：

   % 初始变量
   x0 = [5; 5];
   % 优化循环
   while true
       % 启动/继续优化，首次迭代后暂停
       [x, fval, exitflag] = fmincon(@dummyCostFcn, x0, [], [], [], [], lb, ub, [], opts);
       
       % 检查优化是否自然终止
       if exitflag ~= 0
           break;
       end
       
       % 步骤3：获取当前变量
       global currentX;
       currentVars = currentX;
       
       % 步骤4：应用到物理黑盒，获取输出
       blackBoxOutput = yourBlackBoxFunction(currentVars);
       
       % 步骤5：计算代价函数值
       currentCost = yourCostCalculation(blackBoxOutput);
       
       % 步骤6：检查代价是否达标，达标则退出
       if currentCost < 1e-6 % 自定义代价阈值
           break;
       end
       
       % 更新初始变量，准备下一次迭代
       x0 = currentVars;
   end
   

4. 虚拟代价函数（满足工具箱接口要求）
   工具箱必须传入代价函数句柄，这里写一个仅返回全局存储代价的虚拟函数：

   function cost = dummyCostFcn(x)
       global currentCost;
       cost = currentCost;
   end
   

方案二：自定义优化对象类（完全自主控制） #

如果觉得工具箱限制过多，可以自己封装优化类，内置优化算法逻辑，完全贴合你的流程：

1. 定义优化类

   classdef CustomOptimizer
       properties
           methodType % 优化方法：'gd'（梯度下降）、'ga'（遗传算法）等
           direction % 优化方向：'min'（最小化）、'max'（最大化）
           varsLB % 变量下界
           varsUB % 变量上界
           currentVars % 当前变量组
           currentCost % 当前代价
           stopFlag % 终止标志
           tol % 代价阈值
       end
       
       methods
           % 构造函数：初始化优化对象
           function obj = CustomOptimizer(method, direction, tol)
               obj.methodType = method;
               obj.direction = direction;
               obj.tol = tol;
               obj.stopFlag = false;
           end
           
           % 声明变量边界与约束
           function obj = declareVariables(obj, lb, ub)
               obj.varsLB = lb;
               obj.varsUB = ub;
               % 初始化第一组变量（边界内随机生成）
               obj.currentVars = lb + rand(size(lb)).*(ub - lb);
           end
           
           % 获取当前变量组
           function vars = getVariables(obj)
               vars = obj.currentVars;
           end
           
           % 反馈代价并更新变量（核心优化逻辑）
           function obj = feedCost(obj, cost)
               obj.currentCost = cost;
               % 以梯度下降为例，用有限差分估计梯度
               if strcmp(obj.methodType, 'gd')
                   grad = obj.estimateGradient(cost);
                   stepSize = 0.01;
                   % 根据优化方向调整梯度符号
                   if strcmp(obj.direction, 'max')
                       grad = -grad;
                   end
                   % 更新变量并约束在边界内
                   obj.currentVars = obj.currentVars - stepSize.*grad;
                   obj.currentVars = max(obj.currentVars, obj.varsLB);
                   obj.currentVars = min(obj.currentVars, obj.varsUB);
               end
               % 检查是否达到终止条件
               if abs(cost) < obj.tol
                   obj.stopFlag = true;
               end
           end
           
           % 检查是否终止
           function flag = isStopped(obj)
               flag = obj.stopFlag;
           end
       end
       
       methods (Access = private)
           % 有限差分估计梯度
           function grad = estimateGradient(obj, currentCost)
               epsVal = 1e-6;
               grad = zeros(size(obj.currentVars));
               for i = 1:length(obj.currentVars)
                   xTemp = obj.currentVars;
                   xTemp(i) = xTemp(i) + epsVal;
                   % 调用黑盒计算扰动后的代价
                   tempOutput = yourBlackBoxFunction(xTemp);
                   tempCost = yourCostCalculation(tempOutput);
                   grad(i) = (tempCost - currentCost)/epsVal;
               end
           end
       end
   end
   

2. 使用自定义优化对象
   完全按照你的流程执行：

   % 步骤1：初始化优化对象（梯度下降，最小化，代价阈值1e-6）
   optimizer = CustomOptimizer('gd', 'min', 1e-6);
   
   % 步骤2：声明变量边界
   lb = [0; 0];
   ub = [10; 10];
   optimizer = optimizer.declareVariables(lb, ub);
   
   % 步骤3-6：循环迭代
   while ~optimizer.isStopped()
       % 步骤3：获取变量
       vars = optimizer.getVariables();
       
       % 步骤4：应用到物理黑盒
       output = yourBlackBoxFunction(vars);
       
       % 步骤5：计算代价
       cost = yourCostCalculation(output);
       
       % 步骤6：反馈代价，更新优化状态
       optimizer = optimizer.feedCost(cost);
   end
   
   % 步骤7：结束，获取最优变量
   optimalVars = optimizer.getVariables();
   

关键说明 #

• 方案一利用MATLAB工具箱成熟算法能力，适合需要约束优化等复杂场景，虚拟代价函数仅为满足接口要求，实际代价由外部计算反馈。
• 方案二完全自主实现优化逻辑，灵活性最高，可按需扩展遗传算法、粒子群等更多优化方法。

内容的提问来源于stack exchange，提问作者Farhad