#1
  1. No Profile Picture
    Registered User
    Devshed Newbie (0 - 499 posts)

    Join Date
    Sep 2012
    Posts
    1
    Rep Power
    0

    Need help for this program plz!!!! urgent


    Code:
    #include<stdio.h>
    #include<math.h>
    #include<stdlib.h>
    #include<pthread.h>
    #define INPUT_NEURONS 256
    #define HIDDEN_NEURONS 150
    #define OUTPUT_NEURONS 10
    #define CONTEXT_NEURONS 150
    #define no_of_clients 10
    #define no_trng_vectors 1593
    int HIDDENNEURONS = HIDDEN_NEURONS/no_of_clients;
    // Activations.
    double inputs[INPUT_NEURONS];
    double hidden[HIDDEN_NEURONS]={0};
    double target[OUTPUT_NEURONS];
    double actual[OUTPUT_NEURONS];
    double context[CONTEXT_NEURONS]={0};
    static double outputs_from_file[no_trng_vectors][OUTPUT_NEURONS];
    static double inputs_from_file[no_trng_vectors][INPUT_NEURONS];
    
    double batch_deltawho[no_trng_vectors][INPUT_NEURONS][OUTPUT_NEURONS];
    double batch_deltawih[no_trng_vectors][INPUT_NEURONS][HIDDEN_NEURONS];
    double batch_erro[no_trng_vectors][OUTPUT_NEURONS];
    
    typedef struct{
    	
    	int cli_index;
    	
    	int sam;
    }cli_var;
         
    
    double temp = 0.0;    
    int itteration;
    int stop = 0;
    double LEARN_RATE = 0.2;    // Rho.
    //-------------------------------------------------------------
    // Input to Hidden Weights (with Bias es).
    //double wih[INPUT_NEURONS][HIDDEN_NEURONS]={{0.840188,0.394383,0.783099},{0.798440,0.911647,0.197551},{0.335223,0.768230,0.277775},{0.553970,0.477397,0.628871},{0.364784,0.513401,0.952230},{0.916195,0.635712,0.717297}
    
    // Context to Hidden Weight (with Biases).
    //double wch[CONTEXT_NEURONS][HIDDEN_NEURONS]={{0.141603,0.606969,0.016301},{0.242887,0.137232,0.804177},{0.156679,0.400944,0.129790}
    
    
    
    // Hidden to Output Weights (with Biases).
    //double who[HIDDEN_NEURONS][OUTPUT_NEURONS]={{0.108809,0.998925,0.218257,0.512932,0.839112,0.612640},{0.296032,0.637552,0.524287,0.493583,0.972775,0.292517},{0.771358,0.526745,0.769914,0.400229,0.891529,0.283315}};
    double wih[INPUT_NEURONS][HIDDEN_NEURONS];
    double wch[CONTEXT_NEURONS][HIDDEN_NEURONS];
    double who[HIDDEN_NEURONS][OUTPUT_NEURONS];
    // Hidden to Context Weights (no Biases).
    double whc[OUTPUT_NEURONS][CONTEXT_NEURONS];
    															   
    
    // Unit errors.
    double erro[OUTPUT_NEURONS];
    double errh[HIDDEN_NEURONS];
    
    int NUM_THREADS=no_of_clients+1;
    	pthread_t threads[11];
    int a[2]={0,0};
    double fRand(double,double);
    double sigmoid(double);
    double sigmoidDerivative(double);
    void backPropagate();
    void assignRandomWeightsIH();
    void assignRandomWeightsCH();
    void assignRandomWeightsHC();	
    void assignRandomWeightsHO();
    void storeError(int);
    void elmanNetwork();
    void *server(void *);
    void *client(void *);
    
    main()
    { 
        int noofinp=0,noofout=0;
        struct timeval tv1,tv2;
        int hid,out;
        unsigned long long  startingtime,endingtime;
        gettimeofday(&tv1,NULL);
        startingtime=tv1.tv_usec + tv1.tv_sec *1000000;
        printf("starting time in seconds:");
        printf("%llu",startingtime);
        FILE *fp;
        int i,l,k;
        fp=fopen("read.txt","r");
        
    	/*fscanf(fp,"%d",&INPUT_NEURONS);
    	
    	fscanf(fp,"%d",&HIDDEN_NEURONS);
    	
    	fscanf(fp,"%d",&CONTEXT_NEURONS);
    	
    	fscanf(fp,"%d",&OUTPUT_NEURONS); */
    	
    	fscanf(fp,"%lf",&LEARN_RATE);
    	
    	//fscanf(fp,"%d",&no_trng_vectors); 
    	
    	/*for(i=0;i<no_trng_vectors;i++)
    	
    	{	 
    	
    		for (l = 0; l < INPUT_NEURONS; l++){
    			fscanf (fp, "%lf", &inputs_from_file[i][l]);
    			//printf("----%lf",inputs_from_file[i][l]);
    		} 
    		printf("\n");
    
    
          
    		for (k = 0; k<OUTPUT_NEURONS; k++){
    			fscanf (fp, "%lf", &outputs_from_file[i][k]);
    		}
        }*/
    	for(i=0,noofinp=0,noofout=0;i<no_trng_vectors;i++)
    	{	 
    	       for (l = 0; l < INPUT_NEURONS; l++)
    	       {
    		if(noofinp!=256)
    		{
    		fscanf (fp, "%lf", &inputs_from_file[i][l]);
    		noofinp++;
    		}
    		//printf("----%lf",inputs_from_file[i][l]);
    	       } 
    
    
                   for(k = 0; k<OUTPUT_NEURONS; k++)
    	       {
    		if(noofout!=10)
    		{
    		fscanf (fp, "%lf", &outputs_from_file[i][k]);
    	        noofout++;	        
                    }
    		} 
            }
    	
    
    /*for(i=0;i<no_trng_vectors;i++) //accepting inputs nd outputs from file
    	
    	{	 
    	
    		for (l = 0; l < INPUT_NEURONS; l++){
    			
    			printf("inputs----%lf",inputs_from_file[i][l]);
    			printf("\t");
    		} 
    		printf("\n");
    
    
          
    		for (k = 0; k<OUTPUT_NEURONS; k++){
    			printf ("outputs----%lf", outputs_from_file[i][k]);
    			printf("\t");
    		}
    		printf("\n");
        }*/ 
    	
    
    	fclose(fp);
            assignRandomWeightsHC();	
            assignRandomWeightsHO();
            assignRandomWeightsIH();
            assignRandomWeightsCH();
            elmanNetwork();
    	printf("\nnetwork is trained at %lf",temp);
    	 
    	/*for(out = 0; out < OUTPUT_NEURONS; out++)
    	{
    		for(hid = 0; hid < HIDDEN_NEURONS; hid++)
    		{
    		//printf("%lf", who[hid][out]);
    		//printf("...........");		
    		}
    	 }*/
    	
        
    	gettimeofday(&tv2,NULL);
            endingtime=tv2.tv_usec + tv2.tv_sec *1000000;
            printf("\nendingtime:%llu",endingtime);
    if(startingtime<endingtime)
            printf("\ntime taken in parallel code using pthreads:%llu\n",(endingtime-startingtime));
    else
            printf("\ntime taken in parallel code using pthreads:%llu\n",(startingtime-endingtime));
    }
    
    
    void elmanNetwork()
    {
    	int i,j,cli_index;
    	int inp,out;
    	int batch_count=0;
            cli_var cli_val1;
    	while(!stop)
    	{
    	 int sample=0;
    	 batch_count++;
    		/*if(batch_count==60){
    			break;
    		}*/
    	for(j=0;j<no_trng_vectors;j++)
    	{
    	 for(inp=0;inp<INPUT_NEURONS;inp++)
    	  {
    	   inputs[inp]=inputs_from_file[sample][inp];				
    	   //printf("-------%lf",inputs[inp]);				
    	  }				
    	  for(out=0;out<OUTPUT_NEURONS;out++)
    	  {
    	   target[out]=outputs_from_file[sample][out];
    	  }// creating client thread.
    	  /*for(i=0,cli_val1.cli_index=0;i<NUM_THREADS-1;i++,cli_val1.cli_index++)
    	  {
    		pthread_create(&threads[i],NULL,client,(void *)&cli_val1);
    		//pthread_join(threads[i],NULL);
    	   }*/
    	   //printf(".......");
    	   // creating server thread.
    	   pthread_create(&threads[0],NULL,server,(void *)sample);
    	   pthread_join(threads[0],NULL);
    	   //a[0]=0;
    	   //a[1]=0;
    	   sample++;
    	}
    	//printf("\n batch_count:%d",batch_count);
    	}
    	
    	return;
    }
    
    void *client(void * index)
    {
    	cli_var *cli_var2;
    	cli_var2=(cli_var*)index;	
    	int con;
    	double sum = 0.0;
    	int hid,inp,out;
    	//printf("\n inside client,index %d", cli_var2->cli_index);
    	int sample=cli_var2->sam;
    	/*for(inp=0;inp<INPUT_NEURONS;inp++)
    	{
    	inputs[inp]=inputs_from_file[sample][inp];
    	//printf("-------%lf",inputs[inp]);
    	}
    	for(out=0;out<OUTPUT_NEURONS;out++)
    	{
    	target[out]=outputs_from_file[sample][out];
    	}*/
    	// calculate inputs to hidden layer using wih & wch
    	// part of feed forward 
            for(hid = (cli_var2->cli_index)*HIDDENNEURONS; hid < ((cli_var2->cli_index)+1)*HIDDENNEURONS; hid++)
            {
                sum = 0.0;
                for(inp = 0; inp < INPUT_NEURONS; inp++)    // from input to hidden...
                {
                    sum += inputs[inp] * wih[inp][hid];
                    //printf("\n sum: %lf",sum);
                } // inp
                
                for(con = 0; con < CONTEXT_NEURONS; con++)    // from context to hidden...
                {
                    sum += context[con] * wch[con][hid];
                    //printf("\n sum with con: %lf",sum);
                } // con
                
                //sum += wih[INPUT_NEURONS][hid];    // Add in bias.
                //sum += wch[CONTEXT_NEURONS][hid];
                hidden[hid] = sigmoid(sum);
            } // hid
    	//a[cli_var2->cli_index]=1;
    }
    
    void assignRandomWeightsIH()
    {
    	int inp,hid;
    	for(inp = 0; inp < INPUT_NEURONS; inp++)    // Do not subtract 1 here.
    	{
    		for(hid = 0; hid <HIDDEN_NEURONS; hid++)
    		{
    			// Assign a random weight value between 0 and 1
    			wih[inp][hid] = fRand(0,1);
    		//printf("wih:%lf",wih[inp][hid]);
    		} // hid
    		//printf("\n");
    	} // inp
    	return;
    }
    
    void assignRandomWeightsCH()
    {
    	int con,hid;
    	for(con = 0; con < CONTEXT_NEURONS; con++)
    	{
    		for(hid = 0; hid <HIDDEN_NEURONS; hid++)
    		{
    			// Assign a random weight value between 0 and 1
    			wch[con][hid] = fRand(0,1);
    		//printf("wch:%lf",wch[con][hid]);
    		} // hid
    		//printf("\n");
    	} // con
    	return;
    }
    
    
    void *server(void *index)
    {
    	double err;
    	double sum;
    	cli_var cli_val1;
    	int sample=(int)index;	
    	int out,hid,con,count,inp;
    	
    	int i,l,j;	
    	
    	cli_val1.sam=sample;
    	//printf("\n inside server,index %d", cli_var2->cli_index);
    	//printf("\n inside server,sample %d", sample);
    	
    	for(i=1,cli_val1.cli_index=0;i<NUM_THREADS;i++,cli_val1.cli_index++)
    			{
    				//printf("client index %d",cli_val1.cli_index);
    				pthread_create(&threads[i],NULL,client,(void *)&cli_val1);
    				//pthread_join(threads[i],NULL);
    			}
    		pthread_join(threads[i-1],NULL);
    		/*if(!(a[0]&&a[1]))
    		{
    			printf("sleeping");			
    			sleep(10);
    		}*/
    		
    
    	//while(1){
    	
    		//while(sample!=no_trng_vectors){	
    	   // Train the network.
    		   //itteration++;
    		// Calculate the  hidden to output layer.
    	// part of feed forward
            for(hid = 0; hid < HIDDEN_NEURONS; hid++){
    		//printf("hidden: %lf",hidden[hid]);
    	}
            for(out = 0; out < OUTPUT_NEURONS; out++)
            {
                sum = 0.0;
                for(hid = 0; hid < HIDDEN_NEURONS; hid++)
                {
                    sum += hidden[hid] * who[hid][out];
                } // hid
    
                //sum += who[HIDDEN_NEURONS][out];    // Add in bias.
                actual[out] = sigmoid(sum);
            } // out
    
    
    	 // Copy outputs of the hidden to context layer.
            for(con = 0; con < CONTEXT_NEURONS; con++)
            {
                context[con] = hidden[con];
            }					    
    		storeError(sample);
    		//sample++;
    
    	
    	//}
      
    			
    		if(sample==no_trng_vectors-1){
    			err = 0.0;
    			for(j=0; j < no_trng_vectors; j++){
    				for(i = 0; i < OUTPUT_NEURONS; i++)
    				{
    					//err += Math.sqrt(target_vector[i] - output_vector[i]);
    					err += batch_erro[j][i]*batch_erro[j][i];
    				}
    			}
    			err = 0.5 * err/no_trng_vectors;
    			//printf("err:%lf",err);
    		
    			if(temp>0.0){
    				if(temp-err>0.2){
    					LEARN_RATE=LEARN_RATE-LEARN_RATE*0.1;
    		   	 
    				}else if(temp-err<0.2){
    					LEARN_RATE=LEARN_RATE+LEARN_RATE*0.1;
    				}
    			}
    			temp=err;
    			if(err<0.05)
    			{
    				stop = 1;
    				//printf(".....%lf....",err);
    			
    				//break;
    	
    			}
    			else{
    		 
    				backPropagate();
    				//sample=0;
    				itteration++;
    				return;
    
    			}
    		}
    	
    	//}
    
      	 
    	//printf("itterations :%d",itteration);
    	
    		return;	
    }
    
    void assignRandomWeightsHC()
    {
    	int con,out;    
    	for(out = 0; out < OUTPUT_NEURONS; out++)
    	{
    		for(con = 0; con < CONTEXT_NEURONS; con++)
    		{
    			// These are all fixed weights set to 0.5
    			whc[out][con] = 0.5;
    		} // con
    	} //  out
    	return;
    }
    
    void assignRandomWeightsHO()
    {
    	int hid,out;	
    	for(hid = 0; hid < HIDDEN_NEURONS; hid++)    //Do not subtract 1 here.
    	{
    		for(out = 0; out < OUTPUT_NEURONS; out++)
    		{
    			// Assign a random weight value between 0 and 1
    			who[hid][out] = fRand(0,1);
    		//printf("who:%lf",who[hid][out]);
    		} // out
    		//printf("\n");
    
    	} // hid
    	return;
    }
    
    void storeError(int trng_vector_index)
    {
    	int count1=0;
    	int out,hid,inp;
    	int i;	
    	//printf("\n storing error for trngvectorind %d ",trng_vector_index);
    	// Calculate the output layer error (step 3 for output cell).
    	for(out = 0; out < OUTPUT_NEURONS; out++)
    	{
    		batch_erro[trng_vector_index][out] =  (target[out] - actual[out]);
    		erro[out] = (target[out] - actual[out]) * sigmoidDerivative(actual[out]);
    	}
    	  
    	// Calculate the hidden layer error and updating (step 3 for hidden cell).
    	for(hid = 0; hid < HIDDEN_NEURONS; hid++)
    	{
    		errh[hid] = 0.0;
    		for(out = 0; out < OUTPUT_NEURONS; out++)
    		{
    			errh[hid] += erro[out] * who[hid][out];
    		} // out
    		errh[hid] *= sigmoidDerivative(hidden[hid]);
    	} // hid
    
    	// Update the weights for the output layer (step 4).
    	for(out = 0; out < OUTPUT_NEURONS; out++)
    	{
    		for(hid = 0; hid < HIDDEN_NEURONS; hid++)
    		{
    			batch_deltawho[trng_vector_index][hid][out] += (LEARN_RATE * erro[out] * hidden[hid]);
    			//who[hid][out] += (LEARN_RATE * erro[out] * hidden[hid]);
    		} // hid
    		
    		//who[HIDDEN_NEURONS][out] += (LEARN_RATE * erro[out]);    // Update the bias.
    	} // out
    
    	// Update the weights for the hidden layer (step 4).
    	for(hid = 0; hid < HIDDEN_NEURONS; hid++)
    	{
    		for(inp = 0; inp < INPUT_NEURONS; inp++)
    		{
    			batch_deltawih[trng_vector_index][inp][hid] += (LEARN_RATE * errh[hid] * inputs[inp]);
    			//wih[inp][hid] += (LEARN_RATE * errh[hid] * inputs[inp]);
    		} // inp
    		
    		//wih[INPUT_NEURONS][hid] += (LEARN_RATE * errh[hid]);    // Update the bias.
    	} // hid
    
    }    
    
    
    
     void backPropagate()
     {
         int count1=0;
         int out,hid,inp;
         int trng_vector_ind;
         int i;	
    	 
            // Calculate the output layer error (step 3 for output cell).
            for(out = 0; out < OUTPUT_NEURONS; out++)
            {     
    	 erro[out] = (target[out] - actual[out]) * sigmoidDerivative(actual[out]);
    	}   
            // Calculate the hidden layer error and updating (step 3 for hidden cell).
            for(hid = 0; hid < HIDDEN_NEURONS; hid++)
    	{
    	 errh[hid] = 0.0;
    	 for(out = 0; out < OUTPUT_NEURONS; out++)
    	 {               
    		errh[hid] += erro[out] * who[hid][out];
    	 } // out
    	  errh[hid] *= sigmoidDerivative(hidden[hid]);
    	} // hid
    	
    
            // Update the weights for the output layer (step 4).
            for(out = 0; out < OUTPUT_NEURONS; out++)
    	{
    		for(hid = 0; hid < HIDDEN_NEURONS; hid++)
    		{		
    			for(trng_vector_ind =0; trng_vector_ind<no_trng_vectors; trng_vector_ind++){
    		            		who[hid][out] += batch_deltawho[trng_vector_ind][hid][out];
    		            	
    				}
    			who[hid][out]=who[hid][out]/no_trng_vectors;	
                      //who[hid][out] += (LEARN_RATE * erro[out] * hidden[hid]);
    		} // hid
    		//who[HIDDEN_NEURONS][out] += (LEARN_RATE * erro[out]);    // Update the bias.
    	} // out
    	
    
            // Update the weights for the hidden layer (step 4).
            for(hid = 0; hid < HIDDEN_NEURONS; hid++)
    	{
    		for(inp = 0; inp < INPUT_NEURONS; inp++)
    		{		
    			for(trng_vector_ind =0; trng_vector_ind<no_trng_vectors; trng_vector_ind++){
    		            		wih[inp][hid] += batch_deltawih[trng_vector_ind][inp][hid];
    		            	}
    				
    			wih[inp][hid]=wih[inp][hid]/no_trng_vectors;	
    			//wih[inp][hid] += (LEARN_RATE * errh[hid] * inputs[inp]);
    		} // inp
    		
    		//wih[INPUT_NEURONS][hid] += (LEARN_RATE * errh[hid]);    // Update the bias.
    	} // hid
    }    
    
    double fRand(double fMin, double fMax)
    {
    	double f = (double)rand()/ RAND_MAX;
    	return fMin + f * (fMax - fMin);
    }
        
    double sigmoid(double val)
    {
    	return (1.0 / (1.0 +exp(-val)));
    }
    
    double sigmoidDerivative(double val)
    {
    	return (val * (1.0 - val));
    }
    this program is used to find processor time

    this program has 2 be executed in linux

    when i execute it in ubuntu it says segment fault!!!!

    can anyone give me proper solution asap!!!

    thanks in advance!!!
  2. #2
  3. No Profile Picture
    Contributing User
    Devshed Newbie (0 - 499 posts)

    Join Date
    Aug 2012
    Posts
    156
    Rep Power
    33
    this program is used to find processor time
    I very much doubt that ...

    Have you looked at the linux shell command time?
  4. #3
  5. Contributing User
    Devshed Supreme Being (6500+ posts)

    Join Date
    Jan 2003
    Location
    USA
    Posts
    7,087
    Rep Power
    2222
    this program has 2 be executed in linux
    Auf Englisch, bitte!


    when i execute it in ubuntu it says segment fault!!!!
    Do you know what a segmentation fault (AKA "segfault") is and what can cause it?

    The OS gives every process a segment of memory space with belongs to that process. A process is only allowed to access its own segment of memory and nobody else's, especially not the OS'. When a process tries to access a memory location outside its own memory space, then it gets slapped with a segfault and gets terminated with extremem prejudice -- the OS has to protect itself from us or else we may as well go back to running under MS-DOS.

    The primary way in which you may incur a segfault is by using a pointer that is either uninitialized or else has been loaded with a bogus address.

    The case of it being an unintialized pointer should be trivial to understand, but how could you load a pointer with a bogus address? Well, when a function returns a pointer, it will usually return a NULL if there was an error; eg, if fopen cannot open the file, then it returns NULL. If you neglect to check the return value of such functions and handle them appropriately, then when you try to use that NULL pointer you will get slapped with a segfault -- you did just exactly that.

    Also, in a thread if you pass it a bogus void pointer, then you are asking for a segfault. For example, in your code:
    Code:
    void elmanNetwork()
    {
    	int i,j,cli_index;
    	int inp,out;
    	int batch_count=0;
            cli_var cli_val1;
    	while(!stop)
    	{
    	 int sample=0;
    	 batch_count++;
    		/*if(batch_count==60){
    			break;
    		}*/
    	for(j=0;j<no_trng_vectors;j++)
    	{
    	 for(inp=0;inp<INPUT_NEURONS;inp++)
    	  {
    	   inputs[inp]=inputs_from_file[sample][inp];				
    	   //printf("-------%lf",inputs[inp]);				
    	  }				
    	  for(out=0;out<OUTPUT_NEURONS;out++)
    	  {
    	   target[out]=outputs_from_file[sample][out];
    	  }// creating client thread.
    	  /*for(i=0,cli_val1.cli_index=0;i<NUM_THREADS-1;i++,cli_val1.cli_index++)
    	  {
    		pthread_create(&threads[ i],NULL,client,(void *)&cli_val1);
    		//pthread_join(threads[ i],NULL);
    	   }*/
    	   //printf(".......");
    	   // creating server thread.
    	   pthread_create(&threads[0],NULL,server,(void *)sample);
    If you're passing the value of sample to the thread, then shouldn't you be passing the address of sample? Rather than casting the value of sample to being a pointer, in which case if sample is still zero then you are passing a NULL pointer to that thread which is going to use it to access memory outside its own space, memory that belongs to the OS.

    BTW, those are only two of the possible errors that might be responsible for that segfault. You'll need to ferret out the rest yourself.

    Think about the error, what the error means, and what can cause that error.
    Last edited by dwise1_aol; September 27th, 2012 at 02:19 PM.

IMN logo majestic logo threadwatch logo seochat tools logo