예제 #1
0
파일: CPCCD.cs 프로젝트: SY1990/RhinoPCCD
        // Find community information in each module
        public static void FindCommunity(double Alfa, List <List <int> > Modules, double[,] WeightMatrix, List <ComponentStruct> VerticeMatrix, int[,] RelativeMotionMatrix,
                                         out List <List <List <int> > > Communities, out List <double> Modularity, out List <double[, ]> SubGraphs, out List <List <ComponentStruct> > SubVerticeMs, out List <int[, ]> SubRelativeMs)
        {
            int NumOfModules = Modules.Count;

            Communities   = new List <List <List <int> > >();
            Modularity    = new List <double>();
            SubGraphs     = new List <double[, ]>();
            SubVerticeMs  = new List <List <ComponentStruct> >();;;
            SubRelativeMs = new List <int[, ]>();
            double[,] WMIntraModules;
            int                NumOfIteration  = 5;
            double             CrossOverRatio  = 0.4;
            double             MutationRatio   = 0.05;
            List <int>         NumOfPopulation = new List <int>();
            List <int>         NumOfGeneration = new List <int>();
            List <List <int> > SubModules;

            double[]   T_BestFitness;
            List <int> sublist = new List <int>();

            MPCCD.MPCCDSubGraph(Modules, WeightMatrix, VerticeMatrix, RelativeMotionMatrix, out WMIntraModules, out SubGraphs, out SubVerticeMs, out SubRelativeMs);
            int x = 0;

            for (int i = 0; i < NumOfModules; i++)
            {
                NumOfPopulation.Add((int)(Modules[x].Count / 2) + 1);
                NumOfGeneration.Add(5 * Modules[x].Count);
                x++;
            }
            // find the maximum modularity in each module
            for (int i = 0; i < NumOfModules; i++)
            {
                GAModuleDiv.FindBestSolution_Multiple(SubGraphs[i], NumOfPopulation[i], NumOfGeneration[i], CrossOverRatio, MutationRatio, out SubModules, out T_BestFitness);
                double XX = T_BestFitness.Max();
                if (T_BestFitness.Max() > Alfa)
                {
                    Communities.Add(SubModules.ToList());
                    Modularity.Add(T_BestFitness.Max());
                }
                else
                {
                    SubModules.Clear();
                    for (int j = 0; j < Modules[i].Count; j++)
                    {
                        sublist.Add(j + 1);
                    }
                    SubModules.Add(sublist.ToList());
                    Communities.Add(SubModules);
                    Modularity.Add(T_BestFitness.Max());
                    sublist.Clear();
                }
            }
        }
예제 #2
0
        // Find the best module division result through multiple iterations
        public static void FindBestSolution_Multiple(double[,] SymmWeightMatrix, int NumOfPopulation, int NumOfGeneration, double CrossOverRatio, double MutationRatio,
                                                     out List <List <int> > Modules, out double[] BestFitness)
        {
            int NumOfIteration = 5;

            BestFitness = new double[NumOfGeneration];
            Modules     = new List <List <int> >();

            for (int i = 0; i < NumOfIteration; i++)
            {
                double[]           Fitness      = new double[NumOfGeneration];
                List <List <int> > Temp_Modules = new List <List <int> >();
                GAModuleDiv.FindModule(NumOfPopulation, NumOfGeneration, CrossOverRatio, MutationRatio, SymmWeightMatrix, out Temp_Modules, out Fitness);
                if (i > 0)
                {
                    if (BestFitness.Max() < Fitness.Max())
                    {
                        Modules = Temp_Modules.ToList();
                        Array.Copy(Fitness, BestFitness, Fitness.Length);
                    }
                }
                else
                {
                    Modules = Temp_Modules.ToList();
                    Array.Copy(Fitness, BestFitness, Fitness.Length);
                }

                /* foreach (List<int> x in Modules)
                 * {
                 *   foreach (int xx in x)
                 *   {
                 *       Console.Write(" ");
                 *       Console.Write(string.Join(" ", xx.ToString()));
                 *   }
                 *   Console.WriteLine("\n");
                 * }
                 *
                 * Console.WriteLine(BestFitness.Max().ToString());
                 * Console.WriteLine("\n");
                 *
                 */
            }
        }
