Ir ao conteúdo
  • Cadastre-se
JeffWPoe

C Rede Neural - Problema com Resultados

Recommended Posts

Pessoal é o seguinte. Não vou postar agr porque é muito grande e antes queria situar vcs acerca do problema. 

Eu fiz um código de rede neural em C/C++ e ele funciona até q muito bem e utilizada o algoritmo backpropagation. O problema é que quando insiro dois padrões de entradas diferentes os resultados ao invés de ser por exemplo (entrada 0.4, saída 0.7), (entrada 0.7, saída 0.4) ele acaba fazendo uma média entre os dois objetivos e expondo para os dois padrões de entrada. Não sei mais o que fazer. Se alguém aí achar q pode me ajudar me fala para eu postar o codigo (está com alguns remendos até).

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Cara eu não conheço isso mas me interessei, eu vou estudar esse algoritmo amanhã. Se tu quiser postar o código pra gente talvez alguém que já seja familiar com o conceito possa te ajudar

  • Obrigado 1

Compartilhar este post


Link para o post
Compartilhar em outros sites
4 horas atrás, malloc_ disse:

Cara eu não conheço isso mas me interessei, eu vou estudar esse algoritmo amanhã. Se tu quiser postar o código pra gente talvez alguém que já seja familiar com o conceito possa te ajudar

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

float sigmoide (float x, float a){
	float resultado = 1/(1+exp(-a*x));
	//printf("\n%f\n", resultado);
	return resultado;
}

struct n {
	float *entrada;
	float *peso;
	float dW[10];
	float soma;
	float bias;
	float delta;
	float resultado;

};

struct layer {
	struct  n *neuronio;
};

struct rna {
	struct layer *camada;
};

