가르쳐 어떻게 신경 네트워크의 자바 구현을 사용하는

운영 결과에서 첫번째보기 :

여기에 전체 프로젝트 디렉토리는 다음과 같습니다

---

0 신경망 개요를 구현

층 신경망 뉴런, 가중치 및 바이어스 구성된 활성화 기능. 각각은 하나 개 이상의 뉴런 각 뉴런 및 무게 인 뉴럴 입 / 출력 연결을 갖는다.
뉴런의 수는 각 요소가 다를 수 있기 때문에, 신경 네트워크는 많은 숨겨진 층도 더있을 수있을 수 있다는 것을 강조하는 것이 중요하다. 그러나, 입력 / 출력 개수 신경망의 입력 및 출력 뉴런 층의 수는 동일하다.
위해 우리는 다음과 같은 범주를 정의 할 필요가 있음을 달성하기 위해 :

• 신경 세포 : 인공 뉴런의 정의
• NeuralLayer : 신경 세포 층을 정의하는 추상 클래스.
• InputLayer : 신경망의 입력 층의 정의
• HiddenLayer는 : 입력 층의 층과 층 사이에 출력 정의
• OutputLayer는 : 뉴럴 출력 계층을 정의한다.
• InputNeuron : 입력 뉴런이 나타납니다 신경 네트워크를 정의했다.
• NeuralNet : 이전에 정의 된 모든 클래스 ANN 구조.

이러한 클래스뿐만 아니라, 우리는 또한 IActivationFunction 인터페이스 활성화 함수를 정의 할 필요가있다. 기동 기능과 유사한 방법은, 속성 할당 뉴런으로 요구하기 때문에 필요하다. 그래서 당신은 IActivationFunction 인터페이스를 구현해야 클래스의 함수 정의를 활성화하려면 :

• 선의
• S 상
• 단계
• HyperTan

인코딩 첫 번째 챕터는 기본적으로 완료했다. 또한, 우리는 두 개의 클래스를 정의 할 필요가있다. 예외 처리 (NeuralException), 난수 (RandomNumberGenerator)를 생성하기위한 하나. 마지막으로, 각각 두 개의 패키지에 이러한 클래스.

---

1. 클래스 뉴런 신경 세포

뉴런 클래스는이 장에서 기본 클래스 코드입니다. 인공 뉴런의 이론에 따르면, 다음과 같은 속성

• 기입
• 무게
• 바이어스
• 활성화 기능
• 수출

첫 번째 뉴런의 다양한 속성을 정의한다 :

public class Neuron {
    //神经元相关的权重
    protected ArrayList<Double> weight;
    //神经元的输入
    private ArrayList<Double> input;
    //这个神经元的输出，由激活函数产生
    private Double output;
    //传递给激活函数的值
    private Double outputBeforeActivation;
    //输入的数量。如果为0，则表示神经元尚未初始化。
    private int numberOfInputs = 0;
    //神经元的偏差。除了第一层，其他都应该是1.0。
    protected Double bias = 1.0;
    //神经元的激活函数
    private IActivationFunction activationFunction;
}

뉴런 인스턴스화되면, 번호 입력 데이터의 활성화 기능을 지정. 생성자은 다음과 같습니다 :

    public Neuron(int numberofinputs,IActivationFunction iaf){
        numberOfInputs=numberofinputs;
        weight=new ArrayList<>(numberofinputs+1);
        input=new ArrayList<>(numberofinputs);
        activationFunction=iaf;
    }

바이어스는 다른 무게를 정의합니다. 중요한 단계, 즉, 신경원을 초기화하는 초기 값에 할당 된 가중치이다. 이것은 주로 () 메소드가 완료된 초기화하고, 난수 발생기 RandomNumberGenerator 정적 클래스에 의해 생성 된 난수는 가중치를 할당. 참고 : 가중치를 설정할 때 체중 배열 범위를 방지 할 필요가있다.

public void init(){
        if(numberOfInputs>0){
            for(int i=0;i<=numberOfInputs;i++){
                double newWeight = RandomNumberGenerator.GenerateNext();
                try{
                    this.weight.set(i, newWeight);
                }
                catch(IndexOutOfBoundsException iobe){
                    this.weight.add(newWeight);
                }
            }
        }
    }
    

