细粒度模式下的GPU加速遗传算法

最新推荐文章于 2024-08-18 17:33:57 发布
最新推荐文章于 2024-08-18 17:33:57 发布
阅读量417 收藏
点赞数
文章标签： c++ 算法 oneapi
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43698456/article/details/130344057
版权

文章目录

函数主体部分

#define CL_TARGET_OPENCL_VERSION 120

#include <malloc.h>
#include <time.h>
#include <CL/cl.h>
#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <fstream>
#include <stdlib.h>
#include <iostream>
using namespace std;
//read a kernel file to a string
int convertToString(const char *filename, std::string& s);


const char* programSource=NULL;
void show_matrix(int* m,int dim1,int dim2,char* matrix_name);
void show_matrix_float(float* m,int dim1,int dim2,char* matrix_name);
void bubblesort(float *arr, int size)  
{  
    int i, j, tmp;  
    for (i = 0; i < size - 1; i++) {  
        for (j = 0; j < size - i - 1; j++) {  
            if (arr[j] < arr[j+1]) {  
                tmp = arr[j];  
                arr[j] = arr[j+1];  
                arr[j+1] = tmp;  
            }  
        }  
    }  
}
float max(float *arr,int size)
{
    bubblesort(arr,size);
    return arr[0];
}
void mut_vec(int *arr,int size,float pm)
{
    for(int i=0;i<size;i++)
    {
        float mut_p;
        mut_p=rand()%100*1.0/100;
        if(mut_p<pm)
        {
            arr[i]=rand()%3-1;
        }
    }
}
void get_cross_rates(float *arr,int size)
{
    // 随机初始化等位基因交叉概率组
    for (int i = 0; i < size; i++) 
		arr[i] = rand()%10*1.0/10;
}
int* get_best_individual(int* population,int pop_num,int code_len,float* fitness,float best_fitness)
{
    int* best_indi;
    best_indi=(int*)malloc(sizeof(int)*code_len);
    for(int i=0;i<pop_num;i++)
    {
        if (fitness[i]==best_fitness)
        {
            for(int j=0;j<code_len;j++)
            {
                best_indi[j]=population[i*code_len+j];
            }
            return best_indi;
        }
    }
}
int main() {
	// This code executes on the OpenCL host
	// Host data
	int *population = NULL;  // Input array
    int *population_original=NULL;
	int *p1s = NULL;  // 种群中挑选的父代
	int *p2s = NULL;  // Output array
    int *children1=NULL;
    int *children2=NULL;
    int *population_extend=NULL;//作为中间种群状态存储父代与子代共同构成的种群
    int *mutation_vector=NULL;
    float *fitness=NULL;
    float* fitness_sorted;
    const int pop_num=5000;//种群大小
    const int p_num=pop_num/2;//单类父代个体数
    const int pop_ex_num=2*pop_num;
    const int code_len=20;//个体编码长度
    const float pc=0.6;//等位基因交叉概率
    const float pm=0.1;//等位基因变异概率
    const int evol_num=100;//进化代数
    float *cross_rates=NULL;
    int *best_p=NULL;
    //size of populations
    const int size_pop = pop_num*code_len;
    const int size_pop_ex=2*size_pop;
    const int size_p=pop_num/2*code_len;

    // 为种群分配内存
	// Allocate space for input/output data
    population = (int*)malloc(sizeof(int)*size_pop);  // 
    population_original = (int*)malloc(sizeof(int)*size_pop);  // 
    population_extend = (int*)malloc(sizeof(int)*size_pop_ex);  // 
	p1s = (int*)malloc(sizeof(int)*size_p);  // 
	p2s = (int*)malloc(sizeof(int)*size_p);  // 
    children1=(int*)malloc(sizeof(int)*size_p);
    children2=(int*)malloc(sizeof(int)*size_p);
    best_p=(int*)malloc(sizeof(int)*code_len);
    mutation_vector=(int*)malloc(sizeof(int)*code_len);
    cross_rates=(float*)malloc(sizeof(float)*code_len);
    fitness=(float*)malloc(sizeof(float)*(pop_num+p_num*2));
    fitness_sorted=(float*)malloc(sizeof(float)*pop_num*2);
    // 随机初始化种群
    srand((unsigned)time(NULL));//随机数播种
	int i;
	for (i = 0; i < size_pop; i++) 
    {
		population[i] = rand()%10;//编码值于0-9之间
        population_original[i]=population[i];
    }
    // 初始化两父代群
	p1s=population;// 将两个父代的指针指向种群的起始和中点。
	p2s=population+size_pop/2;
    // 随机初始化一个最优值
    for (i = 0; i < code_len; i++) 
		best_p[i] = rand()%10;
    printf("finish initiate!!!\n");
    /*********************data show***********************/
    //show_matrix(population,pop_num,code_len,"population");
    //show_matrix(population_extend,pop_num+p_num+p_num,code_len,"population_extend");
    //show_matrix_float(cross_rates,code_len,1,"cross_rates");
/************************八股文部分*******************/
	// Use this to check the output of each API call
    // 保存各函数返回值的状态
	cl_int status;
	// 获取平台信息
	cl_uint numPlatforms = 0;
    // 查询可用的平台个数
	status = clGetPlatformIDs(0, NULL, &numPlatforms);
	// Allocate enough space for each platform
	cl_platform_id *platforms = NULL;
    // 分配内存
	platforms = (cl_platform_id*)malloc(numPlatforms * sizeof(cl_platform_id));
	// Fill in the platforms
    // 得到可用的OpenCL列表
	status = clGetPlatformIDs(numPlatforms, platforms, NULL);
	// 获取设备信息
	cl_uint numDevices = 0;
    // 查询设备数量 OpenCL设备
	status = clGetDeviceIDs(platforms[0], CL_DEVICE_TYPE_ALL, 0, NULL, &numDevices);
	// Allocate enough space for each device
	cl_device_id *devices;
    // 设备分配内存
	devices = (cl_device_id*)malloc(numDevices * sizeof(cl_device_id));
	// Fill in the devices 
    // 得到与platform关联的可用的OpenCL设备
	status = clGetDeviceIDs(platforms[0], CL_DEVICE_TYPE_ALL, numDevices, devices, NULL);
	// 创建上下文信息
	cl_context context;
	context = clCreateContext(NULL, numDevices, devices, NULL, NULL, &status);
	// 创建命令队列
	cl_command_queue cmdQueue;
    // 指定上下文与设备创建
	cmdQueue = clCreateCommandQueue(context, devices[0], 0, &status);
/****************八股文暂时结束****************/
    
    
	// 创建数据内存  内存对象  buffer
	// Create a buffer object that will contain the data from the host array A B C
    cl_mem buf_population;  // 种群
    cl_mem buf_p1s;
    cl_mem buf_p2s;    
    cl_mem buf_population_extend;  // 种群过渡态
    cl_mem buf_children1;
    cl_mem buf_children2;
    cl_mem buf_cross_rates;
    cl_mem buf_best_p;
    cl_mem buf_fitness;
    cl_mem buf_fitness_sorted;
    cl_mem buf_mutation_vector;
	buf_population = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(int)*size_pop,NULL, &status);// 可读写
	buf_p1s = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(int)*size_pop/2,NULL, &status);// 可读写
	buf_p2s = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(int)*size_pop/2,NULL, &status);// 可读写
	buf_population_extend = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(int)*size_pop_ex,NULL, &status);// 可读写
    buf_children1 = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(int)*size_pop/2,NULL, &status);// 可读写
    buf_children2 = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(int)*size_pop/2,NULL, &status);// 可读写
    buf_fitness = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(float)*pop_num*2,NULL, &status);// 可读写
    buf_fitness_sorted = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(float)*pop_num*2,NULL, &status);// 可读写
    buf_mutation_vector = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(float)*code_len,NULL, &status);// 可读写
    buf_best_p = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(int)*code_len,NULL, &status);// 只读
    buf_cross_rates = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(float)*code_len,NULL, &status);// 只读
    
   // 主机端内存数据传入到OpenCL buffer中
    //将种群放到OpenCL的buffer中。
	status = clEnqueueWriteBuffer(cmdQueue, buf_population, CL_FALSE,0, sizeof(int)*size_pop, population, 0, NULL, NULL);
	status = clEnqueueWriteBuffer(cmdQueue, buf_p1s, CL_FALSE,0, sizeof(int)*size_pop/2, p1s, 0, NULL, NULL);
	status = clEnqueueWriteBuffer(cmdQueue, buf_p2s, CL_FALSE,0, sizeof(int)*size_pop/2, p2s, 0, NULL, NULL);
	status = clEnqueueWriteBuffer(cmdQueue, buf_cross_rates, CL_FALSE,0, sizeof(float)*code_len, cross_rates, 0, NULL, NULL);
	status = clEnqueueWriteBuffer(cmdQueue, buf_best_p, CL_FALSE,0, sizeof(int)*code_len, best_p, 0, NULL, NULL);
    
	// 创建CL程序
    // read the kernel funtion
    const char* crossover_fun_str=NULL;//可改写指针但是不能改写指针指向的内容
    const char* pop_merge_fun_str=NULL;//可改写指针但是不能改写指针指向的内容
    const char* fitness_fun_str=NULL;//可改写指针但是不能改写指针指向的内容
    const char* pop_produce_fun_str=NULL;//可改写指针但是不能改写指针指向的内容
    const char* mutation_fun_str=NULL;//可改写指针但是不能改写指针指向的内容
    std::string sourcestr;
    std::string sourcestr_pop;
    std::string sourcestr_fit;
    std::string sourcestr_pop_produce;
    std::string sourcestr_mutation;
    convertToString("crossover.cl", sourcestr);
    crossover_fun_str = sourcestr.c_str();
    convertToString("pop_merge.cl", sourcestr_pop);
    pop_merge_fun_str = sourcestr_pop.c_str();
    convertToString("fitness.cl", sourcestr_fit);
    fitness_fun_str = sourcestr_fit.c_str();
    convertToString("pop_produce.cl", sourcestr_pop_produce);
    pop_produce_fun_str = sourcestr_pop_produce.c_str();
    convertToString("mutation.cl", sourcestr_mutation);
    mutation_fun_str = sourcestr_mutation.c_str();
   // 利用核函数(crossover,pop_merge)代码串，创建一个OpenCL程序对象
	cl_program program_crossover = clCreateProgramWithSource(context, 1,(const char**)&crossover_fun_str, NULL, &status);
	cl_program program_pop_merge = clCreateProgramWithSource(context, 1,(const char**)&pop_merge_fun_str, NULL, &status);
	cl_program program_fitness = clCreateProgramWithSource(context, 1,(const char**)&fitness_fun_str, NULL, &status);
	cl_program program_pop_produce = clCreateProgramWithSource(context, 1,(const char**)&pop_produce_fun_str, NULL, &status);
	cl_program program_mutation = clCreateProgramWithSource(context, 1,(const char**)&mutation_fun_str, NULL, &status);
	// 编译CL程序(交叉操作核函数）
	// Build (compile) the program for the device
	status = clBuildProgram(program_crossover, numDevices, devices,NULL, NULL, NULL);
	status = clBuildProgram(program_pop_merge, numDevices, devices,NULL, NULL, NULL);
	status = clBuildProgram(program_fitness, numDevices, devices,NULL, NULL, NULL);
	status = clBuildProgram(program_pop_produce, numDevices, devices,NULL, NULL, NULL);
	status = clBuildProgram(program_mutation, numDevices, devices,NULL, NULL, NULL);
	// 创建CL内核
	// Create the vector addition kernel
	cl_kernel kernel_crossover;
	kernel_crossover = clCreateKernel(program_crossover, "crossover", &status);
    cl_kernel kernel_pop_merge;
	kernel_pop_merge = clCreateKernel(program_pop_merge, "pop_merge", &status);
    cl_kernel kernel_fitness;
	kernel_fitness = clCreateKernel(program_fitness, "fitness", &status);
    cl_kernel kernel_pop_produce;
	kernel_pop_produce = clCreateKernel(program_pop_produce, "pop_produce", &status);
    cl_kernel kernel_mutation;
	kernel_mutation = clCreateKernel(program_mutation, "mutation", &status);
    
    
