请使用Java代码写一个预测价格的BP神经网络算法代码，并将输出的值缩放回原始的量级范围

好的，以下是预测价格的BP神经网络算法的Java代码：

import java.util.Random;

public class BPNeuralNetwork {
    private int inputSize;          // 输入层节点数
    private int hiddenSize;         // 隐藏层节点数
    private int outputSize;         // 输出层节点数
    private double[][] inputHiddenWeights;   // 输入层到隐藏层的权重矩阵
    private double[][] hiddenOutputWeights;  // 隐藏层到输出层的权重矩阵
    private double[] hiddenBiases;  // 隐藏层的偏置
    private double[] outputBiases;  // 输出层的偏置
    private double learningRate;    // 学习率

    public BPNeuralNetwork(int inputSize, int hiddenSize, int outputSize, double learningRate) {
        this.inputSize = inputSize;
        this.hiddenSize = hiddenSize;
        this.outputSize = outputSize;
        this.learningRate = learningRate;
        
        // 初始化权重与偏置
        inputHiddenWeights = new double[inputSize][hiddenSize];
        hiddenOutputWeights = new double[hiddenSize][outputSize];
        hiddenBiases = new double[hiddenSize];
        outputBiases = new double[outputSize];
        Random random = new Random();
        for (int i = 0; i < inputSize; i++) {
            for (int j = 0; j < hiddenSize; j++) {
                inputHiddenWeights[i][j] = random.nextDouble();
            }
        }
        for (int i = 0; i < hiddenSize; i++) {
            for (int j = 0; j < outputSize; j++) {
                hiddenOutputWeights[i][j] = random.nextDouble();
            }
            hiddenBiases[i] = random.nextDouble();
        }
        for (int i = 0; i < outputSize; i++) {
            outputBiases[i] = random.nextDouble();
        }
    }

    // sigmoid激活函数
    private double sigmoid(double x) {
        return 1 / (1 + Math.exp(-x));
    }

    // 前向传播
    public double[] forward(double[] input) {
        double[] hiddenOutputs = new double[hiddenSize];
        double[] outputs = new double[outputSize];
        for (int i = 0; i < hiddenSize; i++) {
            double sum = 0;
            for (int j = 0; j < inputSize; j++) {
                sum += input[j] * inputHiddenWeights[j][i];
            }
            hiddenOutputs[i] = sigmoid(sum + hiddenBiases[i]);
        }
        for (int i = 0; i < outputSize; i++) {
            double sum = 0;
            for (int j = 0; j < hiddenSize; j++) {
                sum += hiddenOutputs[j] * hiddenOutputWeights[j][i];
            }
            outputs[i] = sigmoid(sum + outputBiases[i]);
        }
        return outputs;
    }

    // 反向传播
    public void backward(double[] input, double[] target, double[] outputs) {
        double[] outputErrors = new double[outputSize];
        double[] hiddenErrors = new double[hiddenSize];
        for (int i = 0; i < outputSize; i++) {
            outputErrors[i] = (target[i] - outputs[i]) * outputs[i] * (1 - outputs[i]);
            for (int j = 0; j < hiddenSize; j++) {
                hiddenOutputWeights[j][i] += learningRate * hiddenOutputs[j] * outputErrors[i];
            }
            outputBiases[i] += learningRate * outputErrors[i];
        }
        for (int i = 0; i < hiddenSize; i++) {
            double sum = 0;
            for (int j = 0; j < outputSize; j++) {
                sum += outputErrors[j] * hiddenOutputWeights[i][j];
            }
            hiddenErrors[i] = sum * hiddenOutputs[i] * (1 - hiddenOutputs[i]);
            for (int j = 0; j < inputSize; j++) {
                inputHiddenWeights[j][i] += learningRate * input[j] * hiddenErrors[i];
            }
            hiddenBiases[i] += learningRate * hiddenErrors[i];
        }
    }

    // 训练
    public void train(double[][] inputs, double[][] targets, int epochs) {
        for (int i = 0; i < epochs; i++) {
            double error = 0;
            for (int j = 0; j < inputs.length; j++) {
                double[] outputs = forward(inputs[j]);
                backward(inputs[j], targets[j], outputs);
                for (int k = 0; k < outputSize; k++) {
                    error += Math.pow(targets[j][k] - outputs[k], 2);
                }
            }
            System.out.println("Epoch " + (i + 1) + ", Error: " + error);
        }
    }

    // 缩放回原始的量级范围
    public double scaleBack(double value, double min, double max) {
        return value * (max - min) + min;
    }
}

使用时，可以先构造一个`BPNeuralNetwork`对象，然后调用其`train`方法进行训练，最后调用其`forward`方法进行预测。例如，以下是一个使用该类预测房价的示例代码：

public class Main {
    public static void main(String[] args) {
        double[][] inputs = {{0.2, 0.3, 0.4}, {0.5, 0.6, 0.7}, {0.8, 0.9, 1.0}};  // 输入数据
        double[][] targets = {{0.5}, {0.6}, {0.7}};  // 目标数据
        BPNeuralNetwork nn = new BPNeuralNetwork(3, 4, 1, 0.1);  // 构造神经网络
        nn.train(inputs, targets, 10000);  // 训练神经网络
        double[] testInput = {0.3, 0.4, 0.5};  // 测试数据
        double[] outputs = nn.forward(testInput);  // 预测结果
        double outputValue = nn.scaleBack(outputs[0], 0, 1);  // 缩放回原始的量级范围
        System.out.println("Predicted value: " + outputValue);
    }
}

其中，`inputs`和`targets`分别为输入数据和目标数据，`nn`为构造的神经网络，`nn.train(inputs, targets, 10000)`表示对神经网络进行10000轮训练，`testInput`为测试数据，`outputs`为预测结果，`outputValue`为缩放回原始的量级范围后的预测结果。