ga_server.c

一个不错的GA-NN的神经网络模型的示范代码。适合入门学习

/* Verification before next generation */
/***************************************/
get_fitness(poblation, base, boost, num_neuron, error, fitness);
for (k=0 ; k< poblation; k++)
{
	sprintf(char_buffer,"client_number=%d num_neuron=%d error=%f fitness=%f",
									k,num_neuron[k],error[k],fitness[k]);
	syslog(LOG_INFO,char_buffer);
	if (error[k] <= level)
	{
		exit_flag=1;
	}
} 

if (exit_flag)
{
	for (k=0; k< poblation; k++)
	{
		sprintf(char_buffer,"Exiting");
		writen(connfd[k],char_buffer,BUFFSIZE);
	}
	syslog(LOG_INFO,"Exiting generation %d level %1.6f",gen,level);
	break;
}

if (gen == generations - 1)
{
	for (k=0; k< poblation; k++)
	{
		sprintf(char_buffer,"All work done client=%d",k);
		writen(connfd[k],char_buffer,BUFFSIZE);
	}
	syslog(LOG_INFO,"Last generation");
	break;
}

/*** Updating for Local NICHE SERVER HERE ***/

if (ga_conf.num_niche > 0)
{
	/*** Sending Signal to local Niche ***/
	/* Ten retries, with 10 sec increase in timeout */

	max_fd = connfd_niche + 1;
	k=0;
	while (k < 10)
	{
		if (gen > 0)
		{
			syslog(LOG_INFO,"NICHE SERVER reload of data pid=%d",pid_temp);
			if (kill(pid_temp, SIGUSR1) < 0)
			{
				syslog(LOG_CRIT,"Error Sending signal to NICHE SERVER %s",strerror(errno));
				return(1);
			}
			syslog(LOG_INFO,"SIGUSR1 sent to NICHE SERVER pid=%d",pid_temp);
		}
		else
		{
			syslog(LOG_INFO,"NICHE SERVER First Load pid=%d",pid_temp);
		}

		timeout.tv_sec=(k+1)*10;
		timeout.tv_nsec=0;

		FD_ZERO(&read_set);
		FD_ZERO(&write_set);
		FD_ZERO(&ex_set);
		FD_SET(connfd_niche, &write_set);
		
		syslog(LOG_INFO,"Waiting for writting to niche_fifo");
		if ( (ready_fd=pselect(max_fd, &read_set, &write_set, &ex_set, &timeout, NULL)) <0 )
		{
			syslog(LOG_CRIT,"Error in pselect in local NICHE SERVER: %s",strerror(errno));
			return(1);
		}
		if (ready_fd == 0)
		{
			k += 1;
			syslog(LOG_INFO,"Retry number %d gen %d for local niche data",k,gen);
		}
		else 
		{
			if (FD_ISSET(connfd_niche, &write_set) )
			{
				for (l=0; l< poblation; l++)
				{
					dwrite_neuron_array(num_neuron[l],net_array[l]->neuron_array,connfd_niche);
				}
				break; //After writting, break
			}
		}	
	}
	if (k == 10)
	{
		syslog(LOG_CRIT,"Couldn't update Local Niche data");
		return(1);
	}	
}



/************ Cross ****************/
/***********************************/

if ( (mate(poblation,parents,fitness))<0)
{
	syslog(LOG_CRIT,"Error in cross function");
	return(1);
}

sprintf(char_buffer,"Parents: ");
for (k=0; k<poblation; k++)
{
		sprintf(char_temp,"%d:%d ",parents[k][0],parents[k][1]);
		strcat(char_buffer,char_temp);
}
syslog(LOG_INFO,char_buffer);



