ИИ написан на Java, который классифицирует четные и нечетные числа не работают [закрыто] ⇐ JAVA

[Anonymous]

Я изучаю нейронные сети, и в качестве практики я пытался сделать модель, которая классифицирует числа. Он принимает номера в качестве входов и выводит 1, если число равно или 0, если число нечетное. Но после множества изменений в коде я не могу заставить его работать < /p>
, прежде чем выйти в код и то, что выходит моя нейронная сеть, краткое изложение ее архитектуры: < /p>

1 -й уровень, вход: это только одно число, которое нейронная сеть должна классифицировать < /p>
< /li>
2 -й слой, скрытый: этот слой состоит из 5 нейронов. Каждый из них обрабатывает вход с уравнением y = вес * input + bias . Его функция активации - это протекающая relu < /p>
< /li>
3 -й слой, выход: этот слой берет каждый выход предыдущего слоя и умножает его на связанный с этим веса Суммирует из этого, как видно здесь: < /p>
< /li>
< /ul>
float sum_previous_outputs = output_bias;
for(int j = 0 ; j < hidden_layer_neurons ; j++) {
sum_previous_outputs += output_weights[j] * hidden_layer_outputs[j];
}

После этого он получает результат sum_previous_outputs и передавать его функции Sigmoid, которая возвращает окончательный ответ нейронной сети (0 или 1) < Br /> Это то, что он предсказывает на основе чисел от 1 до 5: < /p>
Prediction with input = 1: prediction = 0.46512857
Prediction with input = 2: prediction = 0.48425278
Prediction with input = 3: prediction = 0.5034232
Prediction with input = 4: prediction = 0.52258354
Prediction with input = 5: prediction = 0.54167765
< /code>
Обратите внимание, насколько медленно он учится даже с эпохами 9000000: < /p>
Значение потери на первой итерации: < /p>
< P>0. loss = 8.499304
Значение потери на последней итерации:
8999999. loss = 6.7793283
Я попытался настроить параметр Learning_rate , но даст его более широким результатом в моей нейронной сети Nan для значения потери и каждого Предсказание это также приводит к NAN . Для более низких значений Learning_Rate он «учится», но очень медленно, до такой степени, что увеличение эпох не имеет значения. Я тоже пытался увеличить количество нейронов, но результат - это то же самое < /p>
Это моя основная функция: < /p>
public class Main {
public static void main(String[] args) {
float training_data[] = {
1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f
};
float expected_data[] = {
0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f
};
int epochs = 9000000;
ClassificationAI ai = new ClassificationAI();
ai.train(training_data, expected_data, epochs);
for(int i = 1 ; i < 6 ; i++) {
System.out.println("Prediction with input = "+i+": prediction = "+ai.predict(i));
}
}
}

И это код классификации :
import java.util.Random;
//ORIGINAL
public class ClassificationAI {
//hidden layer
private static int hidden_layer_neurons = 5;
private float[] hidden_layer_weights = new float[hidden_layer_neurons];
private float[] hidden_layer_biases = new float[hidden_layer_neurons];
//output layer
private float[] output_weights = new float[hidden_layer_neurons];
private float output_bias;
public ClassificationAI() {
Random random = new Random();
for(int i = 0 ; i < hidden_layer_neurons ; i++) {
this.hidden_layer_weights = random.nextFloat(-1, 1);
this.hidden_layer_biases = 0;
}
for(int i = 0 ; i < hidden_layer_neurons ; i++) {
this.output_weights = random.nextFloat(-1, 1);
}
this.output_bias = 0;
}
private float leaky_relu(float x) {
return (x > 0) ? x : 0.01f * x;
}
private float forward_hidden_layer_neuron(float weight, float x, float bias) {
float input = weight * x + bias;
return leaky_relu(input);
}
private float sigmoid(float x) {
return (float)(1 / (1 + Math.pow(Math.E, -x)));
}
private float sigmoid_derivative(float x) {
float sig = sigmoid(x);
return sig * (1 - sig);
}
public void train(float[] training_data, float[] expected_data, int epochs) {
float learning_rate = 0.00001f;
for(int epoch = 0 ; epoch < epochs ; epoch++) {
float total_loss = 0;
for(int i = 0 ; i < training_data.length ; i++) {
float x = training_data;
float expected_x = expected_data;

//hidden layer
float[] hidden_layer_outputs = new float[hidden_layer_neurons];
for(int j = 0 ; j < hidden_layer_neurons ; j++) {
hidden_layer_outputs[j] = forward_hidden_layer_neuron(hidden_layer_weights[j], x, hidden_layer_biases[j]);
}

//output layer
float sum_previous_outputs = output_bias;
for(int j = 0 ; j < hidden_layer_neurons ; j++) {
sum_previous_outputs += output_weights[j] * hidden_layer_outputs[j];
}
float final_output = sigmoid(sum_previous_outputs);

//calculating loss
float epsilon = 1e-8f;
total_loss += (float) ((-1.0f)*(expected_x*Math.log(final_output + epsilon) + (1 - expected_x)*Math.log(1 - final_output + epsilon)));

//derivatives for output layer
float dc_ds = -((expected_x/final_output) - (1 - expected_x)/(1 - final_output));
float ds_dy = sigmoid_derivative(sum_previous_outputs);
//float dy_dow; this derivative is every single output of the previous layer
float dy_dob = 1;

float dc_dow = dc_ds * ds_dy/* every single dy_dow of previous layer */;
float dc_dob = dc_ds * ds_dy * dy_dob;

for(int j = 0 ; j < hidden_layer_neurons ; j++) {
output_weights[j] -= dc_dow * hidden_layer_outputs[j] * learning_rate;
}
output_bias -= dc_dob * learning_rate;

//derivatives for hidden layer
for(int j = 0 ; j < hidden_layer_neurons ; j++) {
float hidden_layer_processed_x = hidden_layer_weights[j] * x + hidden_layer_biases[j];
float dR_dy = (hidden_layer_processed_x

Подробнее здесь: https://stackoverflow.com/questions/794 ... oesnt-work