마지막 석회질 () 메소드에 출력 값 :

public void calc(){
        outputBeforeActivation=0.0;
        if(numberOfInputs>0){
            if(input!=null && weight!=null){
                for(int i=0;i<=numberOfInputs;i++){
                    outputBeforeActivation+=(i==numberOfInputs?bias:input.get(i))*weight.get(i);
                }
            }
        }
        output=activationFunction.calc(outputBeforeActivation);
    }

우선 필요성이 결과는 속성 outputBeforeActivation에 저장된다 (전 - OfInputs == 번호는 바이어스가 최종 무게를) 모든 권리 성과 합계를 다시 입력한다. 출력 뉴런의 활성 함수는이 값을 사용하여 계산.

다음과 같이 전체 코드는 다음과 같습니다

package neuralnet;

import java.util.ArrayList;

public class Neuron {
    //神经元相关的权重
    protected ArrayList<Double> weight;
    //神经元的输入
    private ArrayList<Double> input;
    //这个神经元的输出，由激活函数产生
    private Double output;
    //传递给激活函数的值
    private Double outputBeforeActivation;
    //输入的数量。如果为0，则表示神经元尚未初始化。
    private int numberOfInputs = 0;
    //神经元的偏差。除了第一层，其他都应该是1.0。
    protected Double bias = 1.0;
    //神经元的激活函数
    private IActivationFunction activationFunction;
    public Neuron(){
        
    }
    public Neuron(int numberofinputs){
        numberOfInputs=numberofinputs;
        weight=new ArrayList<>(numberofinputs+1);
        input=new ArrayList<>(numberofinputs);
    }
    public Neuron(int numberofinputs,IActivationFunction iaf){
        numberOfInputs=numberofinputs;
        weight=new ArrayList<>(numberofinputs+1);
        input=new ArrayList<>(numberofinputs);
        activationFunction=iaf;
    }
    public void init(){
        if(numberOfInputs>0){
            for(int i=0;i<=numberOfInputs;i++){
                double newWeight = RandomNumberGenerator.GenerateNext();
                try{
                    this.weight.set(i, newWeight);
                }
                catch(IndexOutOfBoundsException iobe){
                    this.weight.add(newWeight);
                }
            }
        }
    }
    public void setInputs(double [] values){
        if(values.length==numberOfInputs){
            for(int i=0;i<numberOfInputs;i++){
                try{
                    input.set(i, values[i]);
                }
                catch(IndexOutOfBoundsException iobe){
                    input.add(values[i]);
                }
            }
        }
    }
    public void setInputs(ArrayList<Double> values){
        if(values.size()==numberOfInputs){
            input=values;
        }
    }
    public ArrayList<Double> getArrayInputs(){
        return input;
    }
    public double[] getInputs(){
        double[] inputs = new double[numberOfInputs];
        for (int i=0;i<numberOfInputs;i++){
            inputs[i]=this.input.get(i);
        }
        return inputs;
    }
    public void setInput(int i,double value){
        if(i>=0 && i<numberOfInputs){
            try{
                input.set(i, value);
            }
            catch(IndexOutOfBoundsException iobe){
                input.add(value);
            }
        }
    }
    public double getInput(int i){
        return input.get(i);
    }
    public double[] getWeights(){
        double[] weights = new double[numberOfInputs+1];
        for(int i=0;i<=numberOfInputs;i++){
            weights[i]=weight.get(i);
        }
        return weights;
    }
    public ArrayList<Double> getArrayWeights(){
        return weight;
    }
    public void updateWeight(int i, double value){
        if(i>=0 && i<=numberOfInputs){
            weight.set(i, value);
        }
    }
    public int getNumberOfInputs(){
        return this.numberOfInputs;
    }
    public void setWeight(int i,double value) throws NeuralException{
        if(i>=0 && i<numberOfInputs){
            this.weight.set(i, value);
        }
        else{
            throw new NeuralException("Invalid weight index");
        }
    }
   
