public void PresentNewTrainingUnitCommon()
        {
            SchoolWorld.ClearWorld();
            SchoolWorld.SetHints(TSHints);

            PresentNewTrainingUnit();
        }
        public LTClassComposition(SchoolWorld w)
            : base(w)
        {
            TSHints = new TrainingSetHints {
                { TSHintAttributes.IMAGE_NOISE, 0 },
                { TSHintAttributes.IS_VARIABLE_POSITION, 0 },
                { TSHintAttributes.IS_VARIABLE_COLOR, 0 },
                { TSHintAttributes.IS_VARIABLE_SIZE, 0 },
                { TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 4f },
                { TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS, 10000 }
            };

            TSProgression.Add(TSHints.Clone());

            TSProgression.Add(TSHintAttributes.IS_VARIABLE_COLOR, 1.0f);
            TSProgression.Add(TSHintAttributes.IS_VARIABLE_POSITION, 1.0f);
            TSProgression.Add(TSHintAttributes.IMAGE_NOISE, 1);
            TSProgression.Add(TSHintAttributes.IS_VARIABLE_SIZE, 1.0f);
            TSProgression.Add(TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 6f);
            TSProgression.Add(TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 8f);

            m_positiveExamples.Add(Shape.Shapes.Star);
            m_positiveExamples.Add(Shape.Shapes.Circle);
            m_positiveExamples.Add(Shape.Shapes.T);
            m_positiveExamples.Add(Shape.Shapes.Tent);
            m_positiveExamples.Add(Shape.Shapes.Mountains);

            m_negativeExamples.Add(Shape.Shapes.DoubleRhombus);
            m_negativeExamples.Add(Shape.Shapes.Pentagon);
            m_negativeExamples.Add(Shape.Shapes.Rhombus);
            m_negativeExamples.Add(Shape.Shapes.Square);
            m_negativeExamples.Add(Shape.Shapes.Triangle);
        }
示例#3
0
        // Construct the learning task
        public LTConditionalTarget(SchoolWorld w)
            : base(w)
        {
            TSHints = new TrainingSetHints {
                { MOVING_CONDITION, 0 },
                { TSHintAttributes.IS_VARIABLE_SIZE, 0 },
                { TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 1 },
                { TSHintAttributes.IMAGE_NOISE, 0 },
                { CONDITION_SALIENCE, 1 },
                //{ TSHintAttributes.DEGREES_OF_FREEDOM, 1 },
                { TSHintAttributes.GIVE_PARTIAL_REWARDS, 1 },
                { TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS, 10000 },
                // Currently, target locations are always uniformly distributed inside POW
                //{ TSHintAttributes.DEPRECATED_MAX_TARGET_DISTANCE, .3f }
                { TSHintAttributes.IMAGE_TEXTURE_BACKGROUND, 0 },
            };

            TSProgression.Add(TSHints.Clone());
            TSProgression.Add(MOVING_CONDITION, 1);
            //TSProgression.Add(TSHintAttributes.DEGREES_OF_FREEDOM, 2);
            //TSProgression.Add(TSHintAttributes.DEPRECATED_MAX_TARGET_DISTANCE, -1);
            TSProgression.Add(TSHintAttributes.IMAGE_NOISE, 1);
            TSProgression.Add(TSHintAttributes.IS_VARIABLE_SIZE, 1);
            TSProgression.Add(TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 2);
            TSProgression.Add(TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 3);
            TSProgression.Add(CONDITION_SALIENCE, .5f);
            TSProgression.Add(TSHintAttributes.GIVE_PARTIAL_REWARDS, 0);
            TSProgression.Add(TSHintAttributes.IMAGE_TEXTURE_BACKGROUND, 1);
        }
        public LTDetectShapeColor(SchoolWorld w)
            : base(w)
        {
            TSHints = new TrainingSetHints
            {
                { TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS, 10000 },
                { TSHintAttributes.IMAGE_NOISE, 0 },
                { TSHintAttributes.IS_VARIABLE_SIZE, 0 },
                { TSHintAttributes.IS_VARIABLE_POSITION, 0 },
                { TSHintAttributes.IS_VARIABLE_ROTATION, 0 },
                { TSHintAttributes.DEGREES_OF_FREEDOM, 2 },
                { TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 2 },
                { COLOR_COUNT, 2 },
            };

            TSProgression.Add(TSHints.Clone());
            TSProgression.Add(TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 3);
            TSProgression.Add(TSHintAttributes.IS_VARIABLE_POSITION, 1);
            TSProgression.Add(COLOR_COUNT, 3);
            TSProgression.Add(TSHintAttributes.IMAGE_NOISE, 1);
            TSProgression.Add(TSHintAttributes.DEGREES_OF_FREEDOM, 3);
            TSProgression.Add(TSHintAttributes.IS_VARIABLE_SIZE, 1);
            TSProgression.Add(TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 4);
            TSProgression.Add(TSHintAttributes.IS_VARIABLE_ROTATION, 1);
            TSProgression.Add(COLOR_COUNT, 4);
            TSProgression.Add(TSHintAttributes.DEGREES_OF_FREEDOM, 4);
            TSProgression.Add(TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 5);
            TSProgression.Add(COLOR_COUNT, 5);

            SetClasses();
        }
