神经网络实现（一）（基于Java）

版权声明：转载请注明出处 https://blog.csdn.net/github_37412255/article/details/80260828

设计了三个类

神经元

package org.nn.component;

/**
 * 神经元<hr>
 * 创建方式如：<br>
 * Neural neural = new Neural(1.2125);// 输入参数为神经元的输入值，类型了double
 * @author Weibing Long<br>
 * @since 2017.11.23
 * 
 */
public class Neural {
    /**
     * 神经元的输入值
     */
    private double inputValue;

    /**
     * 神经元的输出值
     */
    private double outputValue;

    /**
     * 神经元的激活函数对象
     */
    private ActivationFunction activationFunction;

    /**
     * 创建输入值为inputValue的神经元
     * @param inputValue 神经元输入值
     */
    public Neural(double inputValue) {
        this.inputValue = inputValue;
    }

    /**
     * 获取神经元输入值
     * @return 神经元输入值 --> double
     */
    public double getInputValue() {
        return inputValue;
    }

    /**
     * 设置神经元输入值
     * @param inputValue 神经元输入值 --> double
     */
    public void setInputValue(double inputValue) {
        this.inputValue = inputValue;
    }

    /**
     * 获取神经元输出值
     * @return 神经元输出值 --> double
     */
    public double getOutputValue() {
        return outputValue;
    }

    /**
     * 设置神经元输出值
     * @param outputValue 神经元输入值 --> double
     */
    public void setOutputValue(double outputValue) {
        this.outputValue = outputValue;
    }

    /**
     * 获取激活函数对象
     * @return 激活函数对象 --> ActivationFunction
     */
    public ActivationFunction getActivationFunction() {
        return activationFunction;
    }

    /**
     * 设置激活函数对象
     * @param activationFunction 激活函数对象 --> ActivationFunction
     */
    public void setActivationFunction(ActivationFunction activationFunction) {
        this.activationFunction = activationFunction;
    }

    @Override
    public String toString() {      
        return new String("[类型：Nueral；输入值：" + Double.toString(inputValue)
                   + "；输出值：" + outputValue + "]"
               );       
    }

}

• 神经层

package org.nn.component;

import java.util.*;

/**
 * 神经层
 * @author Weibing Long
 * @since 2018.5.09
 */
public class NeuralLayer implements Iterable<Neural> {

    /**
     * 该神经层上所有的神经元
     */
    private List<Neural> allNeurals;

    /**
     * 该神经层上神经元的个数
     */
    private int neuralNumbers = 0;

    /**
     * 创建神经层对象
     * @param allNeurals 所有的神经元 --> List< Neural >
     */
    public NeuralLayer(List<Neural> allNeurals) {
        this.allNeurals = allNeurals;
        this.neuralNumbers = allNeurals.size();
    }

    /**
     * 创建神经元对象，只需指定神经元个数即可，自动将神经元输入值设置为默认值0.0
     * @param neuralNumbers 定神经元个数 --> int
     */
    public NeuralLayer(int neuralNumbers) {
        this.allNeurals = new LinkedList<Neural>();
        for (int i = 0; i < neuralNumbers; i++) {
            Neural tempNeural = new Neural(0.0);
            this.allNeurals.add(tempNeural);
        }
        this.neuralNumbers = allNeurals.size();
    }

    /**
     * 获取神经元个数
     * @return 神经元个数 --> int
     */
    public int size() {
        return neuralNumbers;
    }

    /**
     * 获取所有的神经元
     * @return 所有的神经元 --> List< Neural >
     */
    public List<Neural> getAllNeurals() {
        return allNeurals;
    }

    /**
     * 设置所有的神经元
     * @param allNeurals 所有的神经元 --> List< Neural >
     */
    public void setAllNeurals(List<Neural> allNeurals) {
        this.allNeurals = allNeurals;
    }

    @Override
    public String toString() {
        String layer = "[";
        for (int i = 0; i < size(); i++) {
            layer += allNeurals.get(i).toString();
            if (i < size() - 1) {
                layer += "，";
            } 
        }
        layer = layer + "]";
        return layer;
    }

    @Override
    public Iterator<Neural> iterator() {
        return new Iterator<Neural>() {
            private int firstIndex = 0;

            @Override
            public boolean hasNext() {
                return firstIndex < allNeurals.size();
            }

            @Override
            public Neural next() {
                return allNeurals.get(firstIndex++);
            }

        };
    }

    public static void main(String[] args) {
        // 创建神经层方式一：
        NeuralLayer inputLayer = new NeuralLayer(10);
        System.out.println(inputLayer);

        // 创建神经层方式一：
        List<Neural> allNeural = new LinkedList<Neural>();
        for (int i = 0; i < 10; i++) {
            allNeural.add(new Neural(1.0));
        }
        NeuralLayer hiddenLayer = new NeuralLayer(allNeural);
        System.out.println(hiddenLayer);

        // 神经层的for-each用法
        for (Neural neural : hiddenLayer) {
            System.out.println(neural);
        }
    }
}

神经网络

package org.nn.component;

import java.util.*;

/**
 * 神经网络
 * 
 * @author 龙卫兵
 * @since 2017.11.24
 * 
 */
public class NeuralNetwork implements Iterable<NeuralLayer> {
    /**
     * 神经网络所有的层
     */
    private List<NeuralLayer> allLayers;

    /**
     * 神经网络的层数
     */
    private int layerCount;

    /**
     * 构建神经网络
     * @param allLayers 所有的神经层--> List< NeuralLayer >
     */
    public NeuralNetwork(List<NeuralLayer> allLayers) {
        this.allLayers = allLayers;
        this.layerCount = allLayers.size();
    }