/******************八股文开始*************************/
    // Define an index space (global work size) of work 
	// items for execution. A workgroup size (local work size) 
	// is not required, but can be used.
	size_t globalWorkSize[1];
    // work items in each dimension
	globalWorkSize[0] = pop_num*2;
	// 计算，执行kernel
    size_t global[2];
/******************八股文结束*************************/
    
    
/****************函数参数初始化***************************/
	// crossover传参
    status = clSetKernelArg(kernel_crossover, 0, sizeof(int), &p_num);
    status = clSetKernelArg(kernel_crossover, 1, sizeof(int), &code_len);
    status = clSetKernelArg(kernel_crossover, 2, sizeof(float), &pc);
    status = clSetKernelArg(kernel_crossover, 3, sizeof(cl_mem), &buf_cross_rates); 
    status = clSetKernelArg(kernel_crossover, 4, sizeof(cl_mem), &buf_p1s);
    status = clSetKernelArg(kernel_crossover, 5, sizeof(cl_mem), &buf_p2s);
    status = clSetKernelArg(kernel_crossover, 6, sizeof(cl_mem), &buf_children1);
    status = clSetKernelArg(kernel_crossover, 7, sizeof(cl_mem), &buf_children2);
	// mutation 传参
    status = clSetKernelArg(kernel_mutation, 0, sizeof(int), &pop_num);
    status = clSetKernelArg(kernel_mutation, 1, sizeof(int), &code_len);
    status = clSetKernelArg(kernel_mutation, 2, sizeof(cl_mem), &buf_mutation_vector);
    status = clSetKernelArg(kernel_mutation, 3, sizeof(cl_mem), &buf_population_extend);
    //pop_merge传参
    status = clSetKernelArg(kernel_pop_merge, 0, sizeof(int), &p_num);
    status = clSetKernelArg(kernel_pop_merge, 1, sizeof(int), &pop_num);
    status = clSetKernelArg(kernel_pop_merge, 2, sizeof(int), &code_len);
    status = clSetKernelArg(kernel_pop_merge, 3, sizeof(cl_mem), &buf_population_extend); 
    status = clSetKernelArg(kernel_pop_merge, 4, sizeof(cl_mem), &buf_population);
    status = clSetKernelArg(kernel_pop_merge, 5, sizeof(cl_mem), &buf_children1);
    status = clSetKernelArg(kernel_pop_merge, 6, sizeof(cl_mem), &buf_children2);
    //fitness 传参
    status = clSetKernelArg(kernel_fitness, 0, sizeof(int), &pop_num);
    status = clSetKernelArg(kernel_fitness, 1, sizeof(int), &code_len);
    status = clSetKernelArg(kernel_fitness, 2, sizeof(cl_mem), &buf_best_p);
    status = clSetKernelArg(kernel_fitness, 3, sizeof(cl_mem), &buf_population_extend); 
    status = clSetKernelArg(kernel_fitness, 4, sizeof(cl_mem), &buf_fitness);
    //pop_produce 传参
    status = clSetKernelArg(kernel_pop_produce, 0, sizeof(int), &pop_num);
    status = clSetKernelArg(kernel_pop_produce, 1, sizeof(int), &code_len);
    status = clSetKernelArg(kernel_pop_produce, 2, sizeof(cl_mem), &buf_fitness_sorted);
    status = clSetKernelArg(kernel_pop_produce, 3, sizeof(cl_mem), &buf_population_extend); 
    status = clSetKernelArg(kernel_pop_produce, 4, sizeof(cl_mem), &buf_population);
    status = clSetKernelArg(kernel_pop_produce, 5, sizeof(cl_mem), &buf_fitness);
    // 执行crossover核函数                                 workdim
	status = clEnqueueNDRangeKernel(cmdQueue, kernel_crossover, 1, NULL,globalWorkSize, NULL, 0, NULL, NULL);
    mut_vec(mutation_vector,code_len,pm); //生成变异向量
	status = clEnqueueWriteBuffer(cmdQueue, buf_mutation_vector, CL_FALSE,0, sizeof(int)*code_len, mutation_vector, 0, NULL, NULL);    //mutation vector 放入gpu
    // 执行crossover核函数                                 workdim
	status = clEnqueueNDRangeKernel(cmdQueue, kernel_mutation, 1, NULL,globalWorkSize, NULL, 0, NULL, NULL);
    // 执行pop_merge 核函数                                workdim
	status = clEnqueueNDRangeKernel(cmdQueue, kernel_pop_merge, 1, NULL,globalWorkSize, NULL, 0, NULL, NULL);
    // 执行fitness 核函数                                workdim
	status = clEnqueueNDRangeKernel(cmdQueue, kernel_fitness, 1, NULL,globalWorkSize, NULL, 0, NULL, NULL);
	clEnqueueReadBuffer(cmdQueue, buf_fitness, CL_TRUE, 0,sizeof(int)*pop_num*2, fitness, 0, NULL, NULL);    //fitness读出
    for(int i=0;i<pop_num*2;i++)
        fitness_sorted[i]=fitness[i];
    //适应度值排序
    bubblesort(fitness_sorted,pop_num*2);
    //将fitness sorted传入gpu
	status = clEnqueueWriteBuffer(cmdQueue, buf_fitness_sorted, CL_FALSE,0, sizeof(int)*pop_num*2, fitness_sorted, 0, NULL, NULL);
    // 执行 pop_produce 核函数                                workdim
	status = clEnqueueNDRangeKernel(cmdQueue, kernel_pop_produce, 1, NULL,globalWorkSize, NULL, 0, NULL, NULL);
    //读取新产生的pop
	clEnqueueReadBuffer(cmdQueue, buf_population, CL_TRUE, 0,sizeof(int)*size_pop, population, 0, NULL, NULL);