示例#5
0
        protected override bool DidTrainingUnitComplete(ref bool wasUnitSuccessful)
        {
            if (SchoolWorld.IsEmulatingUnitCompletion())
            {
                return(SchoolWorld.EmulateIsTrainingUnitCompleted(out wasUnitSuccessful));
            }
            else
            {
                m_stepsSincePresented++;

                if (DidTrainingUnitFail())
                {
                    wasUnitSuccessful = false;
                    return(true);
                }

                if (!m_teacher.IsDone() && m_agent.IsMoving())
                {
                    wasUnitSuccessful = false;
                    return(true);
                }

                // save history for agent and teacher
                m_agentsHistory.Add(m_agent.Position.X, m_agent.Position.Y);
                m_teachersHistory.Add(m_teacher.Position.X, m_teacher.Position.Y);

                wasUnitSuccessful = false;

                int numberOfTeachersSteps = m_teachersHistory.numberOfSteps();
                int numberOfAgentsSteps   = m_agentsHistory.numberOfSteps();

                // simple version of the task
                if (TSHints[STOP_REQUEST] == .0f)
                {
                    if (numberOfTeachersSteps == numberOfAgentsSteps && m_teacher.IsDone())
                    {
                        // compare step
                        wasUnitSuccessful = m_teachersHistory.CompareTo(m_agentsHistory, m_stepsSincePresented);
                        return(true);
                    }
                }
                // hard version
                else
                {
                    if (numberOfTeachersSteps == numberOfAgentsSteps && m_teacher.IsDone())
                    {
                        m_delayedCheck = true;
                    }

                    if (m_delayedCheck)
                    {
                        m_delayedCheck = false;
                        // compare steps
                        wasUnitSuccessful = m_teachersHistory.CompareTo(m_agentsHistory, m_stepsSincePresented);
                        return(true);
                    }
                }
                return(false);
            }
        }
        public LTSimpleDistance(SchoolWorld w)
            : base(w)
        {
            TSHints = new TrainingSetHints
            {
                { TSHintAttributes.IS_VARIABLE_COLOR, 0 },
                { TSHintAttributes.IS_VARIABLE_SIZE, 0 },
                { ERROR_TOLERANCE, 0.25f },
                { TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 1 },
                { TSHintAttributes.IMAGE_NOISE, 0 },
                { TSHintAttributes.GIVE_PARTIAL_REWARDS, 1 },
                { TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS, 10000 }
            };

            TSProgression.Add(TSHints.Clone());
            TSProgression.Add(new TrainingSetHints {
                { TSHintAttributes.IS_VARIABLE_COLOR, 1 },
                { ERROR_TOLERANCE, 0.15f },
                { TSHintAttributes.GIVE_PARTIAL_REWARDS, 0 }
            });
            TSProgression.Add(new TrainingSetHints {
                { TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 2 }
            });
            TSProgression.Add(new TrainingSetHints {
                { TSHintAttributes.IS_VARIABLE_SIZE, 1 },
                { ERROR_TOLERANCE, 0.10f },
            });
            TSProgression.Add(new TrainingSetHints {
                { ERROR_TOLERANCE, 0.05f },
                { TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 3 },
            });
            TSProgression.Add(TSHintAttributes.IMAGE_NOISE, 1);
        }