    public double getOutput(){
        return output;
    }
    
    public void calc(){
        outputBeforeActivation=0.0;
        if(numberOfInputs>0){
            if(input!=null && weight!=null){
                for(int i=0;i<=numberOfInputs;i++){
                    outputBeforeActivation+=(i==numberOfInputs?bias:input.get(i))*weight.get(i);
                }
            }
        }
        output=activationFunction.calc(outputBeforeActivation);
    }
   
    public void setActivationFunction(IActivationFunction iaf){
        this.activationFunction=iaf;
    }
    
    public double getOutputBeforeActivation(){
        return outputBeforeActivation;
    }
}

---

2.NeuralLayer 클래스

이 클래스에서, 뉴런 그룹화 동일한 층에 정렬 될 것이다. 필요한 하나의 다른 값을 전달하기 때문에, 필요 층간 접속을 정의한다. 다음과 같이 정의 클래스를 속성 :

//这一层的神经元数量
    protected int numberOfNeuronsInLayer;
    //这一层的神经元
    private ArrayList<Neuron> neuron;
    //激励函数
    protected IActivationFunction activationFnc;
    //将值提供给此层的前一层 
    protected NeuralLayer previousLayer;
    protected NeuralLayer nextLayer;
    protected ArrayList<Double> input;
    protected ArrayList<Double> output;
    protected int numberOfInputs;

클래스는 추상적이고, 전체 층 인스턴스화 할 수있는 클래스는 InputLayer, HiddenLayer 및 OUTP-utLayer입니다. 클래스는 다른 클래스의 생성자를 사용해야합니다 생성되어이 유사한 클래스 생성자가 있습니다.

초기화 및 층 뉴런 계산은 또한 초기화 () 메소드 CALC () 메소드를 구현. 헤이 만 서브 클래스가 호출하거나 이러한 메소드를 오버라이드 (override) 할 수 있도록, 삶의 유형을 보호.

다음과 같이 모든 코드는 다음과 같습니다

package neuralnet;

import java.util.ArrayList;


public abstract class NeuralLayer {
    //这一层的神经元数量
    protected int numberOfNeuronsInLayer;
    //这一层的神经元
    private ArrayList<Neuron> neuron;
    //激励函数
    protected IActivationFunction activationFnc;
    //将值提供给此层的前一层 
    protected NeuralLayer previousLayer;
    protected NeuralLayer nextLayer;
    protected ArrayList<Double> input;
    protected ArrayList<Double> output;
    protected int numberOfInputs;
   
    public NeuralLayer(int numberofneurons){
        this.numberOfNeuronsInLayer=numberofneurons;
        neuron = new ArrayList<>(numberofneurons);
        output = new ArrayList<>(numberofneurons);
    }
    
    public NeuralLayer(int numberofneurons,IActivationFunction iaf){
        this.numberOfNeuronsInLayer=numberofneurons;
        this.activationFnc=iaf;
        neuron = new ArrayList<>(numberofneurons);
        output = new ArrayList<>(numberofneurons);
    }
    public int getNumberOfNeuronsInLayer(){
        return numberOfNeuronsInLayer;
    }
    
    public ArrayList<Neuron> getListOfNeurons(){
        return neuron;
    }
    
    protected NeuralLayer getPreviousLayer(){
        return previousLayer;
    }
    
    protected NeuralLayer getNextLayer(){
        return nextLayer;
    }
    
    protected void setPreviousLayer(NeuralLayer layer){
        previousLayer=layer;
    }
    
    protected void setNextLayer(NeuralLayer layer){
        nextLayer=layer;
    }
    protected void init(){
        if(numberOfNeuronsInLayer>=0){
            for(int i=0;i<numberOfNeuronsInLayer;i++){
                try{
                    neuron.get(i).setActivationFunction(activationFnc);
                    neuron.get(i).init();
                }
                catch(IndexOutOfBoundsException iobe){
                    neuron.add(new Neuron(numberOfInputs,activationFnc));
                    neuron.get(i).init();
                }
            }
        }
    }
    
