Java写神经网络算法
时间: 2023-11-14 20:20:57 浏览: 30
作为AI领域的重要应用,神经网络在Java中也有着广泛的应用。下面是一个简单的Java神经网络算法实现:
首先,定义神经元类:
```
public class Neuron {
private double[] weights;
private double output;
public Neuron(int numInputs) {
weights = new double[numInputs];
for (int i = 0; i < numInputs; i++) {
weights[i] = Math.random();
}
}
public double getOutput() {
return output;
}
public void setOutput(double output) {
this.output = output;
}
public double[] getWeights() {
return weights;
}
public void setWeights(double[] weights) {
this.weights = weights;
}
public double calculateOutput(double[] inputs) {
double sum = 0;
for (int i = 0; i < inputs.length; i++) {
sum += inputs[i] * weights[i];
}
output = sigmoid(sum);
return output;
}
private double sigmoid(double x) {
return 1 / (1 + Math.exp(-x));
}
}
```
神经元类中包含了权重数组、输出值以及计算输出值的方法。其中,sigmoid函数用于将神经元的输出值映射到0~1之间。
接着,定义神经网络类:
```
public class NeuralNetwork {
private Neuron[] inputLayer;
private Neuron[] hiddenLayer;
private Neuron outputNeuron;
public NeuralNetwork(int numInputs, int numHiddenNeurons) {
inputLayer = new Neuron[numInputs];
hiddenLayer = new Neuron[numHiddenNeurons];
outputNeuron = new Neuron(numHiddenNeurons);
for (int i = 0; i < numInputs; i++) {
inputLayer[i] = new Neuron(1);
}
for (int i = 0; i < numHiddenNeurons; i++) {
hiddenLayer[i] = new Neuron(numInputs);
}
}
public double[] calculateOutput(double[] inputs) {
double[] hiddenOutputs = new double[hiddenLayer.length];
for (int i = 0; i < hiddenLayer.length; i++) {
hiddenOutputs[i] = hiddenLayer[i].calculateOutput(inputs);
}
return new double[]{outputNeuron.calculateOutput(hiddenOutputs)};
}
public void train(double[] inputs, double targetOutput, double learningRate) {
double[] hiddenOutputs = new double[hiddenLayer.length];
for (int i = 0; i < hiddenLayer.length; i++) {
hiddenOutputs[i] = hiddenLayer[i].calculateOutput(inputs);
}
double output = outputNeuron.calculateOutput(hiddenOutputs);
double error = targetOutput - output;
double[] outputErrors = new double[hiddenLayer.length];
for (int i = 0; i < hiddenLayer.length; i++) {
outputErrors[i] = error * outputNeuron.getWeights()[i] * hiddenOutputs[i] * (1 - hiddenOutputs[i]);
double[] weights = hiddenLayer[i].getWeights();
for (int j = 0; j < weights.length; j++) {
weights[j] += learningRate * outputErrors[i] * inputs[j];
}
hiddenLayer[i].setWeights(weights);
}
double[] outputWeights = outputNeuron.getWeights();
for (int i = 0; i < outputWeights.length; i++) {
outputWeights[i] += learningRate * error * hiddenOutputs[i];
}
outputNeuron.setWeights(outputWeights);
}
}
```
神经网络类中包含了输入层、隐藏层和输出层神经元数组。在神经网络初始化时,生成输入层和隐藏层神经元,输出层神经元则在初始化隐藏层后生成。calculateOutput方法用于计算神经网络的输出值,train方法用于训练神经网络。
最后,可以使用以下代码进行测试:
```
public class Main {
public static void main(String[] args) {
NeuralNetwork nn = new NeuralNetwork(2, 2);
double[][] inputs = {{0, 0}, {0, 1}, {1, 0}, {1, 1}};
double[] targets = {0, 1, 1, 0};
for (int i = 0; i < 100000; i++) {
int index = (int) (Math.random() * inputs.length);
nn.train(inputs[index], targets[index], 0.1);
}
for (int i = 0; i < inputs.length; i++) {
double[] input = inputs[i];
double output = nn.calculateOutput(input)[0];
System.out.println(Arrays.toString(input) + " -> " + output);
}
}
}
```
该代码使用神经网络实现了异或逻辑运算。经过训练后,神经网络可以正确地输出异或运算的结果。