遗传算法

最新推荐文章于 2024-07-05 23:41:49 发布
最新推荐文章于 2024-07-05 23:41:49 发布
阅读量679 收藏
点赞数
分类专栏： 智能算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012421537/article/details/42642535
版权 
/**************************************************************************/
/* This is a simple genetic algorithm implementation where the */
/* evaluation function takes positive values only and the      */
/* fitness of an individual is the same as the value of the    */
/* objective function                                          */
/**************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <conio.h>
#include <time.h>

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

/* Change any of these parameters to match your needs */

#define POPSIZE 500               /* population size */
#define MAXGENS 50             /* max. number of generations */
#define NVARS 329                  /* no. of problem variables 结点个数 */
#define PXOVER 0.9               /* probability of crossover */
#define PMUTATION 0.1           /* probability of mutation */
#define TRUE 1
#define FALSE 0

int generation;                  /* current generation no. */
int cur_best;                    /* best individual */
FILE *galog;                     /* an output file */
int **AdjacentMatrix; 

struct genotype /* genotype (GT), a member of the population */
{
	int gene[NVARS];        /* a string of variables */
	int fitness;            /* GT's fitness */
	double upper[NVARS];       /* GT's variables upper bound */
	double lower[NVARS];       /* GT's variables lower bound */
	double rfitness;           /* relative fitness */
	double cfitness;           /* cumulative fitness */
};

struct genotype population[POPSIZE+1];    /* population */
struct genotype newpopulation[POPSIZE+1]; /* new population; */
/* replaces the */
/* old generation */

/* Declaration of procedures used by this genetic algorithm */

void initialize(void);
double randval(double, double);
void evaluate(void);
void keep_the_best(void);
void elitist(void);
void select(void);
void crossover(void);
void Xover(int,int);
void swap(int *, int *);
void mutate(void);
void report(void);

/***************************************************************/
/* Read the file of AdjacentMatrix to compute the              */
/*                         energyfunction                      */
/***************************************************************/

void ReadFile (char *filepath, int** p, int row, int col)
{
	int i, j;
	ifstream input(filepath,ios::in);
	
	if (input.fail())
	{
		cout << "Oops! Couldn't open data file\n";
		exit(1);
	}
	
	for (i=0; i<row; i++)
	{
		for (j=0; j<col; j++)
		{
			input >> p[i][j];
			input.get();
		}
	}
	input.close();
}



/***************************************************************/
/* Initialization function: Initializes the values of genes    */
/* within the variables bounds. It also initializes (to zero)  */
/* all fitness values for each member of the population. It    */
/* reads upper and lower bounds of each variable from the      */
/* input file `gadata.txt'. It randomly generates values       */
/* between these bounds for each gene of each genotype in the  */
/* population. The format of the input file `gadata.txt' is    */
/* var1_lower_bound var1_upper bound                           */
/* var2_lower_bound var2_upper bound ...                       */
/***************************************************************/

void initialize(void)
{
	int i, j;
	/* initialize variables within the bounds */
	
	for (i = 0; i < POPSIZE; i++)
	{
		for (j = 0; j < NVARS; j++)
		{
			population[i].fitness = 0;
			population[i].rfitness = 0;
			population[i].cfitness = 0;

	//		population[j].gene[i] = randval(population[j].lower[i],population[j].upper[i]);
			population[i].gene[j] = j;
		}
	}
	
}

/***********************************************************/
/* Random value generator: Generates a value within bounds */
/***********************************************************/

double randval(double low, double high)
{
	double val;
	val = ((double)(rand()%1000)/1000.0)*(high - low) + low;
	return(val);
}

/*************************************************************/
/* Evaluation function: This takes a user defined function.  */
/* Each time this is changed, the code has to be recompiled. */
/* The current function is:  x[1]^2-x[1]*x[2]+x[3]           */
/*************************************************************/

void evaluate(void)
{
	int mem;
	int i, j, m;
	
	for (mem = 0; mem < POPSIZE; mem++)
	{
		for (i = 0; i < NVARS; i++)
		{
			for (j = i+1; j < NVARS; j++)
			{
				if (population[mem].gene[i] == population[mem].gene[j])
				{
					m = 1;
				}
				else
				{
					m = -1;
				}
				population[mem].fitness += (1 - AdjacentMatrix[i][j] * m)/2;
			}
		}
	}
}

/***************************************************************/
/* Keep_the_best function: This function keeps track of the    */
/* best member of the population. Note that the last entry in  */
/* the array Population holds a copy of the best individual    */
/***************************************************************/