示例#7
0
        public LTSimpleSize(SchoolWorld w)
            : base(w)
        {
            TSHints = new TrainingSetHints
            {
                { TSHintAttributes.IS_VARIABLE_COLOR, 0 },
                { TARGET_SIZE_LEVELS, 2 },
                { TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 1 },
                { TSHintAttributes.IMAGE_NOISE, 0 },
                { TSHintAttributes.GIVE_PARTIAL_REWARDS, 1 },
                { TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS, 10000 }
            };

            TSProgression.Add(TSHints.Clone());
            TSProgression.Add(new TrainingSetHints {
                { TSHintAttributes.IS_VARIABLE_COLOR, 1 },
                { TSHintAttributes.GIVE_PARTIAL_REWARDS, 0 }
            });
            TSProgression.Add(new TrainingSetHints {
                { TARGET_SIZE_LEVELS, 5 },
                { TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 2 }
            });
            TSProgression.Add(new TrainingSetHints {
                { TARGET_SIZE_LEVELS, 10 },
                { TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 3 },
            });
            TSProgression.Add(TSHintAttributes.IMAGE_NOISE, 1);
        }
        public LTMovingTarget(SchoolWorld w)
            : base(w)
        {
            TSHints[TSHintAttributes.DEGREES_OF_FREEDOM] = 2;                   // Set degrees of freedom to 2: move in 4 directions (1 means move only right-left)
            //TSHints[TSHintAttributes.MAX_TARGET_DISTANCE] = 0.3f;

            TSHints[DISTANCE_BONUS_COEFFICENT] = 15f;                            // Coefficent of 4 means that the available steps to reach the target are "initialDistance (between agent and target) * 4" (for more info check LTApproach)

            //Reusing TSHints from LTApproach with some additions
            TSHints.Add(MOVING_VELOCITY, 1);
            TSHints.Add(ELLIPSE_SIZE, 0.55f);
            TSHints.Add(STEPS_TAKEN_FOR_ONE_CIRCLE, 600);
            TSHints.Add(AVOIDING_AGENT, 0);

            TSProgression.Clear();                                              // Clearing TSProgression that was declared in LTApproach before filling custom one

            TSProgression.Add(TSHints.Clone());

            TSProgression.Add(
                new TrainingSetHints {
                { ELLIPSE_SIZE, 0.55f },
                { STEPS_TAKEN_FOR_ONE_CIRCLE, 500 }
            });

            TSProgression.Add(
                new TrainingSetHints {
                { ELLIPSE_SIZE, 0.6f },
                { STEPS_TAKEN_FOR_ONE_CIRCLE, 400 }
            });

            TSProgression.Add(
                new TrainingSetHints {
                { ELLIPSE_SIZE, 0.7f },
                { STEPS_TAKEN_FOR_ONE_CIRCLE, 300 }
            });

            TSProgression.Add(
                new TrainingSetHints {
                { ELLIPSE_SIZE, 0.7f },
                { STEPS_TAKEN_FOR_ONE_CIRCLE, 200 }
            });

            TSProgression.Add(
                new TrainingSetHints {
                { ELLIPSE_SIZE, 0.8f },
                { STEPS_TAKEN_FOR_ONE_CIRCLE, 100 }
            });

            TSProgression.Add(
                new TrainingSetHints {
                { MOVING_VELOCITY, 2 },
                { ELLIPSE_SIZE, 0.65f },
                { STEPS_TAKEN_FOR_ONE_CIRCLE, 1000 },
                { AVOIDING_AGENT, 1 },
                { DISTANCE_BONUS_COEFFICENT, 7f },
                { TSHintAttributes.IMAGE_TEXTURE_BACKGROUND, 1f }
            });
        }
示例#9
0
        public LTMovingTarget(SchoolWorld w)
            : base(w)
        {
            TSHints[TSHintAttributes.DEGREES_OF_FREEDOM] = 2;                   // Set degrees of freedom to 2: move in 4 directions (1 means move only right-left)
            //TSHints[TSHintAttributes.MAX_TARGET_DISTANCE] = 0.3f;

            TSHints[DISTANCE_BONUS_COEFFICENT] = 15f;                            // Coefficent of 4 means that the available steps to reach the target are "initialDistance (between agent and target) * 4" (for more info check LTApproach)

            //Reusing TSHints from LTApproach with some additions
            TSHints.Add(MOVING_VELOCITY, 1);
            TSHints.Add(ELLIPSE_SIZE, 0.55f);
            TSHints.Add(STEPS_TAKEN_FOR_ONE_CIRCLE, 600);
            TSHints.Add(AVOIDING_AGENT, 0);

            TSProgression.Clear();                                              // Clearing TSProgression that was declared in LTApproach before filling custom one

            TSProgression.Add(TSHints.Clone());

            TSProgression.Add(
                new TrainingSetHints {
                    { ELLIPSE_SIZE, 0.55f },
                    { STEPS_TAKEN_FOR_ONE_CIRCLE, 500 }
            });

            TSProgression.Add(
                new TrainingSetHints {
                    { ELLIPSE_SIZE, 0.6f },
                    { STEPS_TAKEN_FOR_ONE_CIRCLE, 400 }
            });

            TSProgression.Add(
                new TrainingSetHints {
                    { ELLIPSE_SIZE, 0.7f },
                    { STEPS_TAKEN_FOR_ONE_CIRCLE, 300 }
            });

            TSProgression.Add(
                new TrainingSetHints {
                    { ELLIPSE_SIZE, 0.7f },
                    { STEPS_TAKEN_FOR_ONE_CIRCLE, 200 }
            });

            TSProgression.Add(
                new TrainingSetHints {
                    { ELLIPSE_SIZE, 0.8f },
                    { STEPS_TAKEN_FOR_ONE_CIRCLE, 100 }
            });

            TSProgression.Add(
                new TrainingSetHints {
                    { MOVING_VELOCITY, 2 },
                    { ELLIPSE_SIZE, 0.65f },
                    { STEPS_TAKEN_FOR_ONE_CIRCLE, 1000 },
                    { AVOIDING_AGENT, 1 },
                    { DISTANCE_BONUS_COEFFICENT, 7f },
                    { TSHintAttributes.IMAGE_TEXTURE_BACKGROUND, 1f}
            });
        }
