src/main/java/ru/neuron/deeplearning4j/DL4JKmToMiles.java - master - inur/one_neuron

src/main/java/ru/neuron/deeplearning4j/DL4JKmToMiles.java
70 строк3 KB
Ilshat Nurgalimov
neuron
13 апр 2025, 18:57
13 апр 2025, 18:575a66525
package ru.neuron.deeplearning4j;

import org.deeplearning4j.nn.api.OptimizationAlgorithm;
import org.deeplearning4j.nn.conf.MultiLayerConfiguration;
import org.deeplearning4j.nn.conf.NeuralNetConfiguration;
import org.deeplearning4j.nn.conf.layers.OutputLayer;
import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
import org.nd4j.linalg.activations.Activation;
import org.nd4j.linalg.dataset.DataSet;
import org.nd4j.linalg.factory.Nd4j;
import org.nd4j.linalg.learning.config.Sgd;
import org.nd4j.linalg.lossfunctions.LossFunctions;

import java.util.Scanner;
import java.util.logging.Logger;
import java.util.stream.IntStream;

import static ru.neuron.CONST.*;

public class DL4JKmToMiles {

    private static final Logger LOGGER = Logger.getLogger(DL4JKmToMiles.class.getName());
    private static final MultiLayerNetwork MODEL = getMultiLayerNetwork();

    public static void main(String[] args) {
        // Прогнозируемое значение
        try (Scanner scanner = new Scanner(System.in)) {
            LOGGER.info("Введите кол-во километров для перевода в мили или \"%s\" для выхода:".formatted(EXIT));
            while (true) {
                String value = scanner.nextLine();
                if (value.equalsIgnoreCase(EXIT)) {
                    break;
                }
                double kmInput = Double.parseDouble(value);
                var kmVec = Nd4j.create(new double[]{kmInput}, new int[]{1, 1});
                LOGGER.info("Predicted miles: %.9f%n".formatted(MODEL.output(kmVec, false).getDouble(0)));
            }
        } catch (Exception e) {
            LOGGER.warning(e.getMessage());
        }
    }

    private static MultiLayerNetwork getMultiLayerNetwork() {
        int LAYER_COUNT = 1;
        var input = Nd4j.create(KM, new int[]{KM.length, LAYER_COUNT});
        var labels = Nd4j.create(MILES, new int[]{MILES.length, LAYER_COUNT});
        DataSet dataSet = new DataSet(input, labels);
        MultiLayerConfiguration conf = buildMultiLayerConfiguration(LAYER_COUNT);
        MultiLayerNetwork model = new MultiLayerNetwork(conf);
        model.init();
        IntStream.range(0, EPOCHS).forEach(i -> model.fit(dataSet));
        return model;
    }

    private static MultiLayerConfiguration buildMultiLayerConfiguration(int LAYER_COUNT) {
        OutputLayer layer = new OutputLayer.Builder()
                .nIn(LAYER_COUNT)
                .nOut(LAYER_COUNT)
                .activation(Activation.IDENTITY)
                .lossFunction(LossFunctions.LossFunction.MSE)
                .build();
        MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
                .optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)
                .updater(new Sgd(LEARNING_RATE))
                .list()
                .layer(layer)
                .build();
        return conf;
    }
}