Пример #1
0
 public void AddConnection(IEnumerable <NeuralGeneNode> _inputNeurons, NeuralGeneNode _outputNeuron, bool _connectionIsEnabled,
                           bool _increaseInnovation = true)
 {
     if (connections == null)
     {
         connections = new List <NeuralGeneConnection>();
     }
     foreach (var inputNeuron in _inputNeurons)
     {
         NeuralGeneConnection tmpSynapse = new NeuralGeneConnection(inputNeuron, _outputNeuron, _connectionIsEnabled, _increaseInnovation ? currInnovation : localInnovation);
         _outputNeuron.AddConnection(inputNeuron, tmpSynapse, _connectionIsEnabled, _increaseInnovation ? currInnovation : localInnovation);
         connections.Add(tmpSynapse);
         if (_increaseInnovation)
         {
             currInnovation++;
             if (IncreaseGlobalInnovation != null)
             {
                 IncreaseGlobalInnovation(currInnovation);
             }
         }
         else
         {
             localInnovation++;
         }
     }
 }
Пример #2
0
    public void AddConnection(NeuralGeneNode _inputNeuron, NeuralGeneNode _outputNeuron, float _bias, bool _connectionIsEnabled,
                              bool _increaseInnovation = true)
    {
        if (connections == null)
        {
            connections = new List <NeuralGeneConnection>();
        }

        NeuralGeneConnection tmpSynapse = new NeuralGeneConnection(_inputNeuron, _outputNeuron, _connectionIsEnabled, _increaseInnovation ? currInnovation : localInnovation);

        _outputNeuron.AddConnection(_inputNeuron, tmpSynapse, _bias, _connectionIsEnabled, _increaseInnovation ? currInnovation : localInnovation);
        connections.Add(tmpSynapse);
        if (_increaseInnovation)
        {
            currInnovation++;
            if (IncreaseGlobalInnovation != null)
            {
                IncreaseGlobalInnovation(currInnovation);
            }
        }
        else
        {
            localInnovation++;
        }
    }
    void AddNodesAndConnectionToChild(NeuralGeneConnection ParentGenome, NeuralGenome childGenome)
    {
        NeuralGeneNode       tmpInputNode  = null;
        NeuralGeneNode       tmpOutputNode = null;
        NeuralGeneConnection tmpConnection = null;

        if (childGenome.HasNode(ParentGenome.inputNeuron.nodeNumber))
        {
            tmpInputNode = childGenome.GetNode(ParentGenome.inputNeuron.nodeNumber);
        }
        else
        {
            tmpInputNode            = AddNodeToGenome(ParentGenome.inputNeuron.nodeType, childGenome);
            tmpInputNode.bias       = ParentGenome.inputNeuron.bias;
            tmpInputNode.nodeNumber = ParentGenome.inputNeuron.nodeNumber;
        }
        if (childGenome.HasNode(ParentGenome.outputNeuron.nodeNumber))
        {
            tmpOutputNode = childGenome.GetNode(ParentGenome.outputNeuron.nodeNumber);
        }
        else
        {
            tmpOutputNode            = AddNodeToGenome(ParentGenome.outputNeuron.nodeType, childGenome);
            tmpOutputNode.bias       = ParentGenome.outputNeuron.bias;
            tmpOutputNode.nodeNumber = ParentGenome.outputNeuron.nodeNumber;
        }
        if (!childGenome.HasConnection(ParentGenome.inputNeuron.nodeNumber, ParentGenome.outputNeuron.nodeNumber))
        {
            childGenome.AddConnection(tmpInputNode, tmpOutputNode, ParentGenome.connectionIsEnabled, ParentGenome.innovation);
        }
    }
 public NeuralGeneConnection(NeuralGeneNode _inputNeuron, NeuralGeneNode _outputNeuron, bool _connectionIsEnabled, int _innovation)
 {
     inputNeuron         = _inputNeuron;
     outputNeuron        = _outputNeuron;
     weight              = NeatNeuralNetwork.GetRandom();
     connectionIsEnabled = _connectionIsEnabled;
     innovation          = _innovation;
 }
Пример #5
0
 public bool HasOutput(NeuralGeneNode _node)
 {
     foreach (var output in outputSynapses)
     {
         if (output.outputNeuron == _node)
         {
             return(true);
         }
     }
     return(false);
 }
Пример #6
0
 public bool HasInput(NeuralGeneNode _node)
 {
     foreach (var input in inputSynapses)
     {
         if (input.inputNeuron == _node)
         {
             return(true);
         }
     }
     return(false);
 }
Пример #7
0
    public void AddConnection(NeuralGeneNode _inputNeuron, NeuralGeneNode _outputNeuron, bool _connectionIsEnabled,
                              int _innovation)
    {
        if (connections == null)
        {
            connections = new List <NeuralGeneConnection>();
        }

        NeuralGeneConnection tmpSynapse = new NeuralGeneConnection(_inputNeuron, _outputNeuron, _connectionIsEnabled, _innovation);

        _outputNeuron.AddConnection(_inputNeuron, tmpSynapse, _connectionIsEnabled, _innovation);
        connections.Add(tmpSynapse);
        localInnovation++;
    }