示例#10
0
        public LTShapeGroups(SchoolWorld w)
            : base(w)
        {
            //  TODO Add TSHints

            TSProgression.Add(TSHints.Clone());
            // TODO progression
            SetHints(TSHints);
        }
        public LTPongWithoutBricks(SchoolWorld w)
            : base(w)
        {
            TSHints = new TrainingSetHints {
                { TSHintAttributes.IMAGE_NOISE, 0 },
                { TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS, 10000 }
            };

            TSHints.Add(MAX_MISSES_ALLOWED, 1);
            TSHints.Add(BALL_HITS_NEEDED, 1);
            ballHitSum = 0f;
            ballHitSum = 0f;

            TSProgression.Add(TSHints.Clone());

            TSProgression.Add(
                new TrainingSetHints {
                { MAX_MISSES_ALLOWED, 1 },
                { BALL_HITS_NEEDED, 1 }
            });

            TSProgression.Add(
                new TrainingSetHints {
                { MAX_MISSES_ALLOWED, 10 },
                { BALL_HITS_NEEDED, 6 }
            });

            TSProgression.Add(
                new TrainingSetHints {
                { MAX_MISSES_ALLOWED, 10 },
                { BALL_HITS_NEEDED, 10 }
            });

            TSProgression.Add(
                new TrainingSetHints {
                { MAX_MISSES_ALLOWED, 10 },
                { BALL_HITS_NEEDED, 20 }
            });

            TSProgression.Add(
                new TrainingSetHints {
                { MAX_MISSES_ALLOWED, 10 },
                { BALL_HITS_NEEDED, 30 }
            });

            TSProgression.Add(
                new TrainingSetHints {
                { MAX_MISSES_ALLOWED, 10 },
                { BALL_HITS_NEEDED, 40 }
            });

            TSProgression.Add(
                new TrainingSetHints {
                { MAX_MISSES_ALLOWED, 1 },
                { BALL_HITS_NEEDED, 10 }
            });
        }
 public AbstractLearningTask(SchoolWorld schoolWorld)
 {
     SchoolWorld             = schoolWorld;
     TSHints                 = new TrainingSetHints();
     TSProgression           = new TrainingSetProgression();
     CurrentNumberOfAttempts = CurrentNumberOfSuccesses = 0;
     CurrentLevel            = 0;
     IsInitialized           = false;
 }
示例#13
0
        public LTDebugging(SchoolWorld w)
            : base(w)
        {
            TSHints = new TrainingSetHints {
                { TSHintAttributes.IMAGE_NOISE, 0 },
                { TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS, 10000 }
            };

            TSProgression.Add(TSHints.Clone());
        }
        public virtual TrainingResult EvaluateStep()
        {
            // Check for unit completion
            bool wasUnitSuccessful = true;
            bool inProgress        = (SchoolWorld.IsEmulatingUnitCompletion() && !SchoolWorld.EmulateIsTrainingUnitCompleted(out wasUnitSuccessful)) ||
                                     (!SchoolWorld.IsEmulatingUnitCompletion() && !DidTrainingUnitComplete(ref wasUnitSuccessful));

            if (inProgress)
            {
                // The unit is still in progress
                return(TrainingResult.TUInProgress);
            }
            // otherwise the unit is over

            CurrentNumberOfAttempts++;

            // Check for task failure
            if (TSHints.ContainsKey(TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS) &&
                CurrentNumberOfAttempts >= TSHints[TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS])
            {
                // Too many attempts
                Reward = -1.0f;
                return(TrainingResult.FailedLT);
            }

            if (wasUnitSuccessful)
            {
                Reward = 1.0f;
                CurrentNumberOfSuccesses++;
            }
            else
            {
                Reward = -1.0f;
                CurrentNumberOfSuccesses = 0;
            }

            MyLog.Writer.WriteLine(
                MyLogLevel.INFO,
                GetTypeName() +
                " unit ends with result: " +
                (wasUnitSuccessful ? "success" : "fail") +
                ". " +
                CurrentNumberOfSuccesses + " successful attempts in row, " +
                NumberOfSuccessesRequired + " required.");


            // Check for level completion
            if (CurrentNumberOfSuccesses < NumberOfSuccessesRequired)
            {
                // The level is still in progress
                return(TrainingResult.FinishedTU);
            }

            return(TrainingResult.FinishedLevel);
        }