void keep_the_best()
{
	int mem;
	int i;
	cur_best = 0; /* stores the index of the best individual */
	
	for (mem = 0; mem < POPSIZE; mem++)
	{
		if (population[mem].fitness < population[POPSIZE].fitness)
		{
            cur_best = mem;
            population[POPSIZE].fitness = population[mem].fitness;
		}
	}
	/* once the best member in the population is found, copy the genes */
	for (i = 0; i < NVARS; i++)
		population[POPSIZE].gene[i] = population[cur_best].gene[i];
}

/****************************************************************/
/* Elitist function: The best member of the previous generation */
/* is stored as the last in the array. If the best member of    */
/* the current generation is worse then the best member of the  */
/* previous generation, the latter one would replace the worst  */
/* member of the current population                             */
/****************************************************************/

void elitist()
{
	int i;
	int best, worst;             /* best and worst fitness values */
	int best_mem, worst_mem; /* indexes of the best and worst member */
	
	best = population[0].fitness;
	worst = population[0].fitness;
	for (i = 0; i < POPSIZE - 1; ++i)
	{
		if(population[i].fitness < population[i+1].fitness)
		{      
            if (population[i].fitness <= best)
			{
				best = population[i].fitness;
				best_mem = i;
			}
            if (population[i+1].fitness >= worst)
			{
				worst = population[i+1].fitness;
				worst_mem = i + 1;
			}
		}
		else
		{
            if (population[i].fitness >= worst)
			{
				worst = population[i].fitness;
				worst_mem = i;
			}
            if (population[i+1].fitness <= best)
			{
				best = population[i+1].fitness;
				best_mem = i + 1;
			}
		}
	}
	/* if best individual from the new population is better than */
	/* the best individual from the previous population, then    */
	/* copy the best from the new population; else replace the   */
	/* worst individual from the current population with the     */
	/* best one from the previous generation                     */
	
	if (best <= population[POPSIZE].fitness)
    {
		for (i = 0; i < NVARS; i++)
			population[POPSIZE].gene[i] = population[best_mem].gene[i];
		population[POPSIZE].fitness = population[best_mem].fitness;
    }
	else
    {
		for (i = 0; i < NVARS; i++)
			population[worst_mem].gene[i] = population[POPSIZE].gene[i];
		population[worst_mem].fitness = population[POPSIZE].fitness;
    } 
}
/**************************************************************/
/* Selection function: Standard proportional selection for    */
/* maximization problems incorporating elitist model - makes  */
/* sure that the best member survives                         */
/**************************************************************/

void select(void)
{
	int mem, i, j;
	int sum = 0;
	double p;
	
	/* find total fitness of the population */
	for (mem = 0; mem < POPSIZE; mem++)
	{
		sum += population[mem].fitness;
	}
	
	/* calculate relative fitness */
	for (mem = 0; mem < POPSIZE; mem++)
	{
		population[mem].rfitness =  population[mem].fitness/sum;
	}
	population[0].cfitness = population[0].rfitness;
	
	/* calculate cumulative fitness */
	for (mem = 1; mem < POPSIZE; mem++)
	{
		population[mem].cfitness =  population[mem-1].cfitness +       
			population[mem].rfitness;
	}
	
	/* finally select survivors using cumulative fitness. */
	
	for (i = 0; i < POPSIZE; i++)
	{ 
		p = rand()%1000/1000.0;
		if (p < population[0].cfitness)
            newpopulation[i] = population[0];      
		else
		{
            for (j = 0; j < POPSIZE;j++)      
				if (p >= population[j].cfitness && p<population[j+1].cfitness)
					newpopulation[i] = population[j+1];
		}
	}
	/* once a new population is created, copy it back */
	
	for (i = 0; i < POPSIZE; i++)
		population[i] = newpopulation[i];      
}

/***************************************************************/
/* Crossover selection: selects two parents that take part in  */
/* the crossover. Implements a single point crossover          */
/***************************************************************/

void crossover(void)
{
	int mem, one;
	int first  =  0; /* count of the number of members chosen */
	
	double x;
	
	for (mem = 0; mem < POPSIZE; mem+=2)
	{
		x = rand()%1000/1000.0;
		if (x < PXOVER)
		{
            ++first;
            if (first % 2 == 0)
				Xover(one, mem);
            else
				one = mem;
		}
	}
}
/**************************************************************/
/* Crossover: performs crossover of the two selected parents. */
/**************************************************************/

