/// <param name="entryCount"> Количество входов перцептрона. </param> /// <param name="sizes"> /// Количества нейронов на слоях перцептрона от сенсорного к реагирующему. /// </param> public Perceptron(int entryCount, IList <int> sizes) { if (sizes == null || sizes.Count == 0) { throw new Exception(); } if (entryCount < 1) { throw new Exception(); } EntryCount = entryCount; LayerCount = sizes.Count; Layers = new Layer[LayerCount]; TransferFunction = new LogisticTransferFunction(); for (int i = 0; i < LayerCount; i++) { Neuron[] neurons = new Neuron[sizes[i]]; for (int j = 0; j < sizes[i]; j++) { neurons[j] = new Neuron(i == 0 ? EntryCount : sizes[i - 1], TransferFunction); } Layers[i] = new Layer(sizes[i], neurons); } }
protected Neuron(ITransferFunction tFunc) { TransferFunction = tFunc; Output = 0.0; ErrorSignal = 0.0; ErrorSignalSum = 0.0; }
public Layer(int numOfNeurons, ITransferFunction transferFun) { Neurons = new List <Neuron>(); for (int i = 0; i < numOfNeurons; i++) { Neurons.Add(new Neuron(transferFun)); } }
public Layer(int NumberOfNeurons, ITransferFunction func) { neurons = new List<Neuron>(); for (int i = 0; i < NumberOfNeurons; i++) { Neuron n = new Neuron(); n.SetTransferFunction(func); neurons.Add(n); } Output = new double[NumberOfNeurons]; }
public Anfis(int numberOfRules, ITNorm norm, ITransferFunction sigmoidTransferFunction, bool stochasticGradient, double learningRate, int epochLimit, double errorTermination, List <TrainingData> trainingData) { NumberOfRules = numberOfRules; TNorm = norm; SigmoidTransferFunction = sigmoidTransferFunction; StochasticGradient = stochasticGradient; LearningRate = learningRate; EpochLimit = epochLimit; ErrorTermination = errorTermination; TrainingData = trainingData; InitArrays(); ErrorsPerEpoch = new List <string>(); }
public double[] FeedForward(double[] inputs, ITransferFunction transferFunction) { this.inputs = inputs; for (int i = 0; i < numberOfOutputs; i++) { this.outputs[i] = 0; for (int j = 0; j < numberOfInputs; j++) { this.outputs[i] += this.inputs[j] * this.weights[i, j]; } outputs[i] = transferFunction.Activate(outputs[i]); } return(this.outputs); }
public NeuralNetwork(int[] layer, ITransferFunction transferFunction) { this.layer = new int[layer.Length]; this.transferFunction = transferFunction; for (int i = 0; i < layer.Length; i++) { this.layer[i] = layer[i]; } // ignore input layer this.layers = new Layer[layer.Length - 1]; for (int i = 0; i < layers.Length; i++) { layers[i] = new Layer(layer[i], layer[i + 1]); } }
public void BackwardPropagationOutput(double[] expected, ITransferFunction transferFunction) { for (int i = 0; i < numberOfOutputs; i++) { error[i] = outputs[i] - expected[i]; } for (int i = 0; i < numberOfOutputs; i++) { gamma[i] = error[i] * transferFunction.Derivative(outputs[i]); } for (int i = 0; i < numberOfOutputs; i++) { for (int j = 0; j < numberOfInputs; j++) { weightsDelta[i, j] = gamma[i] * inputs[j]; } } }
public ThermalSimplePerceptron(ITransferFunction transferFunction, int maxEpochs, double learningRate, double temperature) : base(transferFunction, maxEpochs, learningRate) { Temperature = temperature; }
public InputNeuron(ITransferFunction tFunc) : base(tFunc) { }
public void SetTransferFunction(ITransferFunction func) { this._transferFunction = func; }
public PocketSimplePerceptron(ITransferFunction transferFunction, int maxEpochs, double learningRate) : base(transferFunction, maxEpochs, learningRate) { }
public SimplePerceptron(ITransferFunction transferFunction, int maxEpochs, double learningRate) : base(transferFunction) { _maxEpochs = maxEpochs; _learningRate = learningRate; }
public NeuralNetwork(int numOfInputs, int numOfHiddenLayerNeurons, int numOfOutputs, ITransferFunction transferFun, double minWeight, double maxWeight) { Layers = new List <Layer>(); Layers.Add(new Layer(numOfInputs, transferFun)); Layers.Add(new Layer(numOfHiddenLayerNeurons, transferFun)); Layers.Add(new Layer(numOfOutputs, transferFun)); for (int i = 1; i < Layers.Count; i++) { Layers[i].ConenctToPreviousLayer(Layers[i - 1], minWeight, maxWeight); } }
public InOutData <HashSet <Guid> > Analyze(ControlFlowGraph graph, ILatticeOperations <HashSet <Guid> > ops, ITransferFunction <HashSet <Guid> > f) { var data = new InOutData <HashSet <Guid> > {
public BasePerceptron(ITransferFunction transferFunction) { TransferFunction = transferFunction; }
/// <summary> /// Конструктор класса /// </summary> /// <param name="f1">Первая функция</param> /// <param name="f2">Вторая функция</param> public TransferFuctionComposition(ITransferFunction <T> f1, ITransferFunction <T> f2) { this.f1 = f1; this.f2 = f2; }
public HiddenNeuron(ITransferFunction tFunc) : base(tFunc) { Bias = new Bias(); }
public MindTest() { this.function = new SigmoidTransferFunction(); this.Neurons = new List <List <NeuronTest> >(); }
public NeuralNetwork(int numOfInputs, int numOfHiddenLayerNeurons, int numOfOutputs, ITransferFunction transferFun) : this(numOfInputs, numOfHiddenLayerNeurons, numOfOutputs, transferFun, -0.5d, 0.5d) { }
public InOutData <Dictionary <Guid, VarValue> > Analyze(ControlFlowGraph graph, ILatticeOperations <Dictionary <Guid, VarValue> > ops, ITransferFunction <Dictionary <Guid, VarValue> > f) { var data = new InOutData <Dictionary <Guid, VarValue> >(); foreach (var node in graph.CFGNodes) { data[node] = (ops.Lower, ops.Lower); } var outChanged = true; while (outChanged) { outChanged = false; foreach (var block in graph.CFGNodes) { var inset = block.Parents.Aggregate(ops.Lower, (x, y) => ops.Operator(x, data[y].Item2)); var outset = f.Transfer(block, inset, ops); if (outset.Count == data[block].Item2.Count && !outset.Except(data[block].Item2).Any()) { outChanged = true; data[block] = (inset, outset); } } } return(data); }
public OutputNeuron(ITransferFunction tFunc) : base(tFunc) { Bias = new Bias(); }
public Neuron(ITransferFunction transferFunction) { this.TransferFunction = transferFunction; }
public void BackwardPropagationHidden(double[] gammaForward, double[,] weightsForward, ITransferFunction transferFunction) { for (int i = 0; i < numberOfOutputs; i++) { gamma[i] = 0; for (int j = 0; j < gammaForward.Length; j++) { gamma[i] += gamma[j] * weightsForward[j, i]; } gamma[i] *= transferFunction.Derivative(outputs[i]); } for (int i = 0; i < numberOfOutputs; i++) { for (int j = 0; j < numberOfInputs; j++) { weightsDelta[i, j] = gamma[i] * inputs[j]; } } }
/// <summary> /// Композиция функций f1 и f2. /// </summary> /// <returns>OUT множество композиции</returns> /// <param name="f1">Первая функция</param> /// <param name="f2">Вторая функцияD</param> /// <typeparam name="T">Тип передаточной функции</typeparam> public static ITransferFunction <T> Compose <T>(this ITransferFunction <T> f1, ITransferFunction <T> f2) { return(new TransferFuctionComposition <T>(f1, f2)); }