示例#15
0
        public SchoolCurriculum AsSchoolCurriculum(SchoolWorld world)
        {
            SchoolCurriculum result = new SchoolCurriculum();

            foreach (CurriculumDesign curr in Curricula)
            {
                result.Add(curr.AsSchoolCurriculum(world));
            }

            return(result);
        }
示例#16
0
        public Ltsct1(SchoolWorld w)
            : base(w)
        {
            TSHints = new TrainingSetHints {
                { TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS, 1000000000 },
                { TSHintAttributes.IMAGE_NOISE, 1 },
                { TSHintAttributes.IMAGE_NOISE_BLACK_AND_WHITE, 1 }
            };

            TSProgression.Add(TSHints.Clone());
        }
示例#17
0
 public ILearningTask AsILearningTask(SchoolWorld world = null)
 {
     if (!Enabled)
         return null; //there is no placeholder for empty task, therefore null
     ILearningTask task;
     if (world != null)
         task = LearningTaskFactory.CreateLearningTask(Type.GetType(TaskType), world);
     else
         task = LearningTaskFactory.CreateLearningTask(Type.GetType(TaskType));
     task.RequiredWorldType = Type.GetType(WorldType);
     return task;
 }
        public LTCompatibilityMatching(SchoolWorld w)
            : base(w)
        {
            TSHints = new TrainingSetHints {
                { TSHintAttributes.IMAGE_NOISE, 0 },
                { ROTATION_ALLOWED, 0 },
                { TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS, 10000 }
            };

            TSProgression.Add(TSHints.Clone());
            TSProgression.Add(ROTATION_ALLOWED, 1);
            TSProgression.Add(TSHintAttributes.IMAGE_NOISE, 1);
        }
示例#19
0
        public LTDetectColor(SchoolWorld w)
            : base(w)
        {
            TSHints = new TrainingSetHints {
                { TSHintAttributes.IMAGE_NOISE, 0 },
                { NUMBER_OF_COLORS, 2 },
                { TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS, 10000 }
            };

            TSProgression.Add(TSHints.Clone());
            TSProgression.Add(TSHintAttributes.IMAGE_NOISE, 1);
            TSProgression.Add(NUMBER_OF_COLORS, 4);
            TSProgression.Add(NUMBER_OF_COLORS, 8);
        }
示例#20
0
        public LTSinglePixelRL(SchoolWorld w)
            : base(w)
        {
            TSHints = new TrainingSetHints {
                { TSHintAttributes.IS_VARIABLE_COLOR, 0 },
                { TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS, 10000 }
            };

            TSProgression.Add(TSHints.Clone());
            TSProgression.Add(TSHintAttributes.IS_VARIABLE_COLOR, 1);

            m_objectColor[ObjectType.Target]       = 0;
            m_objectColor[ObjectType.Empty]        = 1;
            m_objectColor[ObjectType.BeforeTarget] = 2;
        }