//     show_matrix(population,pop_num,code_len,"population new");
    
/************************************遗传优化********************************************/
    time_t start,end;
    start=time(NULL);
    float best_fit;
    float origin_best_fit;
    for(int g=0;g<evol_num;g++)
    {
        /***************crossover*****************/
        get_cross_rates(cross_rates,code_len);//随机初始化交叉向量
        //show_matrix_float(cross_rates,1,code_len,"cross Rates");
        status = clEnqueueWriteBuffer(cmdQueue, buf_cross_rates, CL_FALSE,0, sizeof(int)*code_len, cross_rates, 0, NULL, NULL); //将crossrates放入gpu
        status = clEnqueueNDRangeKernel(cmdQueue, kernel_crossover, 1, NULL,globalWorkSize, NULL, 0, NULL, NULL);
        mut_vec(mutation_vector,code_len,pm); //生成变异向量
        status = clEnqueueWriteBuffer(cmdQueue, buf_mutation_vector, CL_FALSE,0, sizeof(int)*code_len, mutation_vector, 0, NULL, NULL);    //mutation vector 放入gpu
        /***************mutation*****************/                                       
        status = clEnqueueNDRangeKernel(cmdQueue, kernel_mutation, 1, NULL,globalWorkSize, NULL, 0, NULL, NULL);
        /***************population merge*****************/                                     
        status = clEnqueueNDRangeKernel(cmdQueue, kernel_pop_merge, 1, NULL,globalWorkSize, NULL, 0, NULL, NULL);
        /**********************fitness*****************/                                 
        status = clEnqueueNDRangeKernel(cmdQueue, kernel_fitness, 1, NULL,globalWorkSize, NULL, 0, NULL, NULL);
        clEnqueueReadBuffer(cmdQueue, buf_fitness, CL_TRUE, 0,sizeof(int)*pop_num*2, fitness, 0, NULL, NULL);    //fitness读出
        if(g==0)
            origin_best_fit=max(fitness,pop_num*2);
        for(int i=0;i<pop_num*2;i++)
            fitness_sorted[i]=fitness[i];
        //适应度值排序
        bubblesort(fitness_sorted,pop_num*2);
        //将fitness sorted传入gpu
        status = clEnqueueWriteBuffer(cmdQueue, buf_fitness_sorted, CL_FALSE,0, sizeof(int)*pop_num*2, fitness_sorted, 0, NULL, NULL);
        /***************population produce*****************/        
        status = clEnqueueNDRangeKernel(cmdQueue, kernel_pop_produce, 1, NULL,globalWorkSize, NULL, 0, NULL, NULL);
        //读取新产生的pop
        clEnqueueReadBuffer(cmdQueue, buf_population, CL_TRUE, 0,sizeof(int)*size_pop, population, 0, NULL, NULL);
        /*******************优化过程监视**************/
        clEnqueueReadBuffer(cmdQueue, buf_fitness, CL_TRUE, 0,sizeof(int)*pop_num*2, fitness, 0, NULL, NULL); 
        bubblesort(fitness,pop_num*2);
         //show_matrix_float(fitness,pop_num*2,1,"fitness");
        best_fit=max(fitness,pop_num*2);
        printf("%d generation:best fitness:%f\n",g,best_fit);
        if(best_fit==4)
            break;
    }
    end=time(NULL);
    printf("time cost：%ld  s\n",end-start);
    // 读取结果，从OpenCL buffer读入主机端内存中
	// Read the device output buffer to the host output array
	clEnqueueReadBuffer(cmdQueue, buf_children1, CL_TRUE, 0,
		sizeof(int)*size_pop/2, children1, 0, NULL, NULL);
	clEnqueueReadBuffer(cmdQueue, buf_children2, CL_TRUE, 0,
		sizeof(int)*size_pop/2, children2, 0, NULL, NULL);
	clEnqueueReadBuffer(cmdQueue, buf_population_extend, CL_TRUE, 0,
		sizeof(int)*size_pop*2, population_extend, 0, NULL, NULL);

	int result = 1;
    int* best_one=get_best_individual(population,pop_num,code_len,fitness,best_fit);
