因为在多目标进化算法中,进化到大约500代之后,(5个目标),下降的曲线趋于平缓,为了让曲线能否再进一步的下降,使用局部搜索进行对一些高覆盖小区进行分簇,然后选择最差的一个簇,进行重新规划这个簇,即初始化这个簇,产生一些的个体,然后评估这些个体,选取最好的一个个体,与当前精英进行比较,如果比当前精英效果好的话,就进行替换这个精英。这样就能继续让指标下降了。
//循环每个子种群,找出每个子种群的簇
for (int i = 0; i < subPopNum; i++)
{
//评估每个簇的适应度值,选出最差的那个簇的下标
#region
//1、首先求出这些簇中最大的所有目标的干扰
double maxInterf = double.MinValue;
int maxModfn = int.MinValue;
int maxModfa3 = int.MinValue;
int maxModfa6 = int.MinValue;
double maxAdjInterf = double.MinValue;
int maxfitnessindex=0;//求得对全网干扰最大的那个簇的下标
double maxfitness = 0;//最大的干扰值
for (int j = 0; j < HighCoverClusters.Count(); j++)
{
for (int k = 0; k < HighCoverClusters[j].Count; k++)
{
//计算单个小区给全网带来的影响,然后求和
List<double> interference = new List<double>();
List<int> modthreeFN = new List<int>();
List<int> modthreeFA = new List<int>();
List<int> modsixFA = new List<int>();
List<double> adjInterf = new List<double>();
//子目标适应度
double interf = getInterference(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);
int modfn = getFNmodthreeCount(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);
int modfa = getFAmodthreeCount(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);
int modfa6 = getFAmodsix(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);
double adjinterf;// = getC2ItopCount(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);
if (gSectorNum < smalldataThr)
adjinterf = getInterferenceAdjMod3(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);
else
adjinterf = getC2ItopCount(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);
if (maxInterf < interf)
{
maxInterf = interf;
// maxInterfIndex = HighCoverClusters[j][k];
}
if (maxModfn < modfn)
{
maxModfn = modfn;
// maxModIndex = HighCoverClusters[j][k];
}
if (maxModfa3 < modfa) maxModfa3 = modfa;
if (maxModfa6 < modfa6) maxModfa6 = modfa6;
if (maxAdjInterf < adjinterf) maxAdjInterf = adjinterf;
}
}
//然后求出每个簇的干扰,去量纲的适应度值,求得最差的那个簇的下标,针对这个簇再进行初始化
for (int j = 0; j < HighCoverClusters.Count(); j++)
{
List<double> interference = new List<double>();
List<int> modthreeFN = new List<int>();
List<int> modthreeFA = new List<int>();
List<int> modsixFA = new List<int>();
List<double> adjInterf = new List<double>();
for (int k = 0; k < HighCoverClusters[j].Count; k++)
{
//计算单个小区给全网带来的影响,然后求和
//子目标适应度
double interf = getInterference(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);
int modfn = getFNmodthreeCount(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);
int modfa = getFAmodthreeCount(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);
int modfa6 = getFAmodsix(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);
double adjinterf;// = getC2ItopCount(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);
if (gSectorNum < smalldataThr)
adjinterf = getInterferenceAdjMod3(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);
else
adjinterf = getC2ItopCount(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);
interference.Add(interf);
modthreeFN.Add(modfn);
modthreeFA.Add(modfa);
modsixFA.Add(modfa6);
adjInterf.Add(adjinterf);
}
double tempfitness=0;
for (int k = 0; k < HighCoverClusters[j].Count; k++)
{
tempfitness += weightMatrix[i, 0] * interference[k] / maxInterf + weightMatrix[i, 1] * modthreeFN[k] / maxModfn + weightMatrix[i, 2] * modthreeFA[k] / maxModfa3 + weightMatrix[i, 3] * modsixFA[k] / maxModfa6 + weightMatrix[i, 4] * adjInterf[k] / maxAdjInterf;
}
if (j == 0)
{
maxfitness = tempfitness;
maxfitnessindex = j;
}
else
{
if (tempfitness > maxfitness)
{
maxfitness = tempfitness;
maxfitnessindex = j;
}
}
}
#endregion
//最差的那个簇是maxfitnessindex,初始化,初始化------
#region
List<sortHelper> sortFlag = new List<sortHelper>();
List<int> candidate;
for (int j = 0; j < HighCoverClusters[maxfitnessindex].Count;j++)
{
bool ret = false;
string celltype = sList.sectorList[HighCoverClusters[maxfitnessindex][j]].sectorType;
candidate = outdoor;
if (celltype == "INDOOR") candidate = indoor;
if (celltype == "SPECIAL") candidate = special;
ret = getUsablePCI(HighCoverClusters[maxfitnessindex][j], candidate, ancestor, out sList.sectorList[HighCoverClusters[maxfitnessindex][j]].UsablePCI);
sortFlag.Add(new sortHelper(HighCoverClusters[maxfitnessindex][j], sList.sectorList[HighCoverClusters[maxfitnessindex][j]].UsablePCI.Count));
}
sortFlag.Sort(SortRewrite.CompareUsablePCI);
//初始化过程
System.Diagnostics.Stopwatch Time = new System.Diagnostics.Stopwatch();
Time.Start();
Individual[] individuals = new Individual[subPopSize];
for (int ii = 0; ii < individuals.Length; ii++)
{
individuals[ii] = new Individual(sList.sectorList.Count, objectNum);
ancestors[i].clone(ref individuals[ii]);//这里出现过错误,是因为我用ancestor克隆的,不是ancestors[ii]
}
for (int indivIndex = 0; indivIndex < individuals.Length; indivIndex++)
{
double r = rand.NextDouble();
if (r < 0.002)
{
List<pciSelection> usable = new List<pciSelection>();
for (int j = 0; j <= HighCoverClusters[maxfitnessindex].Count; j++)
{
usable.Clear();
for (int p = 0; p < sList.sectorList[HighCoverClusters[maxfitnessindex][j]].UsablePCI.Count; p++)
usable.Add(sList.sectorList[HighCoverClusters[maxfitnessindex][j]].UsablePCI[p]);
disSectorPCI(HighCoverClusters[maxfitnessindex][j], usable, ref individuals[indivIndex], i);
}
}
else
{
#region ;子段顺序为//逆;正;逆;正
if (indivIndex % 2 == 0)
{
List<pciSelection> usable = new List<pciSelection>();
for (int j = 0; j < sortFlag.Count / 4; j++)
{
int curIndex = sortFlag[j].SectorIndex;
usable.Clear();
for (int p = 0; p < sList.sectorList[curIndex].UsablePCI.Count; p++)
usable.Add(sList.sectorList[curIndex].UsablePCI[p]);
disSectorPCI(curIndex, usable, ref individuals[indivIndex], i);
}
for (int j = sortFlag.Count / 2; j >= sortFlag.Count / 4; j--)
{
int curIndex = sortFlag[j].SectorIndex;
usable.Clear();
for (int p = 0; p < sList.sectorList[curIndex].UsablePCI.Count; p++)
usable.Add(sList.sectorList[curIndex].UsablePCI[p]);
disSectorPCI(curIndex, usable, ref individuals[indivIndex], i);
}
for (int j = sortFlag.Count / 2 + 1; j <= sortFlag.Count * 3 / 4; j++)
{
int curIndex = sortFlag[j].SectorIndex;
usable.Clear();
for (int p = 0; p < sList.sectorList[curIndex].UsablePCI.Count; p++)
usable.Add(sList.sectorList[curIndex].UsablePCI[p]);
disSectorPCI(curIndex, usable, ref individuals[indivIndex], i);
}
for (int j = sortFlag.Count - 1; j > sortFlag.Count * 3 / 4; j--)
{
int curIndex = sortFlag[j].SectorIndex;
usable.Clear();
for (int p = 0; p < sList.sectorList[curIndex].UsablePCI.Count; p++)
usable.Add(sList.sectorList[curIndex].UsablePCI[p]);
disSectorPCI(curIndex, usable, ref individuals[indivIndex], i);
}
}
#endregion
#region ;子段顺序为//逆;正;逆;正
else
{
List<pciSelection> usable = new List<pciSelection>();
for (int j = sortFlag.Count / 4; j >= 0; j--)
{
int curIndex = sortFlag[j].SectorIndex;
usable.Clear();
for (int p = 0; p < sList.sectorList[curIndex].UsablePCI.Count; p++)
usable.Add(sList.sectorList[curIndex].UsablePCI[p]);
disSectorPCI(curIndex, usable, ref individuals[indivIndex], i);
}
for (int j = sortFlag.Count / 4 + 1; j < sortFlag.Count / 2; j++)
{
int curIndex = sortFlag[j].SectorIndex;
usable.Clear();
for (int p = 0; p < sList.sectorList[curIndex].UsablePCI.Count; p++)
usable.Add(sList.sectorList[curIndex].UsablePCI[p]);
disSectorPCI(curIndex, usable, ref individuals[indivIndex], i);
}
for (int j = sortFlag.Count * 3 / 4; j >= sortFlag.Count / 2; j--)
{
int curIndex = sortFlag[j].SectorIndex;
usable.Clear();
for (int p = 0; p < sList.sectorList[curIndex].UsablePCI.Count; p++)
usable.Add(sList.sectorList[curIndex].UsablePCI[p]);
disSectorPCI(curIndex, usable, ref individuals[indivIndex], i);
}
for (int j = sortFlag.Count * 3 / 4 + 1; j <= sortFlag.Count - 1; j++)
{
int curIndex = sortFlag[j].SectorIndex;
usable.Clear();
for (int p = 0; p < sList.sectorList[curIndex].UsablePCI.Count; p++)
usable.Add(sList.sectorList[curIndex].UsablePCI[p]);
disSectorPCI(curIndex, usable, ref individuals[indivIndex], i);
}
}
#endregion
}
for (int k = 0; k < individuals[indivIndex].gene.Length; k++)
{
if (individuals[indivIndex].gene[k] == -1)
Console.WriteLine("在第" + indivIndex + "个个体中,第" + k + "个小区PCI分配失败");
}
}
Time.Stop();
Console.WriteLine("局部搜索初始化,第{0}个种群 用时 {1}", i + 1, Time.Elapsed.TotalSeconds);
#endregion
//评估这subpopsize个个体,找到最好的,然后比较ancestor,是否替换该Ancestor
#region
double minfitness = 0;
int minfitnessindex=0;
evaluate(ref individuals,0);//评估个体数组,**********这里出现了错误!!!!!!!!
for (int j = 0; j < individuals.Length; j++)
{
double temp=0;
for(int ob=0;ob<objectNum;ob++)
{
temp += individuals[j].fitnessVec[ob]/individuals[j].fitnessVecOri[ob]*weightMatrix[i,ob];
}
if (j == 0)
{
minfitness = temp;
minfitnessindex=j;
}
else
{
if (minfitness > temp)
{
minfitness = temp;
minfitnessindex = j;
}
}
}
//计算ances的适应度值
double ancestorfitness=0;
for(int ob=0;ob<objectNum;ob++)
{
ancestorfitness += ancestors[i].fitnessVec[ob]/ ancestors[i].fitnessVecOri[ob]*weightMatrix[i,ob];
}
//如果最小的适应度值比精英个体还要好,那么就替换掉ancestor[i]
if (minfitness < ancestorfitness)
{
individuals[minfitnessindex].clone(ref ancestors[i]);
}
#endregion
}//循环所有的子种群