parent1 = NULL;
parent2 = NULL;
for (k=0; k < poblation; k++)
{

	/*** Randomize ***/
	if (!toss(mut_new_prob,k) ) //1:normal 0:new neuron_array for client
	{
		/***** First free already asigned memory !!! *******/
		/***************************************************/	

		if( !(parent1 = (struct neuron **)copy_neuron_array(num_neuron[parents[k][0]],
										net_array[parents[k][0]]->neuron_array, parent1)) )
		{
			syslog(LOG_CRIT,"Error in copy to parent1 %d",k);
			return(1);
		}										
		if( !(parent2 = (struct neuron **)copy_neuron_array(num_neuron[parents[k][1]],
										net_array[parents[k][1]]->neuron_array, parent2)) )
		{
			syslog(LOG_CRIT,"Error in copy to parent2 %d",k);
			return(1);
		}

		if ( !(inner_elem1 = (int *)realloc(inner_elem1,num_neuron[parents[k][0]]*sizeof(int)) ))
		{
			syslog(LOG_CRIT,"Error in realloc inner_elem1");
			return(1);
		}
		if ( !(inner_elem2 = (int *)realloc(inner_elem2,num_neuron[parents[k][1]]*sizeof(int)) ))
		{
			syslog(LOG_CRIT,"Error in realloc inner_elem2");
			return(1);
		}

		/********* Selection of neurons ***********/	
		region_gen(vertice);
		if ( inner_neuron(num_neuron[parents[k][0]], parent1, vertice, inner_elem1) < 0)
		{
			syslog(LOG_CRIT,"Error in inner_neuron1: %s",strerror(errno));
			return(3);
		}
		if ( inner_neuron(num_neuron[parents[k][1]], parent2, vertice, inner_elem2) < 0)
		{
			syslog(LOG_CRIT,"Error in inner_neuron2: %s",strerror(errno));
			return(3);
		}

		near_neuron(num_neuron[parents[k][0]],parent1,inner_elem1);
		near_neuron(num_neuron[parents[k][1]],parent2,inner_elem2);

/*
		sprintf(char_buffer,"parent1:");
		for (l=0; l<num_neuron[parents[k][0]]; l++)
		{
			sprintf(char_temp,"%d",inner_elem1[l]);
			strcat(char_buffer,char_temp);
		}
		syslog(LOG_INFO,char_buffer);
	
		sprintf(char_buffer,"parent2:");
		for (l=0; l<num_neuron[parents[k][1]]; l++)
		{
			sprintf(char_temp,"%d",inner_elem2[l]);
			strcat(char_buffer,char_temp);
		}
		syslog(LOG_INFO,char_buffer);
*/

		/*** Rip off connections ***/
		if ( (n=isolate_region(num_neuron[parents[k][0]], parent1, inner_elem1)) <0)
		{
			syslog(LOG_CRIT,"Error isolate_region parent1 %d",n);
			return(1);
		}
		if ( (n=isolate_region(num_neuron[parents[k][1]], parent2, inner_elem2)) <0)
		{
			syslog(LOG_CRIT,"Error isolate_region parent2 %d",n);
			return(1);
		}

		syslog(LOG_INFO,"Size parent1[%d] before remove_neuron()=%d",k,num_neuron[parents[k][0]]);
	
		if (!(parent1 =	(struct neuron **)remove_neuron(
													num_neuron[parents[k][0]],parent1,inner_elem1, &n) ))
		{
			syslog(LOG_CRIT,"Error in remove_neuron parent1 %d",k);
			return(1);
		}
	
		new_num_neuron[k]=n;
		syslog(LOG_INFO,"Size parent1[%d] after remove_neuron()=%d",k,new_num_neuron[k]);
	
		if (!(parent1 =	(struct neuron **)append_neuron(new_num_neuron[k],
					num_neuron[parents[k][1]], parent1,parent2,inner_elem2, &n ) ))
		{
			syslog(LOG_CRIT,"Error in append_neuron parent1 %d",k);
			return(1);
		}

		new_num_neuron[k]=n;
		syslog(LOG_INFO,"Size parent1[%d] after append_neuron()=%d",k,new_num_neuron[k]);
	
	
		/************ Mutation ************/
		/**********************************/

		if (toss(mut_neuron_prob,k) )
		{
			l = dice_toss(k, max_neuron_mut);
			
			/************** Requires num_input num_output ************/
			
			l = (coin_toss(l) > 0) ? l : -l;
//			syslog(LOG_INFO,"Mutation neuron_array: append/remove=%d",l);
			if ( !(parent1 = (struct neuron **)mutate_neuron_array(new_num_neuron[k], l, 
																				parent1, &n) ))
			{
				syslog(LOG_CRIT,"Error in mutate_neuron_array(): net=%d",k);
				return(1);
			}
			new_num_neuron[k]=n;
			syslog(LOG_INFO,"neuron_array mutated, new num_neuron=%d",new_num_neuron[k]);
		}
	
		for (l=0; l< new_num_neuron[k]; l++)
		{
			if (toss(mut_neuron_prob,l))
			{
				syslog(LOG_INFO,"Mutation of neuron: net=%d element=%d",k,l);
				if ( !(parent1[l] = (struct neuron *)mutate_neuron(parent1[l], &ga_conf) ))
				{
					syslog(LOG_CRIT,"Error in mutate_neuron(): net=%d element=%d",k,l);
					return(1);
				}
			}
		}
	
		dwrite_neuron_array(new_num_neuron[k], parent1, connfd[k]);

		if ( (parent1 = (struct neuron **)free_neuron_array(new_num_neuron[k],parent1) ))
		{
			syslog(LOG_CRIT,"Error in free_neuron_array parent1 %d",k);
			return(1);
		}
		if ( (parent2 = (struct neuron **)free_neuron_array(num_neuron[parents[k][1]],parent2) ))
		{
			syslog(LOG_CRIT,"Error in free_neuron_array parent2 %d",k);
			return(1);
		}
	}
	else
	{
		test_flag=0; 
		
		/*** Jump point in randomize case ***/
		if (sigsetjmp(jump_alarm,0) != 0)
		{
			alarm(0);
			test_flag=1; //In case of failing to connect niche server, flag = 1;
		}

		/*** Use niche offspring ***/
		if ( (!test_flag) && (ga_conf.num_niche > 0) && (toss(ga_conf.inm_prob, gen)) )
		{
			l = dice_toss(gen, ga_conf.num_niche);  //NICHE select
			
			syslog(LOG_INFO,"Requesting foreign neuron_array %d",l);
			syslog(LOG_INFO,"Remote niche: %s",ga_conf.niches[l]);
			if ( (connfd_remote = socket(PF_INET, SOCK_STREAM, 0)) < 0)
			{
				syslog(LOG_CRIT,"Error creating socket: %d %s",k,strerror(errno));
				return(1);
			}
			
			bzero(&serv_in_addr_remote, sizeof(serv_in_addr_remote));
			serv_in_addr_remote.sin_family = PF_INET;

			 /***  this requires max_local > 0, so local server port is unused ***/
			serv_in_addr_remote.sin_port = htons((uint16_t)local_server_port);  
		
			if (inet_pton(AF_INET,ga_conf.niches[l],&serv_in_addr_remote.sin_addr) < 1)
			{
				syslog(LOG_CRIT,"Error inet_pton() %d %s",k,strerror(errno));
				return(1);
			}
			
			/*** Setting sigaction to handle SIGALRM ***/
			syslog(LOG_INFO,"Setting SIGALRM handler");
			sigemptyset(&sig_usr_action.sa_mask);
			sig_usr_action.sa_handler = sig_alarm;
			sig_usr_action.sa_flags = 0;
			sig_usr_action.sa_flags |= SA_RESTART;
			sig_usr_action.sa_flags |= SA_NOMASK;
			if (sigaction(SIGALRM, &sig_usr_action, NULL) < 0)
			{
				syslog(LOG_CRIT,"Couldn't set SIGALRM handler");
				return(1);
			}
			
			/*** alarm ***/
			alarm(ga_conf.time_wait);
		
			/*** Retriving remote neuron_array from niche ***/
			if( (connect(connfd_remote, (struct sockaddr *) &serv_in_addr_remote, 
								sizeof(serv_in_addr_remote))) <0)
			{
				syslog(LOG_CRIT,"Couldn't connect to niche[%d]: %d %s",l,k,strerror(errno));
				siglongjmp(jump_alarm,1);
			}
			else 
			{
				alarm(0);
				if (readn(connfd_remote,char_buffer,BUFFSIZE) <0)
				{
					syslog(LOG_CRIT,"Error closed connection from niche");
					return(1);
				}

				if ( !(strncmp("neuron_array",char_buffer,12) ) )
				{
					if ( readn(connfd_remote,char_buffer,BUFFSIZE) < 0)
					{
						syslog(LOG_CRIT,"Error closed connection from niche");
						return(1);
					}
					m = atoi(char_buffer+11);  //num_neuron
					syslog(LOG_INFO,"client=%d niche=%d num_neuron=%d",k,l,m);  //required for bug

					if ( !(parent1 = (struct neuron **)calloc(m,sizeof(struct neuron *)) ))
					{
						syslog(LOG_CRIT,"Error calloc parent1 niche%d: %s",l,strerror(errno));
						return(1);
					}
					for (n=0; n< m; n++)
					{
						if ( !(parent1[n] = (struct neuron *)calloc(1,sizeof(struct neuron)) ))
						{	
							syslog(LOG_CRIT,"Error calloc parent1 niche[%d]: %s",l,strerror(errno));
							return(1);
						}
					}
					read_neuron_array(m, parent1, connfd_remote);
	
					/*** Now writing to client the foreign neuron_array ***/
	
					dwrite_neuron_array(m, parent1, connfd[k]);
	
					/*** Should try just bypassing values ***/
	
					if ( (parent1 = (struct neuron **)free_neuron_array(m,parent1) ))
					{
						syslog(LOG_CRIT,"Error in free_neuron_array parent1 %d",k);
						return(1);
					}
				}
				close(connfd_remote);
			}
		}
		else
		{
			sprintf(char_buffer,"Randomize client %d",k);
			writen(connfd[k],char_buffer,BUFFSIZE);
			syslog(LOG_INFO,char_buffer);
		}
	}

	sprintf(char_buffer,"All work done for client=%d gen=%d",k,gen);
	writen(connfd[k],char_buffer,BUFFSIZE);
	
	syslog(LOG_INFO,"**** Passed iteraction %d generation %d ****",k,gen);
}

for (k=0; k< poblation; k++)
{
	if ( (net_array[k]->neuron_array = (struct neuron **)free_neuron_array(
										num_neuron[k],net_array[k]->neuron_array) ))
	{
		syslog(LOG_CRIT,"Error in free_neuron_array net_array[%d]->neuron_array",k);
		return(1);
	}
}

syslog(LOG_INFO,"**** Passed generation %d ****",gen);

}
/******************** END LOOP GENERATIONS ***************/

for (k=0; (k< poblation) && (k< max_local); k++)
{
	close(connfd[k]);
	sprintf(char_buffer,"unix%d.str",k);
	unlink(char_buffer);		
}
if (ga_conf.num_niche > 0)
{
	unlink("niche_fifo");
}

syslog(LOG_INFO,"********* Exiting *********");
exit(0);
}