C Rede Neural - Problema com Resultados

JeffWPoe · 20 de novembro de 2018

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é).

malloc_ · 20 de novembro de 2018

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

JeffWPoe · 21 de novembro de 2018

Em 20/11/2018 às 23:08, 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

Expandir

#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;
}