//     show_matrix(best_one,1,code_len,"best one searched");
//     show_matrix(best_p,1,code_len,"global best");
    printf("The best fitness of original population:%f\n",origin_best_fit);
    printf("The best fitness of final population:%f\n",best_fit);
    

	// Free OpenCL resources
	clReleaseKernel(kernel_crossover);
	clReleaseProgram(program_crossover);
	clReleaseCommandQueue(cmdQueue);
	clReleaseMemObject(buf_population);
	clReleaseMemObject(buf_population_extend);
	clReleaseMemObject(buf_children1);
	clReleaseMemObject(buf_children2);
    clReleaseMemObject(buf_best_p);
	clReleaseContext(context);
                   
	// Free host resources
	free(population);
	free(population_extend);
	free(children1);
	free(children2);
	free(cross_rates);
	free(best_p);
	free(platforms);
	free(devices);

	return 0;
}

int convertToString(const char *filename, std::string& s)
{// s is the string to store the kernel function
    size_t size;
    char* str;
    std::fstream f(filename, (std::fstream::in | std::fstream::binary));
    if (f.is_open())
    {
        size_t fileSize;
        f.seekg(0, std::fstream::end);
        size = fileSize = (size_t)f.tellg();
        f.seekg(0, std::fstream::beg);
        str = new char[size + 1];
        if (!str)
        {
            f.close();
            return 0;
        }
        f.read(str, fileSize);
        f.close();
        str[size] = '\0';
        s = str;
        delete[] str;
        return 0;
    }
    printf("Error: Failed to open file %s\n", filename);
    return 1;
}
void show_matrix(int* m,int dim1,int dim2,char* matrix_name)
{
    printf("matrix name is :%s \n",matrix_name);
    for (int i = 0; i < dim1; i++) {
        for (int j=0;j< dim2;j++)
            printf("%d ",m[i*dim2+j]);
        printf("\n");
	}
}
void show_matrix_float(float* m,int dim1,int dim2,char* matrix_name)
{
    printf("matrix name is :%s \n",matrix_name);
    for (int i = 0; i < dim1; i++) {
        for (int j=0;j< dim2;j++)
            printf("%.3f ",m[i*dim2+j]);
        printf("\n");
	}
}

