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