0
퍼셉트론 1 층에 도움이 필요합니다. 함수를 전달하기 위해 함수 sigmoide를 사용하고, 학습을 위해 알고리즘을 다시 전파합니다. 나는 A와 B를 계산하기위한 간단한 신경망을 만들고 싶다. 내 문제는 내가 2 값 (예 0과 0)을 넣고 IA가 나에게 항상 0.99를주는 것을 배우는 것입니다. 나는 코드를 3 번 보았고 왜 학습 후에 내 프로그램이 나쁜 대답을하는지 이해하지 못합니다. 도와주세요.퍼셉트론 1로 학습하는 동안 오류가 발생했습니다.
Neuron.java :
public class Neuron {
public double value;
public double[] weights;
public double bias;
public double deltas;
public Neuron(int nb_entree){
weights = new double[nb_entree];
value = Math.random()/10000000000000.0;
bias = Math.random()/10000000000000.0;
deltas = Math.random()/10000000000000.0;
for(int i = 0 ; i < weights.length ; i++){
weights[i] = Math.random()/10000000000000.0;
}
}
/***
* Function to evaluate a neurone with a sigmoide function
* @param input : list to input value
* @return the result of sigmoide function
*/
public double evaluate(double[] input){
double x = 0.0;
for(int i = 0 ; i < input.length ; i++){
x += input[i] * weights[i];
}
x += bias;
value = 1/(1 + Math.pow(Math.E, x));
return value;
}
//Function to delete value of neurons
protected void delete(){
value = 0.0;
}
}
NeuralNetwork.java :
public class NeuralNetwork {
public Neuron[] neurons_hidden;
public Neuron[] neurons_output;
public double rate_learning;
public int nb_hidden;
public int nb_output;
public NeuralNetwork(int nb_input, int nb_hid, int nb_out, double rate){
nb_hidden = nb_hid;
nb_output = nb_out;
rate_learning = rate;
neurons_hidden = new Neuron[nb_hidden];
neurons_output = new Neuron[nb_output];
//Create hidden neurons
for(int i = 0 ; i < nb_hidden ; i++){
neurons_hidden[i] = new Neuron(nb_input);
}
//Create output neurons
for(int i = 0 ; i < nb_output ; i++){
neurons_output[i] = new Neuron(nb_hidden);
}
}
public double[] evaluate(double[] input){
double[] output_hidden = new double[nb_hidden];
double[] outputs = new double[nb_output];
//we delete the value of hidden neurons
for(Neuron n : neurons_hidden){
n.delete();
}
//we delete the value of output neurons
for(Neuron n : neurons_output){
n.delete();
}
//Pour chaque neurone caches
for(int i = 0 ; i < nb_hidden ; i++){
output_hidden[i] = neurons_hidden[i].evaluate(input);
}
//Pour chaque neurone sortie
for(int i = 0 ; i < nb_output ; i++){
outputs[i] = neurons_output[i].evaluate(output_hidden);
}
return outputs;
}
public double backPropagate(double[] input, double[] output){
double[] output_o = evaluate(input);
double error;
int i;
int k;
//For all neurons output, we compute the deltas
for(i = 0 ; i < nb_output ; i++){
error = output[i] - output_o[i];
neurons_output[i].deltas = error * (output_o[i] - Math.pow(output_o[i], 2));
}
//For all neurons hidden, we compute the deltas
for(i = 0 ; i < nb_hidden ; i++){
error = 0.0;
for(k = 0 ; k < nb_output ; k++){
error += neurons_output[k].deltas * neurons_output[k].weights[i];
}
neurons_hidden[i].deltas = error * (neurons_hidden[i].value - Math.pow(neurons_hidden[i].value, 2));
}
//For all neurons output, we modify the weight
for(i = 0 ; i < nb_output ; i++){
for(k = 0 ; k < nb_hidden ; k++){
neurons_output[i].weights[k] += rate_learning *
neurons_output[i].deltas *
neurons_hidden[k].value;
}
neurons_output[i].bias += rate_learning * neurons_output[i].deltas;
}
//For all neurons hidden, we modify the weight
for(i = 0 ; i < nb_hidden ; i++){
for(k = 0 ; k < input.length ; k++){
neurons_hidden[i].weights[k] += rate_learning * neurons_hidden[i].deltas * input[k];
}
neurons_hidden[i].bias += rate_learning * neurons_hidden[i].deltas;
}
error = 0.0;
for(i = 0 ; i < output.length ; i++){
error += Math.abs(output_o[i] - output[i]);
}
error = error/output.length;
return error;
}
}
Test.java :
public class Test {
public static void main(String[] args) {
NeuralNetwork net = new NeuralNetwork(2, 2, 1, 0.6);
/* Learning */
for(int i = 0 ; i < 10000 ; i++)
{
double[] inputs = new double[]{Math.round(Math.random()), Math.round(Math.random())};
double[] output = new double[1];
double error;
if((inputs[0] == inputs[1]) && (inputs[0] == 1))
output[0] = 1.0;
else
output[0] = 0.0;
System.out.println(inputs[0]+" and "+inputs[1]+" = "+output[0]);
error = net.backPropagate(inputs, output);
System.out.println("Error at step "+i+" is "+error);
}
System.out.println("Learning finish!");
/* Test */
double[] inputs = new double[]{0.0, 0.0};
double[] output = net.evaluate(inputs);
System.out.println(inputs[0]+" and "+inputs[1]+" = "+output[0]+"");
}
}
덕분에
가