int main (){
	
	int aux;
	int camadas;
	int epoc;
	int *layout;
	float *entrada;
	float *objetivo;
	float res[2];
	srand((unsigned)time(NULL));
	
	//Solicita os dados de estruta da rede para o usuario
	printf("Insira o numero de camadas da rede: ");
	scanf("%i",&camadas);
	setbuf(stdin, NULL);
	printf("\n");
	
	layout = (int *)malloc(camadas*sizeof(int));
	
	for (int i = 0; i < camadas; i++){
		if (i == 0) {
			printf("Digite o numero de entradas: ");
			scanf("%i",&layout[i]);
			setbuf(stdin, NULL);
			
		}
		else {
			printf("Digite o numero de neuronios da camada %i: ", i+1);
			scanf("%i",&layout[i]);
			setbuf(stdin, NULL);
		}	
	}
	
	objetivo = (float *)malloc(layout[camadas-1]*sizeof(float));
	
	//Inicializa o tamanho do vetor de entradas
	printf("\nDigite o numero de conjunto de entradas: ");
	scanf("%i",&aux);
	setbuf(stdin, NULL);
	entrada = (float*)malloc(aux*layout[0]*sizeof(float));
	
	//Quantidade de epocas
	printf("\nDigite o numero de epocas: ");
	scanf("%i",&epoc);
	setbuf(stdin, NULL);
	
	printf("\nOk1\n");
	//Inicia a estrutura da rede
	struct rna rede;
	
	//Inicia a quantidade de camadas
	rede.camada = (struct layer*) malloc(camadas* sizeof(struct layer));
	
	//Inicia a quantidade de neuronios de cada camada
	for (int i = 0; i < camadas; i++){
		printf("Camada %i: \n", i);
		rede.camada[i].neuronio =(struct n*) malloc(layout[i] * sizeof(struct n));
		printf("\nok2\n");
		//Inicializa a quantidade de entradas e pesos em cada neuronio
		for (int j = 0; j < layout[i]; j++){
			printf("\tNeuronio %i: \n", j);
			if (i == 0) {
			rede.camada[i].neuronio[j].entrada = (float *)malloc(1*sizeof(float));
			rede.camada[i].neuronio[j].peso = (float *)malloc(1*sizeof(float));
			//rede.camada[i].neuronio[j].dW = (float *)malloc(2*sizeof(float));
				printf("\nok3\n");
			}
			else {
			rede.camada[i].neuronio[j].entrada = (float *)malloc(layout[i-1]*sizeof(float));
			rede.camada[i].neuronio[j].peso = (float *)malloc(layout[i-1]*sizeof(float));
				printf("\nok4\n");
			//rede.camada[i].neuronio[j].dW = (float *)malloc((layout[i-1]+1)*sizeof(float));	
			}
		}		
	}
	
	//Inicializa os pesos,delta, bias e soma dos neuronios
	for (int i = 0; i < camadas; i++){
		for (int j = 0; j < layout[i]; j++){
			if (i == 0) {
				rede.camada[i].neuronio[j].peso[0]=1;
				rede.camada[i].neuronio[j].bias=0; 
				rede.camada[i].neuronio[j].soma=0; 
			}
			else {
				for (int a = 0; a < layout[i-1]; a++){
					rede.camada[i].neuronio[j].peso[a] = (rand()%10000)/10000.0;
				}
				rede.camada[i].neuronio[j].bias = 1;
				rede.camada[i].neuronio[j].soma=0;
				rede.camada[i].neuronio[j].delta=0;
				//rede.camada[i].neuronio[j].dW=0;
			}
		}		
	}
	printf("\nok5\n");
	for(int i=0; i < camadas; i++){
		printf("Camada %i: \n", i);
		for(int j=0; j < layout[i]; j++){
			printf("\tNeuronio %i: \n", j);
			for (int w = 0; w < 10; w++){
				rede.camada[i].neuronio[j].dW[w] = 0;
			}
		}
	}
	
	
	printf("\nok6\n");
	
	entrada[0] = 0.4;
	entrada[1] = 0.7;
	objetivo[0] = 0.7;
	objetivo[1] = 0.4;
	
	
	for (int epoca = 0; epoca < epoc; epoca++){
		for (int padrão = 0; padrão < 2; padrão++){
	//Propagacao
	for (int i = 0; i < camadas; i++){
		for (int j = 0; j < layout[i]; j++){
			if (i == 0){
				rede.camada[i].neuronio[j].entrada[0] = entrada[padrão];
					
				rede.camada[i].neuronio[j].soma += rede.camada[i].neuronio[j].entrada[0]*rede.camada[i].neuronio[j].peso[0];
				
				rede.camada[i].neuronio[j].resultado = rede.camada[i].neuronio[j].soma;
				rede.camada[i].neuronio[j].soma = 0;
			} 
			else
			{
				for (int k = 0; k < layout[i-1]; k++){
					rede.camada[i].neuronio[j].entrada[k] = rede.camada[i-1].neuronio[k].resultado;
					
					rede.camada[i].neuronio[j].soma += rede.camada[i].neuronio[j].entrada[k]*rede.camada[i].neuronio[j].peso[k];
				}
				rede.camada[i].neuronio[j].soma -= rede.camada[i].neuronio[j].bias;
				
				rede.camada[i].neuronio[j].resultado = sigmoide(rede.camada[i].neuronio[j].soma, 0.2);
				rede.camada[i].neuronio[j].soma=0;
			}
			
		}
	}
	res[padrão] = rede.camada[2].neuronio[0].resultado;
	printf("\nok7\n");
	//Retropropagacao
	
	//Calculo dos deltas da ultima camada 
	for(int k = 0;k < layout[camadas-1];k++){
		rede.camada[camadas-1].neuronio[k].delta = 0.2*rede.camada[camadas-1].neuronio[k].resultado*(objetivo[padrão] - rede.camada[camadas-1].neuronio[k].resultado)*(1 - rede.camada[camadas-1].neuronio[k].resultado);
	}
	
	//calculo dos delta das camadas intermediarias
	for(int i = camadas-2; i > 0; i--){
		for (int j = 0; j < layout[i]; j++){
			for (int k = 0; k < layout[i+1]; k++){
				rede.camada[i].neuronio[j].delta += 0.2*rede.camada[i+1].neuronio[k].entrada[j]*(1-rede.camada[i+1].neuronio[k].entrada[j])*rede.camada[i+1].neuronio[k].delta*rede.camada[i+1].neuronio[k].peso[j];
				printf("%f\n",rede.camada[i].neuronio[j].delta);
				printf("%f\n",rede.camada[i+1].neuronio[k].entrada[j]);
			}
		}
	}
	
	//Calculos dos DW
	if (epoca == 0){
			printf("Camada %i:\n", camadas-1);
	for(int k = 0;k < layout[camadas-1];k++){
		//printf("\n%f&\n",rede.camada[camadas-1].neuronio[k].dW[0]);
		
		printf("\tNeuronio %i:\n", k);
		for (int w = 0; w < layout[camadas-2]+1; w++){
			if(w == layout[camadas-2]){
				rede.camada[camadas-1].neuronio[k].dW[w] = 0.2*rede.camada[camadas-1].neuronio[k].bias + 0.2*rede.camada[camadas-1].neuronio[k].delta*rede.camada[camadas-1].neuronio[k].resultado;
			}else
			{
			rede.camada[camadas-1].neuronio[k].dW[w] = 0.2*rede.camada[camadas-1].neuronio[k].peso[w] + 0.2*rede.camada[camadas-1].neuronio[k].delta*rede.camada[camadas-1].neuronio[k].resultado;
			printf("dw %f&\tpeso %f\tdelta %f\n",rede.camada[camadas-1].neuronio[k].dW[w],rede.camada[camadas-1].neuronio[k].peso[w],rede.camada[camadas-1].neuronio[k].delta);
			}
			}
	}
	for(int i = camadas-2; i > 0; i--){
		printf("Camada %i:\n",i);
		for (int j = 0; j < layout[i]; j++){
			printf("\tNeuronio %i:\n",j);
			for (int w = 0; w < layout[i-1]+1; w++){
				if(w == layout[i-1]){
					rede.camada[i].neuronio[j].dW[w] = 0.2*rede.camada[i].neuronio[j].bias + 0.2*rede.camada[i].neuronio[j].delta*rede.camada[i].neuronio[j].resultado;
				}else{
				rede.camada[i].neuronio[j].dW[w] = 0.2*rede.camada[i].neuronio[j].peso[w] + 0.2*rede.camada[i].neuronio[j].delta*rede.camada[i].neuronio[j].resultado;
				}
				//printf("%f&&\n",rede.camada[i].neuronio[j].dW[w]);
				printf("dw %f&\tpeso %f\tdelta %f\n",rede.camada[i].neuronio[j].dW[w],rede.camada[i].neuronio[j].peso[w],rede.camada[i].neuronio[j].delta);
			}
		}
	}

	}
	else{
	printf("Camada %i:\n", camadas-1);
	for(int k = 0;k < layout[camadas-1];k++){
		//printf("\n%f&\n",rede.camada[camadas-1].neuronio[k].dW[0]);
		
		printf("\tNeuronio %i:\n", k);
		for (int w = 0; w < layout[camadas-2]+1; w++){
			if(w == layout[camadas-2]){
				rede.camada[camadas-1].neuronio[k].dW[w] = 0.2*rede.camada[camadas-1].neuronio[k].bias + 0.2*rede.camada[camadas-1].neuronio[k].delta*rede.camada[camadas-1].neuronio[k].resultado;
			}else
			{
			rede.camada[camadas-1].neuronio[k].dW[w] = 0.2*rede.camada[camadas-1].neuronio[k].dW[w] + 0.2*rede.camada[camadas-1].neuronio[k].delta*rede.camada[camadas-1].neuronio[k].resultado;
			printf("dw %f&\tpeso %f\tdelta %f\n",rede.camada[camadas-1].neuronio[k].dW[w],rede.camada[camadas-1].neuronio[k].peso[w],rede.camada[camadas-1].neuronio[k].delta);
			}
			}
	}
	for(int i = camadas-2; i > 0; i--){
		printf("Camada %i:\n",i);
		for (int j = 0; j < layout[i]; j++){
			printf("\tNeuronio %i:\n",j);
			for (int w = 0; w < layout[i-1]+1; w++){
				if(w == layout[i-1]){
					rede.camada[i].neuronio[j].dW[w] = 0.2*rede.camada[i].neuronio[j].bias + 0.2*rede.camada[i].neuronio[j].delta*rede.camada[i].neuronio[j].resultado;
				}else{
				rede.camada[i].neuronio[j].dW[w] = 0.2*rede.camada[i].neuronio[j].dW[w] + 0.2*rede.camada[i].neuronio[j].delta*rede.camada[i].neuronio[j].resultado;
				}
				//printf("%f&&\n",rede.camada[i].neuronio[j].dW[w]);
				printf("dw %f&\tpeso %f\tdelta %f\n",rede.camada[i].neuronio[j].dW[w],rede.camada[i].neuronio[j].peso[w],rede.camada[i].neuronio[j].delta);
			}
		}
	}
	}
	
	//Atualizacao dos pesos
	for (int i = 1; i < camadas; i++){
		for (int j = 0; j < layout[i]; j++){
			for (int w = 0; w < layout[i-1]+1; w++){
				if(w == layout[i-1]){
					printf("\n%i\n",w);
					//system("pause");
					//rede.camada[i].neuronio[j].bias += rede.camada[i].neuronio[j].dW[w];	
				}else{
				rede.camada[i].neuronio[j].peso[w] += rede.camada[i].neuronio[j].dW[w];
				}
			}
		}
	}
	
	}
	}
	
	//Visualizador de informações da rede
	printf("\n\n");
	for (int i = 0; i < camadas; i++){
		printf("%i ", layout[i]);
	}
	printf("\n");
	getchar();
	
	for (int i = 0; i < camadas; i++){
		printf("Camada %i:\n",i);
		for (int j = 0; j < layout[i]; j++){
			printf("\tNeuronio %i:\n",j);
			if (i == 0){
				printf("\t\tPesos %i: %f    ", i, rede.camada[i].neuronio[j].peso[0]);
				printf("\t\tEntrada %i: %f\n", i, rede.camada[i].neuronio[j].entrada[0]);
			}
			else{
			for (int a = 0; a < layout[i-1]; a++){
				printf("\t\tPesos %i: %f    ", a, rede.camada[i].neuronio[j].peso[a]);
				printf("\t\tEntrada %i: %f\n", i, rede.camada[i].neuronio[j].entrada[a]);
			}
			}
			printf("\t\tBias: %f\n", rede.camada[i].neuronio[j].bias);
			printf("\t\tDelta: %f\n", rede.camada[i].neuronio[j].delta);
			printf("\t\tResultado %i: %f\n", i, rede.camada[i].neuronio[j].resultado);
		}
	}
	printf("\t\tResultado %f | %f\n", res[0],res[1]);
	
	return 0;
}

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×