示例#21
0
 private void RemoveWorldHandlers(SchoolWorld world)
 {
     if (world == null)
     {
         return;
     }
     world.CurriculumStarting   -= PrepareSimulation;
     world.LearningTaskNew      -= GoToNextTask;
     world.LearningTaskNewLevel -= UpdateLTLevel;
     world.LearningTaskFinished -= LearningTaskFinished;
     world.VisualFormatChanged  -= VisualFormatChanged;
     world.TrainingUnitUpdated  -= UpdateTUStatus;
     world.TrainingUnitFinished -= UpdateTUStatus;
     world.TrainingUnitFinished -= UpdateTrainingUnitNumber;
 }
        public LTMultipleTargetsSequence(SchoolWorld w)
            : base(w)
        {
            TSHints[TSHintAttributes.DEGREES_OF_FREEDOM]          = 2;      // Set degrees of freedom to 2: move in 4 directions (1 means move only right-left)
            TSHints[TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS] = 1;
            TSHints[TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS]      = 10000;

            TSHints.Add(SEQUENCE_LENGTH, 1);
            TSHints.Add(TIMESTEPS_LIMIT, 500);                             // Training unit fails if the TIMESTEP_LIMIT is reached, this is used to avoid that the agent stands without moving
            TSHints.Add(DISTANCE_BONUS_COEFFICENT, 3.0f);                  // Manhattan distance is calculated to estimate how many steps are needed to finish the sequence, DISTANCE_BONUS_COEFFICENT can be used to increase that number, if for example it's 2.0f then TIMESTEPS_LIMIT is (2 * EstimatedManahattanDistance)
            TSHints.Add(TSHintAttributes.IMAGE_TEXTURE_BACKGROUND, 1f);

            TSProgression.Add(TSHints.Clone());

            TSProgression.Add(
                new TrainingSetHints {
                { SEQUENCE_LENGTH, 2 },
                { DISTANCE_BONUS_COEFFICENT, 3f }
            });

            TSProgression.Add(
                new TrainingSetHints {
                { SEQUENCE_LENGTH, 3 },
                { DISTANCE_BONUS_COEFFICENT, 3f }
            });

            TSProgression.Add(
                new TrainingSetHints {
                { SEQUENCE_LENGTH, 4 },
                { DISTANCE_BONUS_COEFFICENT, 2.5f }
            });

            TSProgression.Add(
                new TrainingSetHints {
                { SEQUENCE_LENGTH, 5 },
                { DISTANCE_BONUS_COEFFICENT, 2.0f }
            });

            TSProgression.Add(
                new TrainingSetHints {
                { DISTANCE_BONUS_COEFFICENT, 1.5f }
            });

            TSProgression.Add(
                new TrainingSetHints {
                { DISTANCE_BONUS_COEFFICENT, 1.0f },
            });
        }
示例#23
0
        private void SchoolRunForm_VisibleChanged(object sender, EventArgs e)
        {
            if (!Visible)
            {
                return;
            }
            SelectSchoolWorld(null, EventArgs.Empty);
            splitContainer2.Panel2Collapsed = !Properties.School.Default.ShowVisual;
            m_emulateSuccess = btnEmulateSuccess.Checked;
            SchoolWorld school = m_mainForm.Project.World as SchoolWorld;

            UpdateWorldHandlers(school, school);

            UpdateWindowName(sender, e);
            UpdateData();
        }
        public LTObstaclesTargetInSight(SchoolWorld w)
            : base(w)
        {
            TSHints.Clear();
            TSProgression.Clear();

            TSHints.Add(TIMESTEPS_LIMIT, 200);
            TSHints.Add(TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS, 10000);
            TSHints.Add(TSHintAttributes.IMAGE_NOISE, 0);
            TSHints.Add(TSHintAttributes.IMAGE_TEXTURE_BACKGROUND, 0);

            TSProgression.Add(TSHints.Clone());
            TSProgression.Add(TIMESTEPS_LIMIT, 100);
            TSProgression.Add(TSHintAttributes.IMAGE_NOISE, 1);
            TSProgression.Add(TIMESTEPS_LIMIT, 50);
            TSProgression.Add(TSHintAttributes.IMAGE_TEXTURE_BACKGROUND, 1);
        }
        public LTVisualEquivalence(SchoolWorld w)
            : base(w)
        {
            TSHints = new TrainingSetHints {
                { TSHintAttributes.IMAGE_NOISE, 0 },
                { TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS, 10000 },
                { NUMBER_OF_DIFFERENT_OBJECTS, 2 },
                { ROTATE_SHAPE, 0 },
                { SCALE_SHAPE, 0 }
            };

            TSProgression.Add(TSHints.Clone());
            TSProgression.Add(NUMBER_OF_DIFFERENT_OBJECTS, 3);
            TSProgression.Add(SCALE_SHAPE, 1);
            TSProgression.Add(ROTATE_SHAPE, 1);
            TSProgression.Add(NUMBER_OF_DIFFERENT_OBJECTS, 5);
        }
        public LTObstaclesTargetInSight(SchoolWorld w)
            : base(w)
        {
            TSHints.Clear();
            TSProgression.Clear();

            TSHints.Add(TIMESTEPS_LIMIT, 200);
            TSHints.Add(TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS, 10000);
            TSHints.Add(TSHintAttributes.IMAGE_NOISE, 0);
            TSHints.Add(TSHintAttributes.IMAGE_TEXTURE_BACKGROUND, 0);

            TSProgression.Add(TSHints.Clone());
            TSProgression.Add(TIMESTEPS_LIMIT, 100);
            TSProgression.Add(TSHintAttributes.IMAGE_NOISE, 1);
            TSProgression.Add(TIMESTEPS_LIMIT, 50);
            TSProgression.Add(TSHintAttributes.IMAGE_TEXTURE_BACKGROUND, 1);
        }