    /**
     * 构建神经网络
     * @param allLayerNeuralCount 神经网络拓扑 --> int[]
     */
    public NeuralNetwork(int[] allLayerNeuralCount) {
        allLayers = new ArrayList<NeuralLayer>(3);
        for (int i = 0; i < allLayerNeuralCount.length; i++) {
            int neuralCount = allLayerNeuralCount[i];
            NeuralLayer neural = new NeuralLayer(neuralCount);
            allLayers.add(neural);
        }
        this.layerCount = allLayerNeuralCount.length;
    }

    /**
     * 神经网络层数
     * @return 神经网络层数 --> int
     */
    public int size() {
        return this.layerCount;
    }

    /**
     * 获取神经网络所有的层
     * @return 神经网络所有的层 --> List< NeuralLayer >
     */
    public List<NeuralLayer> getAllLayers() {
        return allLayers;
    }

    /**
     * 设置神经网络所有的层
     * @param allLayers 神经网络所有的层 --> List< NeuralLayer >
     */
    public void setAllLayers(List<NeuralLayer> allLayers) {
        this.allLayers = allLayers;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("{" + "\n");
        sb.append("类型：NeuralNetwork；层数：" + layerCount + "；\n");
        for (int i = 0; i < layerCount; i++) {
            sb.append("第" + i + "层神经元个数：" + allLayers.get(i).size() + "\n");
        }
        for (int i = 0; i < layerCount; i++) {
            sb.append(allLayers.get(i).toString() + "\n");
        }
        sb.append("}");
        return sb.toString();

    }

    @Override
    public Iterator<NeuralLayer> iterator() {
        return new Iterator<NeuralLayer>() {
            private int firstIndex;

            @Override
            public boolean hasNext() {
                return firstIndex < layerCount;
            }

            @Override
            public NeuralLayer next() {
                return allLayers.get(firstIndex++);
            }  
        };
    }

    /**
     * 返回可迭代的神经网络：从输出层到输入层（逆序）<br>
     * 这里类似于适配器模式
     * @return 可迭代对象 --> Iterable< NeuralLayer >
     */
    public Iterable<NeuralLayer> reverse() {
        return new Iterable<NeuralLayer>() {
            @Override
            public Iterator<NeuralLayer> iterator() {
                return new Iterator<NeuralLayer>() {
                    private int lastIndex = layerCount - 1;

                    @Override
                    public boolean hasNext() {
                        return lastIndex >= 0;
                    }

                    @Override
                    public NeuralLayer next() {
                        return allLayers.get(lastIndex--);
                    }
                };
            }            
        };  
    }

    public static void main(String[] args) {     
        NeuralNetwork neuralNetwork = new NeuralNetwork(new int[] {2, 3, 4});
        System.out.println(neuralNetwork);

        // for-each遍历
        for (NeuralLayer neuralLayer : neuralNetwork) {
            System.out.println(neuralLayer);
        }

     // for-each逆序遍历
        for (NeuralLayer neuralLayer : neuralNetwork.reverse()) {
            System.out.println(neuralLayer);
        }
    }
}

调用方式(这里只列了一种，还有另一种神经网络构建方式，具体请看相关构造器)

        NeuralNetwork neuralNetwork = new NeuralNetwork(new int[] {2, 3, 4});
        System.out.println(neuralNetwork);

        // for-each遍历
        for (NeuralLayer neuralLayer : neuralNetwork) {
            System.out.println(neuralLayer);
        }

        // for-each逆序遍历
        for (NeuralLayer neuralLayer : neuralNetwork.reverse()) {
            System.out.println(neuralLayer);
        }

输出结果

{
类型：NeuralNetwork；层数：3；
第0层神经元个数：2
第1层神经元个数：3
第2层神经元个数：4
[[类型：Nueral；输入值：0.0；输出值：0.0]，[类型：Nueral；输入值：0.0；输出值：0.0]]
[[类型：Nueral；输入值：0.0；输出值：0.0]，[类型：Nueral；输入值：0.0；输出值：0.0]，[类型：Nueral；输入值：0.0；输出值：0.0]]
[[类型：Nueral；输入值：0.0；输出值：0.0]，[类型：Nueral；输入值：0.0；输出值：0.0]，[类型：Nueral；输入值：0.0；输出值：0.0]，[类型：Nueral；输入值：0.0；输出值：0.0]]
}
[[类型：Nueral；输入值：0.0；输出值：0.0]，[类型：Nueral；输入值：0.0；输出值：0.0]]
[[类型：Nueral；输入值：0.0；输出值：0.0]，[类型：Nueral；输入值：0.0；输出值：0.0]，[类型：Nueral；输入值：0.0；输出值：0.0]]
[[类型：Nueral；输入值：0.0；输出值：0.0]，[类型：Nueral；输入值：0.0；输出值：0.0]，[类型：Nueral；输入值：0.0；输出值：0.0]，[类型：Nueral；输入值：0.0；输出值：0.0]]
[[类型：Nueral；输入值：0.0；输出值：0.0]，[类型：Nueral；输入值：0.0；输出值：0.0]，[类型：Nueral；输入值：0.0；输出值：0.0]，[类型：Nueral；输入值：0.0；输出值：0.0]]
[[类型：Nueral；输入值：0.0；输出值：0.0]，[类型：Nueral；输入值：0.0；输出值：0.0]，[类型：Nueral；输入值：0.0；输出值：0.0]]
[[类型：Nueral；输入值：0.0；输出值：0.0]，[类型：Nueral；输入值：0.0；输出值：0.0]]

存在的不足

神经元实现中未添加权重，偏置值等参数

难点

• 反向传播算法实现
• 阈值函数实现
• 评价标准实现
• 代码异常情况发现