void Xover(int one, int two)
{
	int i;
	int point1, point2, temp; /* crossover point */
	
	/* select crossover point */
	if(NVARS > 1)
	{
		if(NVARS == 2)
			point1 = 1;
		else
		{	point1 = (rand() % (NVARS - 1)) + 1;
			point2 = (rand() % (NVARS - 1)) + 1;
			if (point1 == point2)
			{
				point2 = (rand() % (NVARS - 1)) + 1;
			}
			else
			{
				if (point1 > point2)
				{
					temp = point1;
					point1 = point2;
					point2 = temp;
				}
			}
		}
		for (i = point1; i <= point2; i++)
		{
			swap(&population[one].gene[i], &population[two].gene[i]);
		}
	}
}

/*************************************************************/
/* Swap: A swap procedure that helps in swapping 2 variables */
/*************************************************************/

void swap(int *x, int *y)
{
	int temp;
	
	temp = *x;
	*x = *y;
	*y = temp;
	
}

/**************************************************************/
/* Mutation: Random uniform mutation. A variable selected for */
/* mutation is replaced by a random value between lower and   */
/* upper bounds of this variable                              */
/**************************************************************/

void mutate(void)
{
	int i, point1, point2;

	double x;
	
	for (i = 0; i < POPSIZE; i++)
	{
		x = rand()%1000/1000.0;
        if (x < PMUTATION)
		{
			int count = 0;
			point1 = (rand() % (NVARS - 1)) + 1;
			point2 = (rand() % (NVARS - 1)) + 1;

			do 
			{
				point2 = (rand() % (NVARS - 1)) + 1;
				count++;
			}while ((AdjacentMatrix[point1][point2] !=1)&&(count != NVARS) );
			
			if (AdjacentMatrix[point1][point2] == 1)
			{
				population[i].gene[point1] = population[i].gene[point2];
			}
		}
	}
}

/***************************************************************/
/* Report function: Reports progress of the simulation. Data   */
/* dumped into the  output file are separated by commas        */
/***************************************************************/

void report(void)
{
	int i;
	int best_val;            /* best population fitness */
	int avg;                 /* avg population fitness */
	double stddev;              /* std. deviation of population fitness */
	int sum_square;          /* sum of square for std. calc */
	double square_sum;          /* square of sum for std. calc */
	int sum;                 /* total population fitness */
	
	sum = 0.0;
	sum_square = 0.0;
	
	for (i = 0; i < POPSIZE; i++)
	{
		sum += population[i].fitness;
		sum_square += population[i].fitness * population[i].fitness;
	}
	
	avg = sum/POPSIZE;
	square_sum = avg * avg * POPSIZE;
	stddev = sqrt((sum_square - square_sum)/(POPSIZE - 1));
	best_val = population[POPSIZE].fitness;
	
//	fprintf(galog, "/n%5d,      %6.3f, %6.3f, %6.3f /n/n", generation, best_val, avg, stddev);
}

/**************************************************************/
/* Main function: Each generation involves selecting the best */
/* members, performing crossover & mutation and then          */
/* evaluating the resulting population, until the terminating */
/* condition is satisfied                                     */
/**************************************************************/

void main(void)
{
	int i;
	AdjacentMatrix = new int *[NVARS];
	for (i = 0;i < NVARS;i++)
	{
		AdjacentMatrix[i] = new int [NVARS];
	}
	
	char *SignedData[] = {   "slovene1.txt",  "gahuku2.txt", \
							"data1.txt",  "data2.txt",        \
							"EGFR.txt",  "Macrophage.txt",	   \
							 "yeast.txt", "ecoli.txt",          \
							 "wiki.txt"};
	int RealIndex = 4;
	generation = 0;
//	strcpy(strReal,SignedData[RealIndex]);
	ReadFile(SignedData[RealIndex],AdjacentMatrix,NVARS,NVARS);

/*	if ((galog = fopen("galog.txt","w"))==NULL)
	{
		exit(1);
	}
	
	fprintf(galog, "/n generation  best  average  standard /n");
	fprintf(galog, " number      value fitness  deviation /n"); */
	
	initialize();
	evaluate();
	keep_the_best();

	while(generation<MAXGENS)
	{
		generation++;
		select();
		crossover();
		mutate();
		evaluate();
		report();
		elitist();
		printf ("The %d generation\n", generation);
		for (i = 0; i < POPSIZE; i++)
		{
			printf ("hs=%d  ",  population[i].fitness);
		}
	}

/*	fprintf(galog,"/n/n Simulation completed/n");
	fprintf(galog,"/n Best member: /n");
	
	for (i = 0; i < NVARS; i++)
	{
		fprintf (galog,"/n var(%d) = %3.3f",i,population[POPSIZE].gene[i]);
	}
	fprintf(galog,"/n/n Best fitness = %3.3f",population[POPSIZE].fitness);
	fclose(galog);*/

	cout << population[POPSIZE].fitness << endl;
	cout << "Success\n" <<endl;
}
/***************************************************************/