交叉操作核函数

__kernel void crossover(
    const int p_num,
    const int individual_len,
    const float pc,
    __global float* cross_rates,
    __global int* p1s,
    __global int* p2s, 
    __global int* children1,
    __global int* children2)
{
    int i = get_global_id(0);
    int k;
    
    if (i < p_num) {
        for(int j=0;j<individual_len;j++)
        {
            if(cross_rates[j]>pc)//概率大于pc则获取父代1的基因
            {
                children1[i*individual_len+j]=p1s[i*individual_len+j];
                children2[i*individual_len+j]=p2s[i*individual_len+j];
            }
            else
            {
                children1[i*individual_len+j]=p2s[i*individual_len+j];
                children2[i*individual_len+j]=p1s[i*individual_len+j];
            }
        }
    }
}

变异操作核函数

__kernel void mutation(
            const int pop_num,    
            const int code_len,
            __global int* mutation_vector,
            __global int* population_extend)
{
    int i = get_global_id(0);
    if(i<pop_num*2)
    {
        for(int j=0;j<code_len;j++)
        {
            population_extend[i*code_len+j]+=mutation_vector[j];
        }
        
    }
}

选择操作核函数

__kernel void pop_produce(
    const int pop_num,
    const int code_len,
    __global float* fitness_sorted,
    __global int* population_extend,
    __global int* population,
    __global float* fitness)
{
    int i = get_global_id(0);
    if (i < pop_num) 
    {
       for(int j=0;j<pop_num*2;j++)
        {
            if(fitness_sorted[i]==fitness[j])
            {
                for(int k=0;k<code_len;k++)
                {
                    population[i*code_len+k]=population_extend[j*code_len+k];
                }
            }
        }
    }
}
。，。，。，。。，。。，
关注
YOLO的全面综述：从YOLOv1到最新版本
AI浩
12-07 6645
YOLO已成为机器人、无人驾驶汽车和视频监控应用的核心实时目标检测系统。我们全面分析了YOLO的演变，研究了从原始YOLO到YOLOv8、YOLO-NAS和带有Transformer的YOLO的每次迭代的创新和贡献。我们首先描述了标准指标和后处理；然后，我们讨论了每个模型在网络架构和训练技巧方面的主要变化。最后，我们总结了YOLO开发的重要经验教训，并对其未来提出了看法，强调了增强实时目标检测系统的潜在研究方向。关键词YOLO·目标检测·深度学习·计算机视觉。
【人工智能】国产开源大模型 baichuan-7B 百川聊天 BaiChat 快速开始上手实战&效果实测 —— 希望 baichuan-7B 再打磨打磨吧
热门推荐
AI天才研究院
06-16 1万+
baichuan-7B 是由百川智能开发的一个开源可商用的大规模预训练语言模型。基于 Transformer 结构，在大约1.2万亿 tokens 上训练的70亿参数模型，支持中英双语，上下文窗口长度为4096。在标准的中文和英文权威 benchmark（C-EVAL/MMLU）上均取得同尺寸最好的效果。
基于GPU的并行遗传算法
11-28
使用GPU并行化遗传算法，并行方式为粗粒度式并行，开发环境为ubuntu16.04;最终计算结果相比于传统的遗传算法，在结果精度差不多的情况下，时间约为传统方法的五分之一
加速遗传算法
05-14
自己写的一个加速遗传算法的MATLAB的程序
【优化算法】遗传算法及加速遗传算法（超详细更新中）
最新发布
2301_79897844的博客
08-18 1630
例如，在调度问题中，可能基于任务的优先级生成一定结构的解。在浮点数编码方法中，必须保证基因值在给定的区间限制范围内，遗传算法中使用的遗传算子也必须保证其运算结果所产生的新个体的基因值也在该区间限制范围内。）一位代表两种状态的信息量，因此对于复杂信息来说，足够长的序列才能更好的传达信息，造成麻烦。对于连续函数的搜索问题，其随机性也使其搜索能力较差，当迫近最优解时由于其变异后表现型变化很大，不连续，所以会远离最优解，达不到稳定。在遗传算法中，用来评价解的优劣程度的数学函数，称为个体的适应度函数。
加速遗传算法 matlab,求加速遗传算法，不是自适应遗传算法
weixin_32792909的博客
03-18 1255
就是用第一次、第二次进化迭代所产生的优秀个体的变量变化空间, 作为变量新的初始变化区间, 算法进入步 1, 重新运行 SGA ,如此加速循环, 直到最优个体的优化准则函数值小于某一设定值或算法运行达到预定加速循环次数, 结束整个算法的运行Ζ 此时就把当前群体中最佳个体或某个优秀个体指定为 AGA 的结果，以上 8 步构成AGA来自金菊良的《标准遗传算法的改进方案——加速遗传算法》我主要想将ga改写...
GeneticAlgorithmTSP_CUDA:使用CUDA架构（GPU）的遗传算法，为TSP（旅行商问题）找到最佳解决方案
05-14
遗传算法TSP_CUDA 一种遗传算法，可使用CUDA体系结构（GPU）为TSP（旅行商问题）找到最佳解决方案。 这是我在USF进行的并行和分布式处理课程的最后一个项目，与Berkeley在2015年Spring发布的“并行计算机的应用程序”一起完成的。该项目的目的是使自己熟悉遗传算法的设计和实现，重点是学习如何在CUDA架构以及C ++的OpenMP库上编写并行代码。 概述： 该项目将在德克萨斯大学奥斯汀分校的Stampede.tacc超级计算机上运行。 该代码在踩踏群集的单个节点上运行，此刻使用Nvidia的CUDA调用单个GPU。 在CUDA中，执行内核（GPU功能），并由块和线程组成。 每个块最多可以有1024个线程，每个内核可以有〜65000个块。 我设计了一种算法，以便在每个GPU上创建一个填充，该填充由启动内核的NTHREADS * NBLOCKS组成。 例如，在一个流行
AGA自适应加速遗传算法
02-11
AGA自适应加速遗传算法，适用于机器学习算法中AGA自适应加速遗传算法，适用于机器学习算法AGA自适应加速遗传算法，适用于机器学习算法
"FastZ：GPU加速的全基因组比对
FastZ：在GPU上加速有缺口的全基因组比对Sree Charan Gundabolu普渡大学美国印第安纳州西拉斐特sgundabo@...不幸的是，使用动态编程（DP）的高灵敏度"我们开发了FastZ，一个GPU加速的，有间隙的WGA软件，在灵敏度上与有
基于启发式遗传算法的神经网络结构搜索方法
1EIGEN：一种基于启发式遗传算法的神经网络结构搜索方法任健1，李哲2，杨建超3，徐宁4，杨天宝2，王伟。Foran11罗格斯大学2爱荷华大学3字节跳动AI实验室4亚马逊Go摘要设计神经网络的结构被认为是深度学习中最具挑战...
【MATLAB并行计算速成】：动态系统仿真加速的关键技术
MATLAB并行计算是利用多个计算资源（如CPU核心、GPU加速器、分布式计算机集群）来解决大规模问题的一种计算技术。它通过同时执行多个计算任务来缩短计算时间，提高工作效率。对于需要大量数值计算的动态系统仿真领域...
基于加速遗传算法的投影寻踪聚类模型
08-27
内容含加速遗传算法及基于遗传算法的投影寻踪聚类模型，程序有详细注释，方便操作 内容含加速遗传算法及基于遗传算法的投影寻踪聚类模型，程序有详细注释，方便操作
改进的实码加速遗传算法 (2005年)
05-21
对实码加速遗传算法(RAGA)8个步骤的局部参数进行修改，再对最后一次加速收缩后的区间用标准遗传算法(SGA)进行精细搜索。经过实例证明，改进后的算法计算机运行的次数减少，并且精度也得到提高。另外，对加速后的区间产生偏向最优点一侧的概率做了理论上的探讨，提出了把区间端点值重新赋给2个个体参加下一轮搜索。这样处理后避免舍去上次搜索的最优值，在一定程度上避免了某个变量的搜索区间在最优值一侧发生偏移。
matlab代码提供加速遗传算法投影寻踪模型 基于实数编码的加速遗传算法求解投影寻踪模
ky路上的博客
05-05 506
matlab代码提供加速遗传算法投影寻踪模型基于实数编码的加速遗传算法求解投影寻。多小时出结果，因为运行量太大，企业面板可能要等半天出结果，这都是正常现象。亲测，省级面板很快出结果，地级市面板要等1个。⚠️用于综合评价指标体系的测算，摆脱写论文只会。⚠️有案例和操作步骤，手把手教你怎么操作。讲解非常详细，参数设置说得很清楚。用熵值法、主成分分析法等的困扰。踪模型Matlab代码。
一个GPU版本的遗传算法迭代xgboost最优参数的示例，这里用的是自定义损失函数
weixin_43069769的博客
11-26 772
## 混合打乱数据# for i in tqdm(range(20),desc="随机打乱数据"):gamma = 0### 自动计算alpha值的取值范围 取负例的比例, "n_estimators":int(w2)#11 #即基评估器的数量。这个参数对随机森林模型的精确性影响是单调的，n_estimators越 大，模型的效果往往越好。
遗传算法（Genetic Algorithm, GA）哪些步骤该丢给GPU
琼楼玉宇
05-25 457
在遗传算法中，种群中的每个个体代表问题的一个候选解，通过迭代选择、交叉和变异操作，来模拟自然选择和遗传过程，从而找到最优或近似最优解。使用GPU加速遗传算法时，需要考虑数据传输 overhead、GPU内存限制以及计算任务的并行度。在这些步骤中，适应度评价、选择、交叉和变异操作通常是并行化的，尤其是在处理大型种群或复杂问题时。因此，这些步骤适合使用GPU进行加速计算。然而，遗传算法中的某些步骤，如确定何时终止算法或如何调整算法参数，可能需要串行处理，因为它们涉及对整个种群的总体评估和决策。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值