Пример #1
0
        public LGPInstruction Clone()
        {
            LGPInstruction clone = new LGPInstruction(mProgram);

            clone.mProgram             = mProgram;
            clone.mIsStructuralIntron  = mIsStructuralIntron;
            clone.mOperator            = mOperator;
            clone.mOperand1            = mOperand1;
            clone.mOperand2            = mOperand2;
            clone.mDestinationRegister = mDestinationRegister;
            return(clone);
        }
        public virtual double[] Execute(double [] register_values)
        {
            for (int i = 0; i < mRegisterSet.RegisterCount; ++i)
            {
                mRegisterSet.FindRegisterByIndex(i).Value = register_values[i % register_values.Length];
            }

            LGPOperator.OperatorExecutionStatus command  = LGPOperator.OperatorExecutionStatus.LGP_EXECUTE_NEXT_INSTRUCTION;
            LGPInstruction current_effective_instruction = null;
            LGPInstruction prev_effective_instruction    = null;

            foreach (LGPInstruction instruction in mInstructions)
            {
                if (instruction.IsStructuralIntron)
                {
                    continue;
                }
                prev_effective_instruction    = current_effective_instruction;
                current_effective_instruction = instruction;
                if (command == LGPOperator.OperatorExecutionStatus.LGP_EXECUTE_NEXT_INSTRUCTION)
                {
                    command = current_effective_instruction.Execute();
                }
                else
                {
                    // CSChen says:
                    // as suggested in Linear Genetic Programming
                    // the condictional construct is restricted to single condictional construct
                    // an example of single conditional construct would be
                    // line 1: if(register[a])
                    // line 2: <action1>
                    // line 3: <action2>
                    // if register[a]==true, then <action1> and <action2> are executed
                    // if register[a]==false, then <action1> is skipped and <action2> is executed
                    // <action1> and <action2> are restricted to effective instruction
                    if (prev_effective_instruction.IsConditionalConstruct)
                    {
                        command = LGPOperator.OperatorExecutionStatus.LGP_EXECUTE_NEXT_INSTRUCTION;
                    }
                }
            }

            double[] outputs = new double[mRegisterSet.RegisterCount];
            for (int i = 0; i < outputs.Length; ++i)
            {
                outputs[i] = mRegisterSet.FindRegisterByIndex(i).Value;
            }
            return(outputs);
        }
        public void MutateInstructionRegister()
        {
            LGPInstruction selected_instruction = mInstructions[maths.Distribution.DistributionModel.NextInt(InstructionCount)];
            double         p_const = 0;

            foreach (LGPInstruction instruction in mInstructions)
            {
                if (instruction.IsOperand1ConstantRegister || instruction.IsOperand2ConstantRegister)
                {
                    p_const += 1.0;
                }
            }
            p_const /= InstructionCount;
            selected_instruction.MutateRegister(p_const);
        }
        public virtual void Create(int size)
        {
            if (!mSetup)
            {
                Setup();
            }

            // CSChen says:
            // In this method, the instruction created is not garanteed to be structurally effective
            for (int i = 0; i < size; ++i)
            {
                LGPInstruction instruction = new LGPInstruction(this);
                instruction.Create();
                mInstructions.Add(instruction);
            }
        }
        protected void ExecuteOnFitnessCase(LGPFitnessCase fitness_case)
        {
            mPop.InitializeProgramRegisters(this, fitness_case);

            LGPOperator.OperatorExecutionStatus command  = LGPOperator.OperatorExecutionStatus.LGP_EXECUTE_NEXT_INSTRUCTION;
            LGPInstruction current_effective_instruction = null;
            LGPInstruction prev_effective_instruction    = null;

            foreach (LGPInstruction instruction in mInstructions)
            {
                if (instruction.IsStructuralIntron)
                {
                    continue;
                }
                prev_effective_instruction    = current_effective_instruction;
                current_effective_instruction = instruction;
                if (command == LGPOperator.OperatorExecutionStatus.LGP_EXECUTE_NEXT_INSTRUCTION)
                {
                    command = current_effective_instruction.Execute();
                    fitness_case.ReportProgress(instruction.Operator, instruction.Operand1, instruction.Operand2, instruction.DestinationRegister, RegisterSet);
                }
                else
                {
                    // CSChen says:
                    // as suggested in Linear Genetic Programming
                    // the condictional construct is restricted to single condictional construct
                    // an example of single conditional construct would be
                    // line 1: if(register[a])
                    // line 2: <action1>
                    // line 3: <action2>
                    // if register[a]==true, then <action1> and <action2> are executed
                    // if register[a]==false, then <action1> is skipped and <action2> is executed
                    // <action1> and <action2> are restricted to effective instruction
                    if (prev_effective_instruction.IsConditionalConstruct)
                    {
                        command = LGPOperator.OperatorExecutionStatus.LGP_EXECUTE_NEXT_INSTRUCTION;
                    }
                }
            }

            double[] outputs = new double[mRegisterSet.RegisterCount];
            for (int i = 0; i < outputs.Length; ++i)
            {
                outputs[i] = mRegisterSet.FindRegisterByIndex(i).Value;
            }
            fitness_case.RunLGPProgramCompleted(outputs);
        }
        /// <summary>
        /// this is derived from the micro mutation implementation in section
        /// 6.2.2 of Linear Genetic Programming
        /// 1. randomly select an (effective) instruction with a constant c
        /// 2. change constant c through a standard deviation from the current value
        /// c:=c + normal(mean:=0, standard_deviation)
        /// </summary>
        public void MutateInstructionConstant(maths.Distribution.Gaussian guass)
        {
            LGPInstruction selected_instruction = null;

            foreach (LGPInstruction instruction in mInstructions)
            {
                if (!instruction.IsStructuralIntron && (instruction.IsOperand1ConstantRegister || instruction.IsOperand2ConstantRegister))
                {
                    if (selected_instruction == null)
                    {
                        selected_instruction = instruction;
                    }
                    else if (maths.Distribution.DistributionModel.GetUniform() < 0.5)
                    {
                        selected_instruction = instruction;
                    }
                }
            }
            if (selected_instruction != null)
            {
                selected_instruction.MutateConstant(guass, MicroMutateConstantStandardDeviation);
            }
        }
        public void MutateInstructionOperator()
        {
            LGPInstruction instruction = mInstructions[maths.Distribution.DistributionModel.NextInt(InstructionCount)];

            instruction.MutateOperator();
        }
        public void MarkStructuralIntrons(int stop_point, HashSet <int> Reff)
        {
            /*
             * Source: Brameier, M 2004  On Linear Genetic Programming (thesis)
             *
             * Algorithm 3.1 (detection of structural introns)
             * 1. Let set R_eff always contain all registers that are effective at the current program
             * position. R_eff := { r | r is output register }.
             * Start at the last program instruction and move backwards.
             * 2. Mark the next preceding operation in program with:
             * destination register r_dest element-of R_eff.
             * If such an instruction is not found then go to 5.
             * 3. If the operation directly follows a branch or a sequence of branches then mark these
             * instructions too. Otherwise remove r_dest from R_eff .
             * 4. Insert each source (operand) register r_op of newly marked instructions in R_eff
             * if not already contained. Go to 2.
             * 5. Stop. All unmarked instructions are introns.
             */

            // CSChen says:
            // this is a variant of Algorithm 3.1 that run Algorithm 3.1 until stop_point and return the Reff at that stage

            int instruction_count = mInstructions.Count;

            for (int i = instruction_count - 1; i > stop_point; i--)
            {
                mInstructions[i].IsStructuralIntron = true;
            }

            Reff.Clear();
            int register_count = mPop.RegisterCount;

            for (int i = 0; i < register_count; ++i)
            {
                Reff.Add(i);
            }

            LGPInstruction current_instruction = null;
            LGPInstruction prev_instruction    = null;

            for (int i = instruction_count - 1; i > stop_point; i--)
            {
                prev_instruction    = current_instruction;
                current_instruction = mInstructions[i];
                // prev_instruction is not an structural intron and the current_instruction
                // is a condictional construct then, the current_instruction is not structural intron either
                // this directly follows from Step 3 of Algorithm 3.1
                if (current_instruction.IsConditionalConstruct && prev_instruction != null)
                {
                    if (!prev_instruction.IsStructuralIntron)
                    {
                        current_instruction.IsStructuralIntron = false;
                    }
                }
                else
                {
                    if (Reff.Contains(current_instruction.DestinationRegisterIndex))
                    {
                        current_instruction.IsStructuralIntron = false;
                        Reff.Remove(current_instruction.DestinationRegisterIndex);

                        if (!current_instruction.IsOperand1ConstantRegister)
                        {
                            Reff.Add(current_instruction.Operand1RegisterIndex);
                        }
                        if (!current_instruction.IsOperand2ConstantRegister)
                        {
                            Reff.Add(current_instruction.Operand2RegisterIndex);
                        }
                    }
                }
            }
        }