遗传算法是根据生物的进化发展的算法。
阮莎SN
关注
专栏目录
遗传算法（Genetic Algorithm）详解与实现
盼小辉丶的博客
12-25 16万+
遗传算法（Genetic Algorithm, GA）是受自然进化原理启发的一系列搜索算法。通过模仿自然选择和繁殖的过程，遗传算法可以为涉及搜索、优化和学习的各种问题提供高质量的解决方案。同时，它们类似于自然进化，因此遗传算法可以克服传统搜索和优化算法遇到的一些障碍，尤其是对于具有大量参数和复杂数学表示形式的问题。
遗传算法，简单又不简单
LANSHANZHUYAO的专栏
11-24 1078
遗传算法是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型，是一种通过模拟自然进化过程搜索最优解的方法。本文主要介绍了遗传算法的python实现过程，以加深对遗传算法的理解，并设计了两个实验展示了遗传算法的强大功力(#^.^#)。
遗传算法-交叉算子讲解
M-博客
03-04 3万+
用最简单直观的方法表达出交叉的过程
遗传算法求解带约束优化问题（源码实现）
总裁余（余登武）博客
04-13 2万+
遗传算法求解带约束优化问题（源码实现）。方法1：开始设计编码规则时，让解编码就只可能在可行区域内。方法2：设计合理的交叉算子和变异算子，使得满足这些算子本身的特性的前提下，还让算子运算后的染色体也在可行域内。方法3： 罚函数法。方法4：在变异/交叉之后加入一个判断语句，判断是否满足约束条件，如果不满足，有两个策略：超出边界的放到边界上。或者超出边界的，重新初始化。
使用Math.max和Math.min求数组的最大值和最小值
现在学习也不晚
04-24 2万+
正常情况下，如果我们求数组的值，用到的就是for循环，如果在代码中经常求最大值和最小值的话，会显得代码很乱。所以，就考虑一中最简单的方法求最大值。 使用Math里面自带的max和min方法 function getMaxOfArray(numArray) { return Math.max.apply(null, numArray); }直接调用一下上面的函数，就会返回数组中最大的值。
遗传算法详解 附python代码实现
热门推荐
ha_ha_ha233的博客
06-10 21万+
遗传算法 遗传算法是用于解决最优化问题的一种搜索算法。从名字来看，遗传算法借用了生物学里达尔文的进化理论：”适者生存，不适者淘汰“，将该理论以算法的形式表现出来就是遗传算法的过程。 问题引入 上面提到遗传算法是用来解决最优化问题的，下面我将以求二元函数： def F(x, y): return 3*(1-x)**2*np.exp(-(x**2)-(y+1)**2)- 10*(x/5 - x**3......
浅析遗传算法
gzxb1995的博客
04-06 8万+
使用遗传算法求解多峰函数的最大值，是我的一项课程作业，做完之后，顺便把文档整理出来做个记录。全部内容如下： 1、问题描述 编程实现遗传算法，并求解多峰函数的最大值。多峰函数的表达式如下所示： 用MATLAB做出函数的图像如下： 2、算法描述及实现 2.1、遗传算法概述 遗传算法(GA，Genetic Algorithm)，也称为进化算法。遗传算法是受达尔文的进化论的启发，借鉴生物进化过程而提出...
遗传算法原理及其matlab程序实现
红烧肉不好吃的博客
08-06 16万+
遗传算法原理及其matlab实现一、遗传算法背景二、遗传算法原理及其数学模型2.1 编码方式2.1.1 二进制编码2.1.2 浮点数编码2.2 种群初始化2.3 计算初始种群的适应度函数值2.4 对初始种群个体进行筛选（以轮盘赌方式进行选择）2.5 个体染色体交叉2.6 个体染色体变异2.7 精英选择及其作用三、遗传算法中关键参数的设定及作用3.1 不同编码方式的区别及其作用3.2 交叉算子3.3...
遗传算法详解
m0_46566693的博客
07-05 1209
遗传算法详解
量子遗传算法,量子遗传算法和遗传算法的区别,matlab
09-10
量子遗传算法（Quantum Genetic Algorithm, QGA）是一种结合了量子计算理论与传统遗传算法的优化方法，旨在解决复杂问题的全局寻优。在本文中，我们将深入探讨量子遗传算法的基本概念、工作原理以及它与传统遗传算法...
基于多层编码遗传算法的车间调度算法.rar_调度MATLAB_车间调度MATLAB_遗传算法 调度_遗传算法调度
07-14
《基于多层编码遗传算法的车间调度算法》 在现代工业生产中，车间调度问题是一项极其重要的优化任务，它涉及到如何有效地安排生产流程，以最小化成本、提高生产效率和满足交货日期等目标。本资源是关于使用MATLAB...
基于遗传算法的光学天线优化_matlab遗传算法_算法天线阵列_comsol遗传算法_comsol_comsolmatlab_源
09-10
本项目聚焦于使用遗传算法来优化光学天线阵列，结合MATLAB和COMSOL Multiphysics两个强大的工具进行实现。遗传算法是一种模拟自然选择和遗传学原理的全局优化方法，它通过模拟种群进化过程来寻找最优解。 首先，...
基于遗传算法的simulink/PID参数整定(s函数）
07-10
《基于遗传算法的Simulink/PID参数整定——深入解析与实践》 在现代控制系统设计中，PID（比例-积分-微分）控制器因其简单易用和良好的稳定性而广泛应用。然而，如何优化PID参数以获得最佳控制性能，是工程师们常常...
基于 YOLOv5（假设为 YOLOv11）的火灾火焰烟雾检测系统（包含详细的完整的程序和数据）
10-13
本文详细介绍了一个利用深度学习模型YOLOv5构建的火灾火焰烟雾检测系统的设计和实现方法，系统能够实时识别图像中的火灾隐患并通过PyQt5实现友好的GUI交互。内容涵盖环境配置、YOLOv5模型准备及其在ONNX中的运用、以及检测逻辑和性能评估等重要环节，提供了可用于智能化监控、公共安全保障的应用方案。 适合人群：有一定深度学习基础的研发人员、安全领域从业者和计算机视觉爱好者。 使用场景及目标：该系统适合作为企业级或公共场所内的智能消防安防设备的一部分，在发生火灾初期及时提醒管理人员采取措施。 该文章适用于想要深入了解YOLOv5在具体场景下如何部署的研究人员和技术团队成员查阅。同时也可作为学习YOLOv5在实时对象检测领域的教学案例。
crcmod-1.7-cp37-cp37m-win_amd64.whl
10-13
crcmod-1.7-cp37-cp37m-win_amd64.whl
python_geohash-0.8.5-cp36-cp36m-win_amd64.whl
最新发布
10-13
python_geohash-0.8.5-cp36-cp36m-win_amd64.whl
【图像加密解密】基于matlab分数傅里叶变换彩色图像加密【含Matlab源码 4543期】.md
10-13
CSDN Matlab武动乾坤上传的资料均有对应的代码，代码均可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博客文章底部QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 图像加密： DNA混沌图像加密、Arnold置乱图像加密解密、Logistic+Tent+Kent+Hent图像加密与解密、双随机相位编码光学图像加密解密 正交拉丁方置乱图像加密解密、RSA图像加密解密、小波变换DWT图像加密解密、混沌结合小波变换图像加密
基于YOLOv11的人脸表情检测系统（包含详细的完整的程序和数据）
10-13
本文档详细介绍了一套使用YOLOv11实现的人脸表情检测系统的开发方法和全流程实现，其中包括高精度检测、用户友好界面和实时处理等亮点特性。此外，系统还能有效识别八种常见的人类表情。它介绍了从前期环境准备到搭建最后的GUI用户交互界面等一系列步骤。 适用人群：从事计算机视觉研究或对深度学习感兴趣的研究员与软件开发者们。 使用场景及目标：对于想要实现高效精准的表情分析和智能人机对话的应用开发者来说十分有用，如游戏娱乐行业和社交平台等都可以使用此类系统。此外，还可以用作学术教学资源，帮助学生们更好地理解并动手实施这一领域中的项目。 其他说明：本文还讨论了一些潜在的发展趋势，旨在不断优化现有的解决方案同时引入新的情感类别以及考虑将此与音频情绪判断结合，使系统更为完善。
单亲遗传算法与传统遗传算法对比分析
"本文主要探讨了单亲遗传算法（PGA）与传统遗传算法（TGA）之间的差异，从编码方式、遗传算子、运行过程和适应度计算等多个方面进行了深入的比较分析。单亲遗传算法摒弃了传统遗传算法中的交叉算子，采用单亲繁殖...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值