    protected void setInputs(ArrayList<Double> inputs){
        this.numberOfInputs=inputs.size();
        this.input=inputs;
    }
   
    protected void calc(){
        if(input!=null && neuron!=null){
            for(int i=0;i<numberOfNeuronsInLayer;i++){
                neuron.get(i).setInputs(this.input);
                neuron.get(i).calc();
                try{
                    output.set(i,neuron.get(i).getOutput());
                }
                catch(IndexOutOfBoundsException iobe){
                    output.add(neuron.get(i).getOutput());
                }
            }
        }
    }
    
    protected ArrayList<Double> getOutputs(){
        return output;
    }
    
    protected Neuron getNeuron(int i){
        return neuron.get(i);
    }

    protected void setNeuron(int i, Neuron _neuron){
        try{
            this.neuron.set(i, _neuron);
        }
        catch(IndexOutOfBoundsException iobe){
            this.neuron.add(_neuron);
        }
    }
    
}

---

3.ActivationFunction 인터페이스

NeerualNetwork 클래스를 정의하기 전에, 자바 코드 인터페이스의 예를 보면 :

public interface IActivationFunction {
    double calc(double x);
    public enum ActivationFunctionENUM {
        STEP, LINEAR, SIGMOID, HYPERTAN
    }
}

특정 클래스에 속하는 상기 석회질 () 메소드 IActivationFunction 활성화 함수 인터페이스, 예를 들어 S 형 함수를 구현한다.

public class Sigmoid implements IActivationFunction {
    private double a=1.0;
    public Sigmoid(){
        
    }
    public Sigmoid(double value){
        this.setA(value);
    }
    public void setA(double value){
        this.a=value;
    }
    @Override
    public double calc(double x){
        return 1.0/(1.0+Math.exp(-a*x));
    }
}

이것은 다형성, 즉 동일한 기능 명, 클래스 유연한 애플리케이션을 생성하기 위해 다른 동작을 제공하기위한 방법의 일 예이다.

4. 신경망 (NeuralNet) 클래스

마지막으로, 신경 네트워크 클래스의 정의. 지금까지, 우리는 이미 신경 조직 층 뉴런 신경망 각 신경망을 사용하는 2 개 이상의 층, 소득, 처리 결과를 수신하기위한 하나의 숨겨진 층의 가변 수를 갖는 것을 알 . 따라서, 신경 세포에 첨가하고 NeuralLary 외부와 유사한 특성을 갖는 클래스에 신경이 또한 numberOfInputs 같은 여러 가지 특성을 가질 것이다 numberOfOutputs 좋아.

 private InputLayer inputLayer;
    private ArrayList<HiddenLayer> hiddenLayer;
    private OutputLayer outputLayer;
    private int numberOfHiddenLayers;
    private int numberOfInputs;
    private int numberOfOutputs;
    private ArrayList<Double> input;
    private ArrayList<Double> output;
   

앞의 클래스 매개 변수보다 더이 클래스의 생성자 :

 public NeuralNet(int numberofinputs,int numberofoutputs,
            int [] numberofhiddenneurons,IActivationFunction[] hiddenAcFnc,
            IActivationFunction outputAcFnc)

숨겨진 레이어의 수는 변수의 경우, 우리는 또한 더 숨겨진 레이어 또는 숨겨진 레이어 0, 각 숨겨진 레이어가있을 수 있음을 고려해야한다, 숨겨진 뉴런의 수는 변수입니다. 이 변화는 정수 벡터 (매개 변수 numberofhiddenlayers)는 각 은닉층 뉴런의 수를 나 타내는 처리하는 가장 좋은 방법입니다. 또한, 각각의 숨겨진 레이어 및 출력 레이어에 대해 정의 된 기능을 활성화 할 필요가 필요하고 hiddenActivationFnc outputAcFnc되는 전체 대물 파라미터를 포함한다.
완전한 구현은 다음과 같습니다 :

