遗传算法(C#)

最新推荐文章于 2023-04-27 09:48:58 发布
最新推荐文章于 2023-04-27 09:48:58 发布
阅读量8k 收藏 77
点赞数 25
CC 4.0 BY-SA版权
分类专栏： 算法 文章标签： 遗传算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/kyq0417/article/details/84345094

这几天学习遗传算法
从onelei1994的博客https://blog.youkuaiyun.com/onelei1994/article/details/74048379下载了代码
但是实际运行中，发现onelei1994的代码算法大逻辑没有问题，存在几个细节问题，所以运行出来的结果是不争取的

  1. chromosome的定义，没有定义复制方法，所以，在往子代传递的时候，变成了引用传递，在传递了几代之后，后代其实全部变成了一个染色体
  2. 随机数取值的时候临时定义的Random变量，导致循环中每次取到的随机数有很大程度是一样的
  3. 轮盘赌选择时，没有定义子代种群，直接在当前种群中操作，会覆盖一部分父代，导致基因丢失
  4. 累积概率计算不正确
  5. 交叉方法不正常
  6. 变异方法不正确
  7. 适度函数选取的空间不正确
    修改过后的代码如下
    修改后的代码执行结果很稳定
using System;
using System.Collections.Generic;

namespace GeneticAlgorithm
{
    internal class Program
    {
        /// <summary>
        /// 染色体;
        /// </summary>
        private class chromosome
        {
            /// <summary>
            /// 用6bit对染色体进行编码;
            /// </summary>
            public int[] bits = new int[6];

            /// <summary>
            /// 适应值;
            /// </summary>
            public int fitValue;

            /// <summary>
            /// 选择概率;
            /// </summary>
            public double fitValuePercent;

            /// <summary>
            /// 累积概率;
            /// </summary>
            public double probability;

            public chromosome Clone()
            {
                chromosome c = new chromosome();
                for (int i = 0; i < bits.Length; i++)
                {
                    c.bits[i] = bits[i];
                }
                c.fitValue = fitValue;
                c.fitValuePercent = fitValuePercent;
                c.probability = probability;
                return c;
            }
        }

        /// <summary>
        /// 染色体组;
        /// </summary>
        private static List<chromosome> chromosomes = new List<chromosome>();

        private static List<chromosome> chromosomesChild = new List<chromosome>();

        private static Random random = new Random();

        private enum ChooseType
        {
            Bubble,//冒泡;
            Roulette,//轮盘赌;
        }

        private static ChooseType chooseType = ChooseType.Roulette;

        /// <summary>
        /// Main入口函数;
        /// </summary>
        /// <param name="args"></param>
        private static void Main(string[] args)
        {
            Console.WriteLine("遗传算法");
            Console.WriteLine("下面举例来说明遗传算法用以求函数最大值函数为y = -x*x+ 5的最大值，-32<=x<=31");
            // f(x)=-x2+ 5
            // 迭代次数;
            int totalTime = 200;
            Console.WriteLine("迭代次数为: " + totalTime);
            //初始化;
            Console.WriteLine("初始化: ");
            Init();
            // 输出初始化数据;
            Print();
            for (int i = 0; i < totalTime; i++)
            {
                Console.WriteLine("当前迭代次数: " + i);

                //重新计算fit值;;
                UpdateFitValue();

                // 挑选染色体;
                Console.WriteLine("挑选:");

                switch (chooseType)
                {
                    case ChooseType.Bubble:
                        // 排序;
                        Console.WriteLine("排序:");
                        ChooseChromosome();
                        break;

                    default:
                        //轮盘赌;
                        Console.WriteLine("轮盘赌:");
                        UpdateNext();
                        break;
                }
                Print(true);

                //交叉得到新个体;
                Console.WriteLine("交叉:");
                CrossOperate();
                Print();

                //变异操作;
                Console.WriteLine("变异:");
                VariationOperate();
                Print();
            }

            int maxfit = chromosomes[0].fitValue;
            for (int i = 1; i < chromosomes.Count; i++)
            {
                if (chromosomes[i].fitValue > maxfit)
                {
                    maxfit = chromosomes[i].fitValue;
                }
            }
            Console.WriteLine("最大值为: " + maxfit);
            Console.ReadLine();
        }

        /// <summary>
        /// 打印;
        /// </summary>
        private static void Print(bool bLoadPercent = false)
        {
            Console.WriteLine("=========================");
            for (int i = 0; i < chromosomes.Count; i++)
            {
                Console.Write("第" + i + "条" + " bits: ");
                for (int j = 0; j < chromosomes[i].bits.Length; j++)
                {
                    Console.Write(" " + chromosomes[i].bits[j]);
                }
                int x = DeCode(chromosomes[i].bits);
                Console.Write(" x: " + x);
                Console.Write(" y: " + chromosomes[i].fitValue);
                if (bLoadPercent)
                {
                    Console.Write(" 选择概率: " + chromosomes[i].fitValuePercent);
                    //Console.Write(" 累积概率: " + chromosomes[i].probability);
                }
                Console.WriteLine();
            }
            Console.WriteLine("=========================");
        }

        /// <summary>
        /// 初始化;
        /// </summary>
        private static void Init()
        {
            chromosomes.Clear();
            // 染色体数量;
            int length = 10;
            int totalFit = 0;

            for (int i = 0; i < length; i++)
            {
                chromosome chromosome = new chromosome();
                for (int j = 0; j < chromosome.bits.Length; j++)
                {
                    // 随机出0或者1;
                    //int seed = (i + j) * 100 / 3;//种子;
                    int bitValue = random.Next(0, 2);
                    chromosome.bits[j] = bitValue;
                }
                //获得十进制的值;
                int x = DeCode(chromosome.bits);
                int y = GetFitValue(x);
                chromosome.fitValue = y;
                chromosomes.Add(chromosome);
                //算出total fit;
                if (chromosome.fitValue <= 0)
                {
                    totalFit += 0;
                }
                else
                {
                    totalFit += chromosome.fitValue;
                }
            }
        }

        /// <summary>
        /// 解码,二进制装换;
        /// </summary>
        /// <param name="bits"></param>
        /// <returns></returns>
        private static int DeCode(int[] bits)
        {
            int result = bits[1] * 16 + bits[2] * 8 + bits[3] * 4 + bits[4] * 2 + bits[5] * 1;
            //正数;
            if (bits[0] == 0)
            {
                return result;
            }
            else
            {
                return -result;
            }
        }

        /// <summary>
        /// 获取fit值;
        /// </summary>
        /// <param name="x"></param>
        /// <returns></returns>
        private static int GetFitValue(int x)
        {
            //目标函数：y= - ( x^ 2 ) +5;
            return (x * x) + 5;
        }

        /// <summary>
        /// 更新下一代;
        /// 基于轮盘赌选择方法，进行基因型的选择;
        /// </summary>
        private static void UpdateNext()
        {
            // 获取总的fit;
            double totalFitValue = 0;
            for (int i = 0; i < chromosomes.Count; i++)
            {
                //适应度为负数的取0;
                if (chromosomes[i].fitValue <= 0)
                {
                    totalFitValue += 0;
                }
                else
                {
                    totalFitValue += chromosomes[i].fitValue;
                }
            }
            Console.WriteLine("totalFitValue " + totalFitValue);

            //算出每个的fit percent;
            for (int i = 0; i < chromosomes.Count; i++)
            {
                if (chromosomes[i].fitValue <= 0)
                {
                    chromosomes[i].fitValuePercent = 0;
                }
                else
                {
                    chromosomes[i].fitValuePercent = chromosomes[i].fitValue / totalFitValue;
                }
                Console.WriteLine("fitValuePercent " + i + " " + chromosomes[i].fitValuePercent);
            }

            ////计算累积概率;
            //// 第一个的累计概率就是自己的概率;
            chromosomes[0].probability = chromosomes[0].fitValuePercent;
            Console.WriteLine("probability 0 " + chromosomes[0].probability);
            double probability = chromosomes[0].probability;
            for (int i = 1; i < chromosomes.Count; i++)
            {
                if (chromosomes[i].fitValuePercent != 0)
                {
                    chromosomes[i].probability = chromosomes[i].fitValuePercent + probability;
                    probability = chromosomes[i].probability;
                }
                Console.WriteLine("probability " + i + " " + chromosomes[i].probability);
            }
            chromosomesChild.Clear();
            //轮盘赌选择方法,用于选出前两个;
            for (int i = 0; i < chromosomes.Count; i++)
            {
                //产生0-1之前的随机数;
                //int seed = i * 100 / 3;
                double rand = random.NextDouble();//0.0-1.0
                Console.WriteLine("挑选的rand " + rand);
                if (rand < chromosomes[0].probability)
                {
                    chromosomesChild.Add(chromosomes[0].Clone());
                }
                else
                {
                    for (int j = 0; j < chromosomes.Count - 1; j++)
                    {
                        if (chromosomes[j].probability <= rand && rand <= chromosomes[j + 1].probability)
                        {
                            chromosomesChild.Add(chromosomes[j + 1].Clone());
                        }
                    }
                }
            }
            for (int i = 0; i < chromosomes.Count; i++)
            {
                chromosomes[i] = chromosomesChild[i];
            }
        }

        /// <summary>
        /// 选择染色体;
        /// </summary>
        private static void ChooseChromosome()
        {
            // 从大到小排序;
            chromosomes.Sort((a, b) => { return b.fitValue.CompareTo(a.fitValue); });
        }

        /// <summary>
        /// 交叉操作;
        /// </summary>
        private static void CrossOperate()
        {
            /**         bit[5]~bit[0]   fit
             * 4        000 110         12
             * 3        001 010         9
             * child1   000 010         14
             * child2   001 110         5
             */
            int rand1 = random.Next(0, 6);//0-5;
            int rand2 = random.Next(0, 6);//0-5;
            if (rand1 > rand2)
            {
                var t = rand1;
                rand1 = rand2;
                rand2 = t;
            }
            Console.WriteLine("交叉的rand " + rand1 + " - " + rand2);
            for (int j = 0; j < chromosomes.Count; j = j + 2)
            {
                for (int i = rand1; i <= rand2; i++)
                {
                    //将第0个给第2个;
                    var t = chromosomes[j].bits[i];
                    chromosomes[j].bits[i] = chromosomes[j + 1].bits[i];//第一条和第三条交叉;
                    chromosomes[j + 1].bits[i] = t;
                }
                chromosomes[j].fitValue = GetFitValue(DeCode(chromosomes[j].bits));
                chromosomes[j + 1].fitValue = GetFitValue(DeCode(chromosomes[j + 1].bits));
            }
        }

        /// <summary>
        /// 变异操作;
        /// </summary>
        private static void VariationOperate()
        {
            int rand = random.Next(0, 50);
            Console.WriteLine("变异的rand " + rand);
            if (rand < 5)//1/50 = 0.02的概率进行变异;rand==25;
            {
                Console.WriteLine("开始变异");

                int col = random.Next(0, 6);
                int row = random.Next(0, 4);
                Console.WriteLine("变异的位置 " + row + "  " + col);
                // 0变为1,1变为0;
                if (chromosomes[row].bits[col] == 0)
                {
                    chromosomes[row].bits[col] = 1;
                }
                else
                {
                    chromosomes[row].bits[col] = 0;
                }
                chromosomes[row].fitValue = GetFitValue(DeCode(chromosomes[row].bits));
            }
        }

        /// <summary>
        /// 重新计算fit值;
        /// </summary>
        private static void UpdateFitValue()
        {
            for (int i = 0; i < chromosomes.Count; i++)
            {
                chromosomes[i].fitValue = GetFitValue(DeCode(chromosomes[i].bits));
            }
        }
    }
}
从入门到精通：遗传算法全攻略
邓邓子的博客
06-25 1680
遗传算法作为受生物进化理论启发的智能优化算法，通过模拟自然选择、交叉、变异等过程求解复杂优化问题。本文系统构建遗传算法知识体系：从编码机制与适应度函数设计入手，解析选择、交叉、变异等核心操作的数学原理与工程实现；结合工程优化、人工智能、航空航天等多领域应用案例，阐述算法在函数优化、超参数调优等场景的实践逻辑；通过 Python 实战演示算法全流程，分析迭代收敛特性。同时客观剖析算法全局搜索优势与早熟收敛等不足，探讨自适应参数调整等优化策略，为读者提供从理论认知到工程落地的完整指南。
遗传算法 C# 实现
最新发布
Tai_zg的博客
01-18 753
c#代码实现遗传算法
遗传算法，C#代码，简单入手
12-11
用简单的例子讲解遗传算法，代码主要用C#编程，内容简单详细清楚。
遗传算法的C#实现
故事不长丨的博客
04-27 1287
遗传算法是计算数学中用于解决最佳化的搜索算法，是进化算法的一种。进化算法最初是借鉴了进化生物学中的一些现象而发展起来的，这些现象包括遗传、突变、自然选择以及杂交等。遗传算法通常实现方式为一种计算机模拟。
C#遗传算法程序（可视化版）
05-25
将一段用C语言实现的求解下列方程： f(x1,x2,x3)=x1^2-x1*x2+x3 在给定区间的最大值的遗传算法程序改成C#程序。 要求： 　　　　　（1）、数据从文件读入，结果输出到另一文件； 　　　　　（2） 实现多线程。
基于C#的遗传算法
qq_42552806的博客
11-09 3018
在学习遗传算法时，参考了https://blog.youkuaiyun.com/kyq0417/article/details/84345094，在运行过程中，做了一些修改，以函数y=-x^2+5求最大值作为测试函数，验证了算法的正确性，代码如下： using System; using System.Collections.Generic; using System.Linq; using System.T...
一个遗传算法.rar_C#遗传算法_c 遗传算法_c++ 遗传算法_遗传算法 _遗传算法 c#
07-14
在C#、C和C++等编程语言中，都有实现遗传算法的框架和库，以支持开发者在各种应用场景下进行高效的计算。 标题中的“一个遗传算法.rar”暗示了这是一个关于遗传算法的代码或实例集合，可能包含了C#、C和C++三种编程...
遗传算法c#实现，参考，学习
07-22
本项目是基于C#编程语言实现的遗传算法，适用于学习和参考。 遗传算法的基本原理是模拟生物的自然选择、遗传、变异等过程来寻找问题的最优解。首先，通过随机生成一组初始解（称为种群），这些解代表可能的解决方案...
TSP问题的遗传算法 C#编写 genetic algorithm
09-05
在C#编程环境下，我们可以利用遗传算法来解决TSP问题，这涉及到以下几个关键知识点：** 1. **旅行商问题（TSP）**: TSP是图论中的一个经典问题，描述了一个旅行商如何访问一系列城市，每个城市仅访问一次，然后返回...
非常好用的遗传算法 C#程序 源码 遗传算法例子 遗传算法程序
03-14
标题中的"非常好用的遗传算法 C#程序 源码"表明这是一个实用的遗传算法实现，提供了C#源代码，方便开发者学习和应用。遗传算法的核心组件包括种群初始化、适应度函数、选择、交叉和变异等操作。 1. 种群初始化：...
C#遗传算法（常用7种遗传算法源码实例）
03-31
该资源包含了常用的7种C#遗传算法源码实例集，和遗传算法C#五子棋游戏程序
C#实现遗传算法
04-20
讲解举例用C#编程实现遗传算法。代码实现
遗传算法的c#实现
08-27
数据挖掘中遗传算法的实现，采用c#语言，可推广多c++，java等其他语言的实现
C# 中的基本遗传算法示例_C#_代码_下载
06-18
C# 中的基本遗传算法示例
遗传算法最短路径c#实现
01-20
遗传算法最短路径c#实现
遗传算法通用写法C#
ysg8422am的专栏
11-05 4279
遗传算法是通过模拟生物进化而进行数据寻优的一种进化算法。主要过程是初始种群的产生，选择，交叉，变异，循环迭代，直至出现最优解。本程序两个主要类，种群类与个体类。定义进化策略接口，计算适应度策略接口。进化策略接口实现三个行为，交叉，变异，选择，其中，进化策略接口可以加上自己的实现。大致实现如下：////class Population//using System;using System.Col
遗传算法的C#实现及应用
ysg8422am的专栏
11-05 2429
 以下代码实现了一个简单的花朵进化的模拟过程。花朵的种群数量是10，共进化了50代。通过运行程序，你会发现通过不断的进化，种群的总的适应环境的能力在逐步提高（fitness的值下降）。实现代码：using System; using System.Collections.Generic; using System.Text; namespace GA{class Program{static vo
C#实现遗传算法，模拟花朵的进化。
weixin_34228662的博客
01-09 239
 以下代码实现了一个简单的花朵进化的模拟过程。 花朵的种群数量是10，共进化了50代。 通过运行程序，你会发现通过不断的进化，种群的总的适应环境的能力在逐步提高（fitness的值下降）。 实现代码： using System; using System.Collections.Generic; using System.Text; namespace GA {   ...
C#实现的标准遗传算法示例
资源摘要信息: "standard-GA...总结来说，该资源为开发者提供了一个易于理解和修改的标准遗传算法C#实现，允许用户通过简单的自定义快速实现问题的优化。资源的结构旨在减少学习曲线，使遗传算法的应用更加广泛和高效。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值