示例#27
0
        public SchoolCurriculum AsSchoolCurriculum(SchoolWorld world)
        {
            SchoolCurriculum curriculum = new SchoolCurriculum();

            if (!Enabled)
            {
                return(curriculum);
            }

            Tasks.
            Select(x => x.AsILearningTask(world)).
            Where(x => x != null).
            ToList().
            ForEach(x => curriculum.Add(x));

            return(curriculum);
        }
示例#28
0
        public LTCopyAction(SchoolWorld w)
            : base(w)
        {
            TSHints = new TrainingSetHints
            {
                { STOP_REQUEST, 0 },
                { TSHintAttributes.DEGREES_OF_FREEDOM, 1 },
                { TSHintAttributes.IMAGE_NOISE, 0 },
                { TEACHER_ON_DIFF_START_POSITION, 0 },
                { TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS, 10000 },
                { TSHintAttributes.IMAGE_TEXTURE_BACKGROUND, 1 },
            };

            TSProgression.Add(TSHints.Clone());
            TSProgression.Add(TSHintAttributes.DEGREES_OF_FREEDOM, 2);
            TSProgression.Add(TSHintAttributes.IMAGE_NOISE, 1);
            TSProgression.Add(TEACHER_ON_DIFF_START_POSITION, 1);
        }
示例#29
0
        public ILearningTask AsILearningTask(SchoolWorld world = null)
        {
            if (!Enabled)
            {
                return(null); //there is no placeholder for empty task, therefore null
            }
            ILearningTask task;

            if (world != null)
            {
                task = LearningTaskFactory.CreateLearningTask(Type.GetType(TaskType), world);
            }
            else
            {
                task = LearningTaskFactory.CreateLearningTask(Type.GetType(TaskType));
            }
            task.RequiredWorldType = Type.GetType(WorldType);
            return(task);
        }
示例#30
0
        public LTShapeSorting(SchoolWorld w)
            : base(w)
        {
            TSHints = new TrainingSetHints
            {
                { TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS, 10000 },
                { TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 2 },
                { TSHintAttributes.DEGREES_OF_FREEDOM, 1 },
                { TSHintAttributes.IMAGE_NOISE, 0 },
                // Rotation about origin
                { TSHintAttributes.IS_VARIABLE_POSITION, 0 },
                // Shape scaling
                { TSHintAttributes.IS_VARIABLE_SIZE, 0 },
                // Rotation about center of gravity (of each shape)
                { TSHintAttributes.IS_VARIABLE_ROTATION, 0 },
                // Random color
                { TSHintAttributes.IS_VARIABLE_COLOR, 0 },
                // Random distance from origin
                { IS_VARIABLE_DISTANCE, 0 },
                { RANDOMNESS_LEVEL, 1 },
            };

            TSProgression.Add(TSHints.Clone());

            TSProgression.Add(TSHintAttributes.IS_VARIABLE_ROTATION, 1);
            TSProgression.Add(new TrainingSetHints {
                { TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 3 },
                { TSHintAttributes.DEGREES_OF_FREEDOM, 2 }
            });

            TSProgression.Add(TSHintAttributes.IS_VARIABLE_SIZE, 1);
            TSProgression.Add(TSHintAttributes.IMAGE_NOISE, 1);

            TSProgression.Add(IS_VARIABLE_DISTANCE, 1);
            TSProgression.Add(TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 4);

            TSProgression.Add(TSHintAttributes.IS_VARIABLE_POSITION, 1);
            TSProgression.Add(RANDOMNESS_LEVEL, 1.2f);

            TSProgression.Add(TSHintAttributes.IS_VARIABLE_COLOR, 1);
            TSProgression.Add(TSHintAttributes.NUMBER_OF_DIFFERENT_OBJECTS, 5);
            TSProgression.Add(RANDOMNESS_LEVEL, 1.4f);
        }
        public LTDetectDifference(SchoolWorld w)
            : base(w)
        {
            TSHints = new TrainingSetHints {
                { TSHintAttributes.IMAGE_NOISE, 0 },
                { TSHintAttributes.IS_VARIABLE_COLOR, 0 },
                { TSHintAttributes.IS_VARIABLE_SIZE, 0 },
                { TSHintAttributes.NUMBER_OBJECTS, 2 },
                { TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS, 10000 }
            };

            TSProgression.Add(TSHints.Clone());
            TSProgression.Add(TSHintAttributes.IMAGE_NOISE, 1);
            TSProgression.Add(TSHintAttributes.NUMBER_OBJECTS, 4f);
            TSProgression.Add(TSHintAttributes.IS_VARIABLE_COLOR, 1f);
            TSProgression.Add(TSHintAttributes.NUMBER_OBJECTS, 8f);
            TSProgression.Add(TSHintAttributes.IS_VARIABLE_SIZE, 1f);
            TSProgression.Add(TSHintAttributes.NUMBER_OBJECTS, 10f);
        }
        public LTDetectBlackAndWhite(SchoolWorld w)
            : base(w)
        {
            TSHints = new TrainingSetHints
            {
                { TSHintAttributes.IS_VARIABLE_SIZE, 0 },
                { TSHintAttributes.IMAGE_NOISE, 0 },
                { TSHintAttributes.MAX_NUMBER_OF_ATTEMPTS, 10000 },
                { IS_TARGET_MOVING, 0 }
            };

            TSProgression.Add(TSHints.Clone());
            TSProgression.Add(
                new TrainingSetHints {
                { TSHintAttributes.IS_VARIABLE_SIZE, 1 },
                { TSHintAttributes.IMAGE_NOISE, 1 },
                { IS_TARGET_MOVING, 1 }
            });
        }