Пример #8
0
    public NeuralGeneNode AddHiddenNode(NeuralActivationFunction _neuralActivationFunctions)
    {
        if (HiddenLayers == null)
        {
            HiddenLayers = new List <NeuralGeneNode>();
        }
        if (nodes == null)
        {
            nodes = new List <NeuralGeneNode>();
        }
        NeuralGeneNode tmpNode = new NeuralGeneNode(_neuralActivationFunctions, nodes.Count + 1, NeuralNodeType.Hidden);

        HiddenLayers.Add(tmpNode);
        nodes.Add(tmpNode);
        return(tmpNode);
    }
Пример #9
0
    public NeuralGeneNode AddOutputNode(NeuralActivationFunction _neuralActivationFunctions)
    {
        if (OutputLayer == null)
        {
            OutputLayer = new List <NeuralGeneNode>();
        }
        if (nodes == null)
        {
            nodes = new List <NeuralGeneNode>();
        }
        NeuralGeneNode tmpNode = new NeuralGeneNode(_neuralActivationFunctions, nodes.Count + 1, NeuralNodeType.Output);

        OutputLayer.Add(tmpNode);
        nodes.Add(tmpNode);
        return(tmpNode);
    }
Пример #10
0
 public void AddInputsNode(int _inputSize, NeuralActivationFunction _neuralActivationFunctions)
 {
     if (InputLayer == null)
     {
         InputLayer = new List <NeuralGeneNode>();
     }
     if (nodes == null)
     {
         nodes = new List <NeuralGeneNode>();
     }
     for (int i = 0; i < _inputSize; i++)
     {
         NeuralGeneNode tmpNode = new NeuralGeneNode(_neuralActivationFunctions, i + 1, NeuralNodeType.Input);
         InputLayer.Add(tmpNode);
         nodes.Add(tmpNode);
     }
 }
Пример #11
0
 public void AddOutputsNode(int _outputSize, NeuralActivationFunction _neuralActivationFunctions)
 {
     if (OutputLayer == null)
     {
         OutputLayer = new List <NeuralGeneNode>();
     }
     if (nodes == null)
     {
         nodes = new List <NeuralGeneNode>();
     }
     for (int i = 0; i < _outputSize; i++)
     {
         NeuralGeneNode tmpNode = new NeuralGeneNode(_neuralActivationFunctions, nodes.Count + 1, NeuralNodeType.Output);
         OutputLayer.Add(tmpNode);
         nodes.Add(tmpNode);
     }
 }
Пример #12
0
    public void MutateNodes()
    {
        List <NeuralGeneNode> tmpNodesNoinputsList = new List <NeuralGeneNode>();

        foreach (NeuralGeneNode node in HiddenLayers)
        {
            tmpNodesNoinputsList.Add(node);
        }

        foreach (NeuralGeneNode node in OutputLayer)
        {
            tmpNodesNoinputsList.Add(node);
        }

        NeuralGeneNode tmpHiddenNode = AddHiddenNode(neuralActivationFunctions[1]);

        List <NeuralGeneConnection> possibleConnectionsList = new List <NeuralGeneConnection>();

        foreach (var node in tmpNodesNoinputsList)
        {
            foreach (var connection in node.inputSynapses)
            {
                if ((connection.outputNeuron.nodeNumber > tmpHiddenNode.nodeNumber || OutputLayer.Contains(connection.outputNeuron)) && connection.connectionIsEnabled)
                {
                    possibleConnectionsList.Add(connection);
                }
            }
        }

        int nodeConnectionIndex = UnityEngine.Random.Range(0, possibleConnectionsList.Count);

        possibleConnectionsList[nodeConnectionIndex].connectionIsEnabled = false;

        AddConnection(possibleConnectionsList[nodeConnectionIndex].inputNeuron, tmpHiddenNode, true);
        AddConnection(tmpHiddenNode, possibleConnectionsList[nodeConnectionIndex].outputNeuron, true);
    }
Пример #13
0
 public NeuralGeneNode GetNode(NeuralGeneNode _neuron)
 {
     return(nodes.Find(x => x == _neuron));
 }
Пример #14
0
 public bool HasNode(NeuralGeneNode _neuron)
 {
     return(nodes.Contains(_neuron));
 }
Пример #15
0
 public void AddConnection(NeuralGeneNode _inputNeuron, NeuralGeneConnection _synapse, float _bias, bool _connectionIsEnabled, int _innovation)
 {
     bias = _bias;
     _inputNeuron.outputSynapses.Add(_synapse);
     inputSynapses.Add(_synapse);
 }
Пример #16
0
 public void AddConnection(NeuralGeneNode _inputNeuron, NeuralGeneConnection _synapse, bool _connectionIsEnabled, int _innovation)
 {
     bias = NeatNeuralNetwork.GetRandom();
     _inputNeuron.outputSynapses.Add(_synapse);
     inputSynapses.Add(_synapse);
 }