public NeuralNet(int numberofinputs,int numberofoutputs,
            int [] numberofhiddenneurons,IActivationFunction[] hiddenAcFnc,
            IActivationFunction outputAcFnc){
        numberOfHiddenLayers=numberofhiddenneurons.length;
        numberOfInputs=numberofinputs;
        numberOfOutputs=numberofoutputs;
        if(numberOfHiddenLayers==hiddenAcFnc.length){
            input=new ArrayList<>(numberofinputs);
            inputLayer=new InputLayer(numberofinputs);
            if(numberOfHiddenLayers>0){
                hiddenLayer=new ArrayList<>(numberOfHiddenLayers);
            }
            for(int i=0;i<numberOfHiddenLayers;i++){
                if(i==0){
                    try{
                        hiddenLayer.set(i,new HiddenLayer(numberofhiddenneurons[i],
                            hiddenAcFnc[i],
                            inputLayer.getNumberOfNeuronsInLayer()));
                    }
                    catch(IndexOutOfBoundsException iobe){
                        hiddenLayer.add(new HiddenLayer(numberofhiddenneurons[i],
                            hiddenAcFnc[i],
                            inputLayer.getNumberOfNeuronsInLayer()));
                    }
                    inputLayer.setNextLayer(hiddenLayer.get(i));
                }
                else{
                    try{
                        hiddenLayer.set(i, new HiddenLayer(numberofhiddenneurons[i],
                             hiddenAcFnc[i],hiddenLayer.get(i-1)
                            .getNumberOfNeuronsInLayer()
                            ));
                    }
                    catch(IndexOutOfBoundsException iobe){
                        hiddenLayer.add(new HiddenLayer(numberofhiddenneurons[i],
                             hiddenAcFnc[i],hiddenLayer.get(i-1)
                            .getNumberOfNeuronsInLayer()
                            ));
                    }
                    hiddenLayer.get(i-1).setNextLayer(hiddenLayer.get(i));
                }
            }
            if(numberOfHiddenLayers>0){
                outputLayer=new OutputLayer(numberofoutputs,outputAcFnc,
                        hiddenLayer.get(numberOfHiddenLayers-1)
                        .getNumberOfNeuronsInLayer() 
                        );
                hiddenLayer.get(numberOfHiddenLayers-1).setNextLayer(outputLayer);
            }
            else{
                outputLayer=new OutputLayer(numberofinputs, outputAcFnc,
                        numberofoutputs);
                inputLayer.setNextLayer(outputLayer);
            }
        }
    }

5. 프로그램을 실행

다음과 같이 코드입니다 :

package neuralnet;

import neuralnet.math.IActivationFunction;
import neuralnet.math.Linear;
import neuralnet.math.RandomNumberGenerator;
import neuralnet.math.Sigmoid;

public class NeuralNetConsoleTest {
    public static void main(String[] args){
        
        RandomNumberGenerator.seed=0;
        
        int numberOfInputs=2;
        int numberOfOutputs=1;
        int[] numberOfHiddenNeurons= { 3 };
        IActivationFunction[] hiddenAcFnc = { new Sigmoid(1.0) } ;
        Linear outputAcFnc = new Linear(1.0);
        System.out.println("Creating Neural Netword...");
        NeuralNet nn = new NeuralNet(numberOfInputs,numberOfOutputs,
                numberOfHiddenNeurons,hiddenAcFnc,outputAcFnc);
        System.out.println("Neural Network Network...");
       
        double [] neuralInput = { 1.5 , 0.5 };
        System.out.println("Feeding the values {1.5;0.5} to the neural network");
        double [] neuralOutput;
        nn.setInputs(neuralInput);
        nn.calc();
        neuralOutput=nn.getOutputs();
        System.out.println("OutPut 1:" + neuralOutput[0]);
        neuralInput[0] = 1.0;
        neuralInput[1] = 2.1;
        System.out.println("Feeding the values {1.0;2.1} to the neural network");
        nn.setInputs(neuralInput);
        nn.calc();
        neuralOutput=nn.getOutputs();
        System.out.println("OutPut 2:" + neuralOutput[0]);
        
    }
}

이것은 우리가 네트워크를 신경 코드를 모두 완료 : 다음은 소스 코드 아카이브입니다. 불우 학생을 다운로드하고 실행할 수 있습니다.

다운로드 링크