예제 #3
0
        // find the optimal module division result
        public static void FindModule(int NumOfPopulation, int NumOfGeneration, double CrossOverRatio, double MutationRatio, double[,] WeightMatrix, out List <List <int> > Modules, out double[] BestFitness)
        {
            int NumOfNode = WeightMatrix.GetLength(0);

            Modules     = new List <List <int> >();
            BestFitness = new double[NumOfGeneration];
            int[]  BestGene   = new int[NumOfNode]; // the best gene in one generation
            double MaxFitness = 0;

            int[] MaxGene = new int[NumOfNode]; // the max gene in one generation
            int[,] InitialPop;
            int[,] OldPop = new int[NumOfPopulation, NumOfNode];
            int[,] NewPop = new int[NumOfPopulation, NumOfNode];
            int[][]            AdjacentNodes;
            List <List <int> > Community = new List <List <int> >();

            double[] Fitness;
            double[] OldFitness = new double[NumOfPopulation];
            double[] NewFitness = new double[NumOfPopulation];
            double[] AveFitness = new double[NumOfGeneration];
            double[] Temp_NormalizeFitness = new double[NumOfPopulation];
            double[] Temp_Fitness = new double[NumOfPopulation];
            int      SelectionFather = 0, SelectionMother = 0, CrossOverPosition = 0, MutationPosition = 0;
            double   Temp_sum;

            int        NumMax = 0;
            List <int> RowOfMax = new List <int>();

            // Initialize the population
            GAModuleDiv.InitializePopulation(NumOfNode, NumOfPopulation, WeightMatrix, out InitialPop, out AdjacentNodes);
            GAModuleDiv.FitnessCalAll(InitialPop, AdjacentNodes, WeightMatrix, out Fitness);
            Array.Copy(InitialPop, OldPop, NumOfPopulation * NumOfNode);
            Array.Copy(Fitness, OldFitness, Fitness.Length);
            Random rnd = new Random();

            //find the best solution
            for (int i = 0; i < NumOfGeneration; i++)
            {
                Temp_sum      = 0;
                MaxFitness    = OldFitness.Max();
                AveFitness[i] = OldFitness.Sum() / NumOfPopulation;
                RowOfMax.Clear();
                // find the row of the max
                for (int j = 0; j < NumOfPopulation; j++)
                {
                    if (MaxFitness == OldFitness[j])
                    {
                        RowOfMax.Add(j);
                    }
                }
                for (int k = 0; k < OldPop.GetLength(1); k++)
                {
                    MaxGene[k] = OldPop[RowOfMax[0], k];
                }
                // copy the best gene to the first few rows
                if (i > 0)
                {
                    if (MaxFitness > BestFitness[i - 1])
                    {
                        BestFitness[i] = MaxFitness;
                        Array.Copy(MaxGene, BestGene, NumOfNode);
                        // copy the best rows

                        /* for (int k = 0; k < RowOfMax.Count; k++)
                         * {
                         *   for (int x = 0; x < NumOfNode; x++)
                         *   {
                         *       NewPop[k, x] = OldPop[RowOfMax[k], x];
                         *   }
                         * }
                         * NumMax = RowOfMax.Count;
                         * */
                        for (int x = 0; x < NumOfNode; x++)
                        {
                            NewPop[0, x] = OldPop[RowOfMax[0], x];
                        }
                        NumMax = 1;
                    }
                    else
                    {
                        BestFitness[i] = BestFitness[i - 1];

                        for (int x = 0; x < NumOfNode; x++)
                        {
                            NewPop[0, x] = OldPop[RowOfMax[0], x];
                        }
                        NumMax = 1;
                    }
                }
                else
                {
                    BestFitness[i] = MaxFitness;
                    Array.Copy(MaxGene, BestGene, NumOfNode);
                    // copy the best rows

                    /*for (int k = 0; k < RowOfMax.Count; k++)
                     * {
                     *  for (int x = 0; x < NumOfNode; x++)
                     *  {
                     *      NewPop[k, x] = OldPop[RowOfMax[k], x];
                     *  }
                     * }
                     * NumMax = RowOfMax.Count;*/
                    for (int x = 0; x < NumOfNode; x++)
                    {
                        NewPop[0, x] = OldPop[RowOfMax[0], x];
                    }
                    NumMax = 1;
                }

                // selection, normalization
                double[] Temp_NormalizeFitness1 = new double[NumOfPopulation];
                for (int k = 0; k < NumOfPopulation; k++)
                {
                    Temp_NormalizeFitness1[k] = OldFitness[k] + Math.Abs(OldFitness.Min()) + 0.01;
                }
                for (int k = 0; k < NumOfPopulation; k++)
                {
                    Temp_NormalizeFitness[k] = Temp_NormalizeFitness1[k] / Temp_NormalizeFitness1.Sum();
                }



                for (int k = 0; k < NumOfPopulation; k++)
                {
                    Temp_sum        = Temp_sum + Temp_NormalizeFitness[k];
                    Temp_Fitness[k] = Temp_sum;
                }


                for (int j = NumMax; j < NumOfPopulation; j++)
                {
                    double Delta = rnd.NextDouble();
                    for (int k = 0; k < NumOfPopulation; k++)
                    {
                        if (Delta < Temp_Fitness[k])
                        {
                            for (int x = 0; x < NumOfNode; x++)
                            {
                                NewPop[j, x] = OldPop[k, x];
                            }
                            SelectionFather = k;
                            break;
                        }
                    }
                    ////////////////////////check NewPop  from above to find why it does not work////////////////

                    // crossover

                    SelectionMother   = rnd.Next(0, NumOfPopulation);
                    CrossOverPosition = rnd.Next(0, NumOfNode);
                    double Delta2 = rnd.NextDouble();
                    if (Delta2 <= CrossOverRatio)
                    {
                        for (int k = 0; k < CrossOverPosition; k++)
                        {
                            NewPop[j, k] = OldPop[SelectionFather, k];
                        }

                        for (int k = CrossOverPosition; k < NumOfNode; k++)
                        {
                            NewPop[j, k] = OldPop[SelectionMother, k];
                        }
                    }
                    // mutation

                    double Delta3 = rnd.NextDouble();
                    MutationPosition = rnd.Next(0, NumOfNode);
                    if (Delta3 <= MutationRatio)
                    {
                        NewPop[j, MutationPosition] = AdjacentNodes[MutationPosition][rnd.Next(0, AdjacentNodes[MutationPosition].GetLength(0))];
                    }
                }
                GAModuleDiv.FitnessCalAll(NewPop, AdjacentNodes, WeightMatrix, out NewFitness);
                Array.Copy(NewFitness, OldFitness, NumOfPopulation);
                Array.Copy(NewPop, OldPop, NumOfPopulation * NumOfNode);
                Array.Clear(NewPop, 0, NumOfPopulation * NumOfNode);
                Array.Clear(NewFitness, 0, NumOfPopulation);
            }

            GAModuleDiv.TransToCommunity(NumOfNode, BestGene, out Modules);
        }