MATLAB: How to store the value at each iteration of a genetic algorithm

genetic algorithmGlobal Optimization Toolboxstore values

I have a simple function and two constraints for my genetic algorithm code

ObjFcn = @myFitness;
nvars = 2;   %number of variables
LB = [0 0];  %lower bound
UB = [1 13]; %upper bound
ConsFcn = @myConstraints;
[x,fval] = ga(ObjFcn,nvars,[],[],[],[],LB,UB,ConsFcn,opts);
function y = myFitness(x)
y = 100*(x(1)^2-x(2))^2 + (1-x(1))^2;
end
function [c,c_eq] = myConstraints(x)
c = [x(1)*x(2) + x(1) - x(2) + 1.5; 10 - x(1)*x(2)];
c_eq = [];
end

I would like to store the values of x at each function evaluation, as well as keep track of the generation. I've found a similar question here but I don't really understand what the solution meant as it wasn't very clear. I believe I need to tell my fitness function to store values of the GA function so when the GA function reads the fitness function the input parameters at that iteration are saved… but I would like help on how the syntax would work for such a thing. Any help is appreciated!

I've also looked at the GA options and was unable to find help with my specific issue.

Best Answer

Hi,

you coultd try this way:

[x,fval,vals] = solve_problem 
function [x,fval,vals] = solve_problem 
ObjFcn = @myFitness;
nvars = 2;   %number of variables
LB = [0 0];  %lower bound
UB = [1 13]; %upper bound
ConsFcn = @myConstraints;
iter = 1;
vals = [];
[x,fval] = ga(ObjFcn,nvars,[],[],[],[],LB,UB,ConsFcn);
function y = myFitness(x)
y = 100*(x(1)^2-x(2))^2 + (1-x(1))^2;
vals(iter,1:2) = x;
iter = iter+1;
end
function [c,c_eq] = myConstraints(x)
c = [x(1)*x(2) + x(1) - x(2) + 1.5; 10 - x(1)*x(2)];
c_eq = [];
end
end

After running this you can plot how x(1) and x(2) change over the iterations:

yyaxis left
plot(vals(:,1))
yyaxis right
plot(vals(:,2))

Best regards

Stephan

Related Solutions

MATLAB: Problems with fmincon, how to solve

Your problem is convex, so you can use the CVX package if you want. Also, the solution should be the global minimum; not a local minimum. To use fmincon, do the following:

Equality/nonEquality constraint:

function [c,ceq]=mycon(x)
c(1) = x(1)^2 + x(2)^2 - 4*x(1) - 3*x(2) + 5;
c(2) = -x(1)^2 - x(2)^2 + 4*x(1) + 3*x(2) - 6; % notice the fixed typo
ceq = 2*x(1)^2 + 2*x(2)^2 - 3*x(1) - 3*x(2) - 2; 
end

Construct the problem and call fmincon:

clc
clear all
Aeq=[]; 
beq=[]; 
A=[]; 
b=[]; 
% if you are not sure that vector x is within lb and ub do not restrict it
lb = []; %lb=[-3,-3]; 
ub = []; %ub=[3,3]; % 
x0=[4,4];
myObj = @(x) x(1)^2 + x(2)^2 - 5*x(1) - 6*x(2) + 15;
nonlcon = @mycon;
options = optimoptions('fmincon','Algorithm','sqp','Display','iter-detailed','MaxFunctionEvaluations',100000, 'MaxIterations',2000, 'OptimalityTolerance' ,1e-10);
[x,cost] = fmincon(myObj,x0,A,b,Aeq,beq,lb,ub,nonlcon)

Output (global minimum):


Local minimum found that satisfies the constraints.
Optimization completed because the objective function is non-decreasing in 
feasible directions, to within the value of the optimality tolerance,
and constraints are satisfied to within the value of the constraint tolerance.
<stopping criteria details>
x =
    1.6450    1.9007
cost =
    1.6896

MATLAB: Saving All Results Of Objective Function in Genetic Algorithm

I'm not sure it's possible to do exactly what you've indicated, but I think you should be able to get something along those lines as follows. There might be a better way to do this, but one way that I think should work is to use persistent variables to store x and fval across calls of objfunc done by each individual parallel worker, and then retrieve them all at the end using an spmd command.

So your objfunc.m function should look something like:

function [fv,x2,fv2] = objfunc(x)
persistent xstore fvstore
fval = ExternalProgramFunction(x); % call your external program

% add the current x and fval to the persistent variables

xstore = [xstore; x]; % assuming x is a row vector

fvstore = [fvstore; fval];
% When optimizing, you won't need to recover the stored values. To

% save on unnecessary copying, only create copies of these variables

% for output if actually necessary.

if nargout > 1
    x2 = xstore;
    if nargout > 2
        fv2 = fvstore;
    end
end
end

Note that xstore and fvstore here are variables that will be shared by successive calls to objfunc by a particular worker, but not across different workers. So if you have 8 workers, then at the end of your optimization you'll have 8 different versions of xstore and fvstore. You can then retrieve them using spmd via

spmd
    [~,x2,fv2] = objfunc(x);
end
clear objfunc

Here, x2 and fv2 will be composite variables with dimension equal to the number of parallel workers you have, and where x2{j} and fv2{j} returning the values of xstore and fvstore on worker j. Thus, the i-th rows of xj=x2{j} and fvj=fv2{j} will give the values of x and fval for the ith call of objfunc made by the j-th worker.

Note that the last line above ("clear objfunc") clears the persistent variables from memory. If you don't do that, then next time objfunc is called you'll continue to add rows to the stored variables, which you may not want. In general, it's a good idea to run this clear statement right after you've retrieved your data in order to avoid unexpected results later on.

Note also that it's not possible to group the calls made by the different workers by the corresponding genetic algorithm "generation". If that's what you're after, I'm not sure how to do that.

One final note. The above code, as well as the method you linked to for serial execution, involve expanding the size of the stored arrays at every iteration, which is a costly step to execute and should be avoided if possible. If you have some idea of what the maximum number of function calls will be, you can potentially speed things up by pre-allocating the xstore and fvstore arrays as follows:

function [fv,x2,fv2] = objfunc(x)
persistent xstore fvstore iter
if isempty(iter) % if this is the first call, initialize variables
    maxcalls = 1000; % maximum number of calls you expect a worker to make
    nx = 10;    % number of elements of x
    xstore = zeros(maxcalls,nx);
    fvstore = zeros(maxcalls,1);
    iter = 1;
else
    iter = iter+1
end
fval = ExternalProgramFunction(x); % call your external program
% add the current x and fval to the persistent variables
xstore(iter,:) = x; % assuming x is a row vector
fvstore(iter) = fval;
% When optimizing, you won't need to recover the stored values. To
% save on unnecessary copying, only create copies of these variables
% for output if actually necessary.
if nargout > 1
    x2 = xstore;
    if nargout > 2
        fv2 = fvstore;
    end
end
end

Best Answer

Related Solutions

MATLAB: Problems with fmincon, how to solve

MATLAB: Saving All Results Of Objective Function in Genetic Algorithm

Related Question