Objective-Extraction-via-Fuzzy-Clustering-in-Evolutionary-Many-Objective-Optimization/nsga2.m at master · wangyirui/Objective-Extraction-via-Fuzzy-Clustering-in-Evolutionary-Many-Objective-Optimization · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
global MaxIt nPop pCrossover Eta_c pMutation Eta_m popc popm;
global Cluster mop pop U  U_old  VarSize F1 weightStatus;

%% NSGA-II Parameters
MaxIt =300;                                      % Maximum Number of Iterations
nPop = 300;                                      % Population Size
pCrossover=0.9;                                  % Crossover Percentage
Eta_c = 5.0;                                     % Crossover Index
pMutation =1.0 / mop.pdim;                       % Mutation Percentage
Eta_m = 50.0;                                    % Mutation Index
VarSize = [1 mop.pdim];                          % Size of Decision Variables Matrix(Columns)

%% Initialization Part I: Create structure and pop

empty_individual.Position=[];
empty_individual.Cost=[];
empty_individual.RawCost=[];
empty_individual.Rank=[];
empty_individual.Constrains=[];
empty_individual.DominationSet=[];
empty_individual.DominatedCount=[];
empty_individual.CrowdingDistance=[];

pop=repmat(empty_individual,nPop,1);
weightStatus = 'Initialize';

%% Initialization Part II: Prepare to Compute Membership Matrix
for LoopCnt=1:nPop
    pop(LoopCnt).Position=unifrnd(mop.varMin, mop.varMax, VarSize);
    [pop(LoopCnt).RawCost, pop(LoopCnt).Cost, pop(LoopCnt).Constrains] ...
        = costFunction(mop, pop(LoopCnt).Position);
end

% Non-Dominated Sorting
[pop, F]=NonDominatedSorting(pop);

% Calculate Crowding Distance
pop=CrowdingDistance(pop,F);

% Sort Population
[pop, F]=SortPopulation(pop);

% Deploy Fuzzy C-Means to obtain U
U = Weight(pop)
U_old = zeros(size(U,1), size(U, 2));
weightStatus = 'Ready';
U1=U;
%% Initialization Part III: Run NSGA-II again to update pop.Cost

for LoopCnt=1:nPop
    pop(LoopCnt).Position=unifrnd(mop.varMin, mop.varMax, VarSize);
    [pop(LoopCnt).RawCost, pop(LoopCnt).Cost, pop(LoopCnt).Constrains] ...
        = costFunction(mop, pop(LoopCnt).Position);
end

% Non-Dominated Sorting
[pop, F]=NonDominatedSorting(pop);

% Calculate Crowding Distance
pop=CrowdingDistance(pop,F);

% Sort Population
[pop, F]=SortPopulation(pop);

%% NSGA-II Main Loop

updateIt = 1;
finishWeightMatrix = 1;

for it=1:MaxIt
    % Tournament and Crossover
    popc=repmat(empty_individual,  (size(pop, 1) - mod(size(pop,1), 4)) / 2, 1);
    Mating();

    % Mutation
    popm=repmat(empty_individual,  size(popc, 1), 1);
    Mutate();

    % Non-Dominated Sorting
    [pop, F]=NonDominatedSorting(pop);

    % Calculate Crowding Distance
    pop=CrowdingDistance(pop,F);

    % Sort Population
    pop=SortPopulation(pop);

    % Truncate
    pop=pop(1:nPop);

    % Non-Dominated Sorting
    [pop, F]=NonDominatedSorting(pop);

    % Calculate Crowding Distance
    pop=CrowdingDistance(pop,F);

    % Sort Population
    [pop, F]=SortPopulation(pop);

    % Store F1
    F1=pop(F{1});

    global df;
    df = zeros(mop.odim, size(F1, 1));
    for i1 = 1 : size(F1, 1)
        df(:, i1) = F1(i1).RawCost;
    end

    % Plot F1 Costs
    figure(1);
    PlotCosts(F1);
    pause(0.01);

    % Show Iteration Information
    disp(['Iteration ' num2str(it) ': Number of F1 Members = ' num2str(numel(F1))]);

    if (sum(sum(abs(U - U_old))))  / (size(U,1) *  size(U, 2)) > (2.0e-4 * Cluster)
        updateIt = updateIt + 1;
        U_old = U;
        U = Weight(pop)
        disp(['Weight Update: '  num2str(updateIt)]);
        disp(['Agverage Fluctuation: ' num2str((sum(sum(abs(U - U_old))))  / (size(U,1) *  size(U, 2)))]);

        for LoopCnt=1:nPop
            %             pop(LoopCnt).Position=unifrnd(mop.varMin, mop.varMax, VarSize);
            [pop(LoopCnt).RawCost, pop(LoopCnt).Cost, pop(LoopCnt).Constrains] ...
                = costFunction(mop, pop(LoopCnt).Position);
        end

        % Non-Dominated Sorting
        [pop, F]=NonDominatedSorting(pop);

        % Calculate Crowding Distance
        pop=CrowdingDistance(pop,F);

        % Sort Population
        [pop, F]=SortPopulation(pop);

        F1=pop(F{1});

    end

end