Example #1
0
        //phillip
        static List <NodeGene> NodeGeneration()
        {
            List <NodeGene> list = new List <NodeGene>();
            SubstrateNodes  temp;

            int nodeId = 0;

            temp          = new SubstrateNodes();
            temp.Function = "Identity";
            temp.Id       = nodeId;
            nodeId++;
            temp.Layer = 0;
            temp.Coordinate.Add(0);
            temp.Coordinate.Add(0);
            temp.Type = NodeType.Bias;
            list.Add(temp);


            double xIncrement = Math.Abs(config.SubstrateEndX - config.SubstrateStartX) / config.SubstrateX;
            double yIncrement = Math.Abs(config.SubstrateEndY - config.SubstrateStartY) / config.SubstrateY;

            for (double y = config.SubstrateStartY + yIncrement / 2; y <= config.SubstrateEndY - yIncrement / 2; y += yIncrement)
            {
                for (double x = config.SubstrateStartX + xIncrement / 2; x <= config.SubstrateEndX - xIncrement / 2; x += xIncrement)
                {
                    temp = new SubstrateNodes();

                    temp.Type  = NodeType.Input;
                    temp.Layer = 0;
                    temp.Id    = nodeId;
                    nodeId++;
                    temp.Function = "Identity";
                    temp.Coordinate.Add(x);
                    temp.Coordinate.Add(y);
                    list.Add(temp);
                }
            }

            for (double y = config.SubstrateStartY + yIncrement / 2; y <= config.SubstrateEndY - yIncrement / 2; y += yIncrement)
            {
                for (double x = config.SubstrateStartX + xIncrement / 2; x <= config.SubstrateEndX - xIncrement / 2; x += xIncrement)
                {
                    temp = new SubstrateNodes();

                    temp.Type  = NodeType.Output;
                    temp.Layer = 1;
                    temp.Id    = nodeId;
                    nodeId++;
                    temp.Function = "BipolarSigmoid";
                    temp.Coordinate.Add(x);
                    temp.Coordinate.Add(y);
                    list.Add(temp);
                }
            }

            return(list);
        }
Example #2
0
        public static List <NodeGene> XorNode()
        {
            List <NodeGene> list           = new List <NodeGene>();
            SubstrateNodes  substrateNode1 = new SubstrateNodes();

            substrateNode1.Function = "Identity";
            substrateNode1.Id       = 1;
            substrateNode1.Layer    = 0;
            substrateNode1.Type     = NodeType.Input;
            substrateNode1.SetCoordinate(-1.0, -1.0);
            list.Add((NodeGene)substrateNode1);
            SubstrateNodes substrateNode2 = new SubstrateNodes();

            substrateNode2.Function = "Identity";
            substrateNode2.Id       = 2;
            substrateNode2.Layer    = 0;
            substrateNode2.Type     = NodeType.Input;
            substrateNode2.SetCoordinate(1.0, -1.0);
            list.Add((NodeGene)substrateNode2);
            SubstrateNodes substrateNode3 = new SubstrateNodes();

            substrateNode3.Function = "Identity";
            substrateNode3.Id       = 3;
            substrateNode3.Layer    = 0;
            substrateNode3.Type     = NodeType.Input;
            substrateNode3.SetCoordinate(-1.0, 1.0);
            list.Add((NodeGene)substrateNode3);
            SubstrateNodes substrateNode4 = new SubstrateNodes();

            substrateNode4.Function = "Identity";
            substrateNode4.Id       = 4;
            substrateNode4.Layer    = 0;
            substrateNode4.Type     = NodeType.Input;
            substrateNode4.SetCoordinate(1.0, 1.0);
            list.Add((NodeGene)substrateNode4);
            SubstrateNodes substrateNode5 = new SubstrateNodes();

            substrateNode5.Function = "BipolarSigmoid";
            substrateNode5.Id       = 5;
            substrateNode5.Layer    = 1;
            substrateNode5.Type     = NodeType.Output;
            substrateNode5.SetCoordinate(new double[2]);
            list.Add((NodeGene)substrateNode5);
            return(list);
        }