示例#33
0
        public static ILearningTask CreateLearningTask(Type taskType, Type worldType)
        {
            // check if task type is valid
            if (!KnownLearningTasks.ContainsKey(taskType))
            {
                return(null);
            }

            // check if the world is valid for this task
            if (!KnownLearningTasks[taskType].Contains(worldType))
            {
                return(null);
            }

            // everything is OK - create the task
            SchoolWorld   world = (SchoolWorld)Activator.CreateInstance(worldType);
            ILearningTask task  = (ILearningTask)Activator.CreateInstance(taskType, world);

            return(task);
        }
 public static ILearningTask CreateLearningTask(Type learningTaskType, SchoolWorld w)
 {
     return (ILearningTask)Activator.CreateInstance(learningTaskType, w);
 }
示例#35
0
        public Ltsct1Fp(SchoolWorld w)
            : base(w)
        {

        }
示例#36
0
        public SchoolCurriculum AsSchoolCurriculum(SchoolWorld world)
        {
            SchoolCurriculum curriculum = new SchoolCurriculum();
            if (!Enabled)
                return curriculum;

            Tasks.
                Select(x => x.AsILearningTask(world)).
                Where(x => x != null).
                ToList().
                ForEach(x => curriculum.Add(x));

            return curriculum;
        }
示例#37
0
        public SchoolCurriculum AsSchoolCurriculum(SchoolWorld world)
        {
            SchoolCurriculum result = new SchoolCurriculum();
            foreach (CurriculumDesign curr in Curricula)
                result.Add(curr.AsSchoolCurriculum(world));

            return result;
        }
示例#38
0
 public Ltsct3d2(SchoolWorld w)
     : base(w)
 {
     RndGen = new Random(3); // to avoid generating same data as in case of the first task
 }
示例#39
0
        private void UpdateWorldHandlers(SchoolWorld oldWorld, SchoolWorld newWorld)
        {
            if (!Visible)
                return;
            if (newWorld == null)
                Hide();
            if (oldWorld != null)
                RemoveWorldHandlers(oldWorld as SchoolWorld);
            if (newWorld != null)
                AddWorldHandlers(newWorld as SchoolWorld);

            SetObserver();
        }
示例#40
0
 private void RemoveWorldHandlers(SchoolWorld world)
 {
     if (world == null)
         return;
     world.CurriculumStarting -= PrepareSimulation;
     world.LearningTaskNew -= GoToNextTask;
     world.LearningTaskNewLevel -= UpdateLTLevel;
     world.LearningTaskFinished -= LearningTaskFinished;
     world.VisualFormatChanged -= VisualFormatChanged;
     world.TrainingUnitUpdated -= UpdateTUStatus;
     world.TrainingUnitFinished -= UpdateTUStatus;
     world.TrainingUnitFinished -= UpdateTrainingUnitNumber;
 }
示例#41
0
 public Ltsct2d2(SchoolWorld w)
     : base(w)
 {
 }
示例#42
0
 public Ltsct6(SchoolWorld w)
     : base(w)
 {
 }