あなたは、ニューラルネットワークのJava実装を使用する方法を教えて

営業成績を初めて目：

ここではプロジェクト全体のディレクトリは次のとおりです。

---

0ニューラルネットワークの概要を実装

層ニューラルネットワーク、ニューロン、重みおよびバイアス構成起動機能。それぞれが一個の以上のニューロン、各ニューロンとの重みであるニューラル入力/出力接続を有しています。
ニューラルネットワークは、ニューロンの数は、各要素が異なる場合がありますので、多くの隠れ層はまた、無かもしれ得ることを強調することが重要です。しかし、入力/出力の神経の数の入力と出力層のニューロンの数は等しいです。
私たちは、次のカテゴリを定義する必要があることを達成するために：

• ニューロン：人工ニューロンの定義
• NeuralLayer：ニューロン層を定義する抽象クラス。
• InputLayer：神経回路の入力層の定義
• HiddenLayer：入力層と出力層との間に画定された層
• OutputLayer：神経回路の出力層を定義します。
• InputNeuron：入力ニューロンが表示され、ニューラルネットワークを定義しました。
• NeuralNet：以前に定義するすべてのクラスANN構造。

これらのクラスに加えて、我々はまた、IActivationFunctionインタフェースの活性化関数を定義する必要があります。活性化関数と同様の方法が、プロパティが割り当てられたニューロンとして必要なので、これが必要です。だから、IActivationFunctionインタフェースを実装するために必要なクラスの関数定義を有効にします：

• 線形
• シグモイド
• ステップ
• HyperTan

コードする第一章では、基本的に完成します。加えて、我々は2つのクラスを定義する必要があります。例外処理（NeuralException）、乱数（RandomNumberGenerator）を生成するための1つのために。最後に、それぞれ2つのパッケージにこれらのクラス。

---

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;
    }

バイアスは、別の重みを定義することに留意されたいです。重要なステップは、つまり、神経細胞を初期化する初期値に割り当てられた重みです。これは、init（）メソッドは、乱数発生器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です。クラスが作成され、別のクラスのコンストラクタを使用する必要があり、これらは類似したクラスのコンストラクタを持っています。

初期化および層及びニューロンを算出するが、それらはまた、init（）メソッドとCALC（）メソッドを実現します。ちょっとだけサブクラスがこれらのメソッドを呼び出すか、オーバーライドできることを保証するために、人生の種類を保護しました。

次のようにすべてのコードは次のとおりです。

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クラスを定義する前に、Javaコード・インターフェースの例を見て：

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

特定のクラスに属する、請求Calcの（）メソッドは、IActivationFunction活性化機能インタフェース、例えばシグモイド関数を実装します。

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）クラス

最後に、ニューラルネットワーククラスの定義。これまでのところ、我々はすでに神経組織層ニューロンにおける神経回路網、および各ニューラルネットワークが使用されている少なくとも二つの層、収入、処理出力を受信するための1、および中間層の可変数を持っていることを知っています。したがって、ニューロンおよび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]);
        
    }
}

以下は、ソースコードのアーカイブである：これは私たちがネットワークを神経のすべてのコードを完了します。貧しい学生はダウンロードして実行することができます。

ダウンロードのリンク