Example #3
0
        public static void XorCreate(NetworkGenome sub, DecodedNetworks cppn)
        {
            SubstrateNodes substrateNode1 = sub.Nodes.Find((Predicate <NodeGene>)(n => n.Type == NodeType.Output)) as SubstrateNodes;

            double[] inputs = new double[4];
            int      id     = 0;

            for (int index = 0; index < sub.Nodes.Count - 1; ++index)
            {
                SubstrateNodes substrateNode2 = sub.Nodes[index] as SubstrateNodes;
                cppn.Flush();
                inputs[0] = substrateNode2.Coordinate[0];
                inputs[1] = substrateNode2.Coordinate[1];
                inputs[2] = substrateNode1.Coordinate[0];
                inputs[3] = substrateNode1.Coordinate[1];
                cppn.SetInputs(inputs);
                cppn.ActivateNetwork(5);
                double[] outputs = cppn.GetOutputs();
                sub.Links.Add(new LinkGene(id, substrateNode2.Id, substrateNode1.Id, outputs[0]));
            }
        }
Example #4
0
        public DecodedNetworks GenerateNetwork(MapWeights create, DecodedNetworks cppn)
        {
            for (int index = 0; index < this.net.ActivatingNodes.Count; ++index)
            {
                this.net.ActivatingNodes[index].links.Clear();
            }
            create(this.sub, cppn);
            double val1 = 0.0;

            foreach (LinkGene linkGene in this.sub.Links)
            {
                val1 = Math.Max(val1, Math.Abs(linkGene.Weight));
            }
            List <LinkGene> list             = new List <LinkGene>();
            double          staticThreshold1 = Substrates.param.StaticThreshold;

            DecodedNetworks.Link link1;
            using (List <LinkGene> .Enumerator enumerator = this.sub.Links.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    LinkGene link = enumerator.Current;
                    link.Weight *= Substrates.param.WeightRange / (2.0 * val1);
                    double staticThreshold2 = Substrates.param.StaticThreshold;
                    if (Substrates.param.ThresholdByDistance)
                    {
                        SubstrateNodes substrateNode1 = this.sub.Nodes.Find((Predicate <NodeGene>)(n => n.Id == link.Source)) as SubstrateNodes;
                        SubstrateNodes substrateNode2 = this.sub.Nodes.Find((Predicate <NodeGene>)(n => n.Id == link.Target)) as SubstrateNodes;
                        double         d = 0.0;
                        for (int index = 0; index < substrateNode1.Coordinate.Count; ++index)
                        {
                            double num = substrateNode1.Coordinate[index] - substrateNode2.Coordinate[index];
                            d += num * num;
                        }
                        double num1 = Math.Sqrt(d);
                        staticThreshold2 += num1 * Substrates.param.StaticThreshold;
                    }
                    if (Math.Abs(link.Weight) >= staticThreshold2)
                    {
                        link1.sourceNode = link.Source;
                        link1.weight     = link.Weight;
                        this.net.Neurons[link.Target].links.Add(link1);
                    }
                }
            }
            for (int index = 0; index < this.net.ActivatingNodes.Count; ++index)
            {
                link1.sourceNode = -1;
                link1.weight     = 0.0;
                this.net.ActivatingNodes[index].links.Add(link1);
            }
            if (Substrates.param.Normalize)
            {
                double num1 = 1.0;
                for (int index1 = 0; index1 < this.net.ActivatingNodes.Count; ++index1)
                {
                    double d = 0.0;
                    for (int index2 = 0; index2 < this.net.ActivatingNodes[index1].links.Count - 1; ++index2)
                    {
                        d += this.net.ActivatingNodes[index1].links[index2].weight * this.net.ActivatingNodes[index1].links[index2].weight;
                    }
                    num1 = Math.Max(num1, Math.Sqrt(d));
                }
                double num2 = Math.Sqrt(num1);
                for (int index1 = 0; index1 < this.net.ActivatingNodes.Count; ++index1)
                {
                    for (int index2 = 0; index2 < this.net.ActivatingNodes[index1].links.Count - 1; ++index2)
                    {
                        DecodedNetworks.Link link2;
                        link2.sourceNode = this.net.ActivatingNodes[index1].links[index2].sourceNode;
                        link2.weight     = this.net.ActivatingNodes[index1].links[index2].weight / num2;
                        this.net.ActivatingNodes[index1].links[index2] = link2;
                    }
                }
            }
            return(this.net);
        }