예제 #1
0
        public SIMONManager()
        {
            SimonUtility = SIMONUtility.GetInstance();
            SimonObjectCollections = new SIMONCollection();
            SimonDataManager = new SIMONDataManager();
            SimonDefinitionObjects = new Dictionary<string, SIMONObject>();
            SimonFunctions = new Dictionary<string, SIMONFunction>();

            IntelligenceManager = new SIMONIntelligence();

            LearningCount = SIMONConstants.DEFAULT_LEARNING_COUNT;
            LearningPoint = SIMONConstants.DEFAULT_LEARNING_POINT;

            CreateWorkPath();
        }
예제 #2
0
        public SIMONManager(int learningCount, int learningPoint)
        {
            SimonUtility = SIMONUtility.GetInstance();
            SimonObjectCollections = new SIMONCollection();
            SimonDataManager = new SIMONDataManager();

            SimonDefinitionObjects = new Dictionary<string, SIMONObject>();
            SimonFunctions = new Dictionary<string, SIMONFunction>();

            IntelligenceManager = new SIMONIntelligence();

            this.LearningCount = learningCount;
            this.LearningPoint = learningPoint;

            CreateWorkPath();
        }
예제 #3
0
 /// <summary>
 /// Property에 대한 학습을 비동기적으로 구현합니다.
 /// </summary>
 /// <param name="ObjectCollection">Property 학습을 수행할 대상 Group입니다.</param>
 /// <param name="SimonFunctions">학습에 사용될 SIMONFunction ADT입니다.</param>
 /// <param name="learningRate">학습률입니다.</param>
 /// <returns>비동기 결과객체입니다.</returns>
 public IAsyncResult LearnPropertyAsync(SIMONCollection ObjectCollection, Dictionary<string, SIMONFunction> SimonFunctions, double learningRate)
 {
     isLearning = true;
     return AlgorithmLearnPropInvoker.BeginInvoke(ObjectCollection, SimonFunctions, learningRate, LearnPropertyAsyncCallback, null);
 }
예제 #4
0
 /// <summary>
 /// SIMONObject들의 Property 학습을 수행하는 별도의 알고리즘 구현을 제공합니다.
 /// </summary>
 /// <param name="ObjectCollection">Property 학습을 수행할 대상 Group입니다.</param>
 /// <param name="SimonFunctions">학습에 사용될 SIMONFunction ADT입니다.</param>
 public void LearnProperty(SIMONCollection ObjectCollection, Dictionary<string, SIMONFunction> SimonFunctions)
 {
     try
     {
         isLearning = true;
         LearnResult = AlgorithmPerformer.Implementation(ObjectCollection, SimonFunctions);
         isLearning = false;
     }
     catch (Exception exp)
     {
         throw new SIMONFramework.LearningFaultException(SIMONConstants.EXP_LEARNING_FAULT);
     }
 }
        /// <summary>
        /// SIMONAlgorithm의 구현을 담당하는 Interface의 기능을 호출합니다.
        /// </summary>
        /// <param name="PropertyCollection">진화에 대한 구현을 담당하는 2차원 SIMONCollection입니다.</param>
        /// <param name="SimonFunctions">SIMONFunction 집합입니다.</param>
        /// <returns>구현에 대한 결과값입니다.</returns>
        public object Implementation(SIMONCollection GroupCollection, Dictionary<string, SIMONFunction> SimonFunctions)
        {
            List<List<SIMONGene>> selectedDNAPool = Selection(GroupCollection, SimonFunctions);
            List<List<SIMONGene>> crossedDNAPool = CrossOver(selectedDNAPool);
            List<List<SIMONGene>> mutatedDNAPool = Mutation(crossedDNAPool);
            Evolution(GroupCollection, mutatedDNAPool);
            UpdateObjectsPropertyDNA(GroupCollection);

            return null;
        }
예제 #6
0
	public void SIMONLearn(SIMONCollection Group){
		SimonManager.LearnRoutine(Group);
	}
예제 #7
0
 /// <summary>
 /// 매개변수로 전달받은 SIMONObject 독립된 객체에 관한 학습 동작을 수행합니다.
 /// </summary>
 /// <param name="sObject">학습을 진행시킬 SIMONObject 단일객체.</param>
 public void TeachObject(SIMONObject sObject)
 {
     SIMONCollection subCollection = new SIMONCollection();
     subCollection.Add(sObject.ObjectID, sObject);
     SIMONCollection subActionMap = CreateActionMap(subCollection);
     IntelligenceManager.Learn(subCollection, subActionMap, SimonFunctions);
     IntelligenceManager.LearnProperty(subCollection, SimonFunctions);
 }
예제 #8
0
        /// <summary>
        /// SimonCollection들에 대한 History를 이용해서 학습 루틴을 구현합니다.
        /// </summary>
        public void LearnRoutine(SIMONCollection targetGroup)
        {
            /**********************************     학습      **************************************/
            
            SIMONCollection newActionMap = CreateActionMap(targetGroup);

            IntelligenceManager.Learn(targetGroup, newActionMap, SimonFunctions);

            IntelligenceManager.LearnProperty(targetGroup, SimonFunctions);

            /***************************************************************************************/
        }
        /// <summary>
        /// SIMONObjectCollection 집합에 대해서 다음 세대의 DNA를 적용시켜서 진화시킵니다.
        /// </summary>
        /// <param name="ObjectCollection">3차원의 대상 SIMON Collection 입니다.</param>
        /// <param name="ActionMap">3차원의 ActionMap 입니다.</param>
        /// <param name="nextDNA">진화시킬 다음 세대의 3차원 DNA입니다.</param>
        private void Evolution(SIMONCollection ObjectCollection, SIMONCollection ActionMap, List<List<List<SIMONGene>>> nextDNA)
        {
            if (ObjectCollection.Count <= 0 || nextDNA == null || nextDNA.Count <= 0)
                return;
            int numberOfDNA = nextDNA.Count;

            for (int i = 0; i < ActionMap.Count; i++)
            {
                if (nextDNA[i].Count < 1)
                    continue;
                Random rand = new Random();

                List<SIMONObject> actionObjectList = (List<SIMONObject>)ActionMap.ValueOfIndex(i);

                for (int j = 0; j < actionObjectList.Count; j++)
                {
                    for (int k = 0; k < actionObjectList[j].Actions.Count; k++)
                    {
                        if (ActionMap.KeyOfIndex(i).Equals(actionObjectList[j].Actions[k].ActionName))
                        {
                            int geneIdx = rand.Next(0, nextDNA[i].Count);
                            ((List<SIMONObject>)ActionMap.ValueOfIndex(i))[j].Actions[k].ActionDNA = nextDNA[i][geneIdx];
                            break;
                        }
                    }
                }
            }
        }
        /// <summary>
        /// SIMONObjectCollection 집합내의 Property DNA를 진화시키는 함수를 제공합니다.
        /// </summary>
        /// <param name="PropertyCollection">2차원의 대상 SIMON Collection 입니다.</param>
        /// <param name="nextDNA">진화시킬 다음 세대의 2차원 DNA입니다.</param>
        /// <param name="learningRate">학습률을 적용합니다.</param>
        private void Evolution(SIMONCollection PropertyCollection, List<List<SIMONGene>> nextDNA, double learningRate)
        {
            if (PropertyCollection.Count <= 0 || nextDNA == null || nextDNA.Count <= 0)
                return;
            int objectCount = PropertyCollection.Count;
            Random rand = new Random();

            for (int i = 0; i < nextDNA.Count; i++)
            {
                int nextGeneElementCount = nextDNA[i].Count;
                for (int j = 0; j < nextGeneElementCount; j++)
                    nextDNA[i][j].ElementWeight *= learningRate;
            }

            for (int i = 0; i < objectCount; i++)
            {
                int selectDNAIdx = rand.Next(0, nextDNA.Count - 1);
                ((SIMONObject)PropertyCollection.ValueOfIndex(i)).PropertyDNA = nextDNA[selectDNAIdx];
            }
        }
        /// <summary>
        /// SIMONObjectCollection 집합내의 Property DNA를 진화시키는 함수를 제공합니다.
        /// </summary>
        /// <param name="PropertyCollection">2차원의 대상 SIMON Collection 입니다.</param>
        /// <param name="nextDNA">진화시킬 다음 세대의 2차원 DNA입니다.</param>
        private void Evolution(SIMONCollection PropertyCollection, List<List<SIMONGene>> nextDNA)
        {
            if (PropertyCollection.Count <= 0 || nextDNA == null || nextDNA.Count <= 0)
                return;
            int objectCount = PropertyCollection.Count;
            Random rand = new Random();

            for (int i = 0; i < objectCount; i++)
            {
                int selectDNAIdx = rand.Next(0, nextDNA.Count - 1);
                for (int j = 0; j < nextDNA[selectDNAIdx].Count; j++)
                {
                    for (int k = 0; k < ((SIMONObject)PropertyCollection.ValueOfIndex(i)).PropertyDNA.Count; k++)
                    {
                        if (((SIMONObject)PropertyCollection.ValueOfIndex(i)).PropertyDNA[k].ElementName == nextDNA[selectDNAIdx][j].ElementName)
                        {
                            ((SIMONObject)PropertyCollection.ValueOfIndex(i)).PropertyDNA[k] = nextDNA[selectDNAIdx][j];
                        }
                    }
                }
            }
        }
        /// <summary>
        /// History로부터 읽어온 데이터를 바탕으로, 유전 선택 알고리즘을 수행합니다. 우성 : 열성이 3:1 비율이 되도록 집단에서 우성 행동들과 열성 행동의 3차원 배열값을 반환합니다.
        /// </summary>
        /// <param name="ObjectCollection">3차원으로 구성된 Selection 대상 ObjectCollection 입니다.</param>
        /// <param name="ActionMap">Selection 대상 ActionMap 입니다.</param>
        /// <param name="SimonFunctions">Selection 연산에 사용될 SimonFunction 집합입니다.</param>
        /// <returns>선택된 3차원 ActionDNA 배열입니다.</returns>
        public List<List<List<SIMONGene>>> Selection(SIMONCollection ObjectCollection, SIMONCollection ActionMap, Dictionary<string, SIMONFunction> SimonFunctions)
        {
            List<List<List<SIMONGene>>> selectedDNA = new List<List<List<SIMONGene>>>();
            List<GeneValue[]> recordMap = new List<GeneValue[]>();                                            //ObjectCollection 내 각 객체들에 대한 Action들에 대한 Record 값들을 저장하는 Map.

            int ObjectCount = ObjectCollection.Count;
            int ActionCount = ActionMap.Count;

            for (int i = 0; i < ActionCount; i++)
            {
                selectedDNA.Add(new List<List<SIMONGene>>());
            }

            #region 현재 ActionMap 구조를 이용한 RecordMap 구조화

            for (int i = 0; i < ActionCount; i++)
            {
                List<SIMONObject> elementList = (List<SIMONObject>)ActionMap.ValueOfIndex(i);

                int actionObjectCount = elementList.Count;

                GeneValue[] gene = new GeneValue[actionObjectCount];
                recordMap.Add(gene);

                for (int j = 0; j < actionObjectCount; j++)
                {
                    recordMap[i][j] = new GeneValue();
                    SIMONObject[] otherObjectsList;
                    if (ObjectCount > 1)
                        otherObjectsList = new SIMONObject[ObjectCollection.Count - 1];
                    else
                        otherObjectsList = null;
                    int otherObjectCnt = 0;

                    for (int k = 0; k < ObjectCount; k++)
                        if ((otherObjectsList != null) && (!ObjectCollection.ValueOfIndex(k).Equals(elementList[j])))
                            otherObjectsList[otherObjectCnt++] = (SIMONObject)ObjectCollection.ValueOfIndex(k);

                    for (int k = 0; k < elementList[j].Actions.Count; k++)
                    {
                        if (elementList[j].Actions[k].ActionName.Equals(ActionMap.KeyOfIndex(i)))
                        {
                            recordMap[i][j].dna = elementList[j].Actions[k].ActionDNA;
                            double fitnessValue = (double)SimonFunctions[elementList[j].Actions[k].FitnessFunctionName].Invoke(elementList[j], otherObjectsList);

                            //Upper Boundary와 Lower Boundary 내의 Fitness Value들을 채택.
                            if (fitnessValue < SIMONConstants.FITNESS_MIN_VALUE)
                            {
                                throw new SIMONFramework.ValueUnderflowException(SIMONConstants.EXP_VALUE_UNDERFLOW);
                            }
                            else if (fitnessValue > SIMONConstants.FITNESS_MAX_VALUE)
                            {
                                throw new SIMONFramework.ValueOverflowException(SIMONConstants.EXP_VALUE_OVERFLOW);
                            }
                            recordMap[i][j].fitnessValue = fitnessValue;
                            break;
                        }
                    }
                }
            }

            #endregion

            #region 현재 division 나누는 코드. Action 별로 4등분해서 나누기 때문에 2차원 배열임.

            int[][] divIndex = new int[ActionCount][];
            for (int i = 0; i < ActionCount; i++)
            {
                int numberOfActionObjects = ((List<SIMONObject>)ActionMap.ValueOfIndex(i)).Count;
                divIndex[i] = new int[SIMONConstants.GENE_SUM_RATING];
                for (int j = 0; j < SIMONConstants.GENE_SUM_RATING; j++)
                {
                    int divPosition = (numberOfActionObjects * (j + 1)) / SIMONConstants.GENE_SUM_RATING;
                    if (divPosition == 0)
                        divPosition = -1;
                    else
                        divPosition--;
                    divIndex[i][j] = divPosition;
                }
            }

            #endregion

            //QuickSort를 통해서 각 Action별로 fitness 값들을 정렬.
            for (int i = 0; i < recordMap.Count; i++)
                QuickSort(recordMap[i], 0, recordMap[i].Length - 1);

            List<List<GeneValue>> firstSelectGene = new List<List<GeneValue>>();
            List<List<GeneValue>> lastSelectGene = new List<List<GeneValue>>();

            for (int i = 0; i < recordMap.Count; i++)
            {
                firstSelectGene.Add(new List<GeneValue>());
                lastSelectGene.Add(new List<GeneValue>());
                List<GeneValue> recessiveGroup = new List<GeneValue>();
                List<GeneValue> dominionGroup = new List<GeneValue>();

                //열성집합 중 1만큼의 비율을 선택. 경계값부터 시작인덱스 까지 내려가면서 집합에 포함시킨다.
                for (int j = divIndex[i][(SIMONConstants.GENE_RECESSIVE_RATING - 1)]; j >= 0; j--)
                {
                    recessiveGroup.Add(recordMap[i][j]);
                }
                List<GeneValue> rouletteRecessive = RouletteWheel(recessiveGroup, GeneSelectionLaw.RECESSIVE);      //각 Object 들의 열성 집합 중 대표값 배열을 우성 열성 비율별로 선택
                if (rouletteRecessive != null)
                    firstSelectGene[i].AddRange(rouletteRecessive);

                //우성집합 중 3만큼의 비율을 선택. 경계값부터 시작인덱스까지 내려가면서 집합에 포함시킨다.
                for (int j = divIndex[i][SIMONConstants.GENE_DOMINION_RATING]; j >= divIndex[i][(SIMONConstants.GENE_RECESSIVE_RATING - 1)] + 1; j--)
                {
                    dominionGroup.Add(recordMap[i][j]);
                }
                List<GeneValue> rouletteDominion = RouletteWheel(dominionGroup, GeneSelectionLaw.DOMINION);         //각 Object 들의 우성 집합 중 대표값 배열을 우성 열성 비율별로 선택
                if (rouletteDominion != null)
                    firstSelectGene[i].AddRange(rouletteDominion);

                lastSelectGene[i].AddRange(RouletteWheel(firstSelectGene[i], GeneSelectionLaw.DOMINION));
            }

            for (int i = 0; i < ActionCount; i++)
            {
                int selectedCount = SIMONConstants.GENE_REAL_SELECT_NUM;
                int[] selectedIdxList = new int[lastSelectGene[i].Count];
                int selectedIdxListIndex = 0;

                //만약 실제 유전자 숫자가 Default로 정한 유전자 추출 갯수보다 작으면 실제 유전자 갯수 만큼을 선택 횟수로 지정한다.
                if (lastSelectGene[i].Count < SIMONConstants.GENE_REAL_SELECT_NUM)
                    selectedCount = lastSelectGene[i].Count;

                if (selectedCount <= 0)
                    continue;

                //실제 유전시킬 유전자 갯수만큼 랜덤값을 통한 추출
                while (selectedIdxListIndex < selectedCount)
                {
                    Random rand = new Random();
                    int selectIdx = rand.Next(0, selectedCount);
                    bool retryFlag = false;

                    for (int j = 0; j < selectedIdxListIndex; j++)
                    {
                        if (selectIdx == selectedIdxList[j])
                        {
                            retryFlag = true;
                            break;
                        }
                    }
                    if (retryFlag)
                        continue;

                    selectedDNA[i].Add(lastSelectGene[i][selectIdx].dna);
                    selectedIdxList[selectedIdxListIndex++] = selectIdx;
                }
            }
            //selectedDNA 리턴.
            return selectedDNA;
        }
        /// <summary>
        /// History로부터 읽어온 데이터를 바탕으로, 유전 선택 알고리즘을 수행합니다. 우성 : 열성이 3:1 비율이 되도록 집단에서 우성 행동들과 열성 행동의 2차원 배열값을 반환합니다.
        /// </summary>
        /// <param name="PropertyCollection">2차원으로 구성된 Selection 대상 ObjectCollection 입니다.</param>
        /// <param name="SimonFunctions">Selection 연산에 사용될 SimonFunction 집합입니다.</param>
        /// <returns>선택된 2차원 Property DNA 배열입니다.</returns>
        public List<List<SIMONGene>> Selection(SIMONCollection PropertyCollection, Dictionary<string, SIMONFunction> SimonFunctions)
        {
            List<List<SIMONGene>> selectedDNA = new List<List<SIMONGene>>();
            int dnaObjectCount = PropertyCollection.Count;
            GeneValue[] propertyGenes = new GeneValue[dnaObjectCount];
            int[] divIndex = new int[SIMONConstants.GENE_SUM_RATING];

            for (int i = 0; i < dnaObjectCount; i++)
            {
                SIMONObject elementObject = (SIMONObject)PropertyCollection.ValueOfIndex(i);
                SIMONObject[] otherObjects = new SIMONObject[dnaObjectCount - 1];
                int otherObjectsCnt = 0;
                propertyGenes[i] = new GeneValue();

                //otherObject 리스트 추가시키면됨.
                for (int j = 0; j < dnaObjectCount; j++)
                    if (elementObject != (SIMONObject)PropertyCollection.ValueOfIndex(j))
                        otherObjects[otherObjectsCnt++] = (SIMONObject)PropertyCollection.ValueOfIndex(j);

                propertyGenes[i].dna = elementObject.PropertyDNA;
                double fitnessValue = (double)SimonFunctions[elementObject.ObjectFitnessFunctionName].Invoke(elementObject, otherObjects);

                //Upper Boundary와 Lower Boundary 경계 내의 Fitness Value를 채택.
                if (fitnessValue < SIMONConstants.FITNESS_MIN_VALUE)
                {
                    throw new SIMONFramework.ValueUnderflowException(SIMONConstants.EXP_VALUE_UNDERFLOW);
                }
                else if (fitnessValue > SIMONConstants.FITNESS_MAX_VALUE)
                {
                    throw new SIMONFramework.ValueOverflowException(SIMONConstants.EXP_VALUE_OVERFLOW);
                }
                propertyGenes[i].fitnessValue = fitnessValue;
            }
            QuickSort(propertyGenes, 0, dnaObjectCount - 1);

            for (int i = 0; i < SIMONConstants.GENE_SUM_RATING; i++)
            {
                int divNum = (int)(((i + 1) * dnaObjectCount) / SIMONConstants.GENE_SUM_RATING);
                if (divNum == 0)
                    divNum = -1;
                else
                    divNum--;
                divIndex[i] = divNum;
            }

            List<GeneValue> recessiveGroup = new List<GeneValue>();
            List<GeneValue> dominionGroup = new List<GeneValue>();

            List<GeneValue> selectedGene = new List<GeneValue>();

            for (int i = divIndex[SIMONConstants.GENE_RECESSIVE_RATING - 1]; i >= 0; i--)
            {
                recessiveGroup.Add(propertyGenes[i]);
            }
            selectedGene.AddRange(RouletteWheel(recessiveGroup, GeneSelectionLaw.RECESSIVE));

            for (int i = divIndex[SIMONConstants.GENE_DOMINION_RATING]; i >= divIndex[SIMONConstants.GENE_RECESSIVE_RATING - 1] + 1; i--)
            {
                dominionGroup.Add(propertyGenes[i]);
            }
            selectedGene.AddRange(RouletteWheel(dominionGroup, GeneSelectionLaw.DOMINION));

            int selectingCount = SIMONConstants.GENE_REAL_SELECT_NUM;
            if (selectedGene.Count < selectingCount)
                selectingCount = selectedGene.Count;
            int[] selectedIdxTable = new int[selectingCount];
            int selectedIdx = 0;

            if (selectedGene.Count <= 0)
                return selectedDNA;

            while (selectedIdx < selectingCount)
            {
                Random rand = new Random();
                int selectIdx = rand.Next(0, selectedGene.Count);
                bool retryFlag = false;

                for (int i = 0; i < selectedIdx; i++)
                {
                    if (selectedIdxTable[i] == selectIdx)
                    {
                        retryFlag = true;
                        break;
                    }
                }
                if (retryFlag)
                    continue;
                selectedDNA.Add(selectedGene[selectIdx].dna);
                selectedIdxTable[selectedIdx++] = selectIdx;
            }

            return selectedDNA;
        }
        /// <summary>
        /// SIMONAlgorithm의 구현을 담당하는 Interface의 기능을 호출합니다.
        /// </summary>
        /// <param name="GroupCollection">Algorithm의 적용 대상 Collection입니다.</param>
        /// <param name="ActionMap">Algorithm의 적용 대상 Action에 대한 매핑 테이블을 선언합니다.</param>
        /// <param name="SimonFunctions">Algorithm에 사용되는 함수를 링크합니다.</param>
        /// <param name="learningRate">알고리즘의 학습률을 지정합니다.</param>
        /// <returns>구현에 대한 결과값입니다.</returns>
        public object Implementation(SIMONCollection GroupCollection, SIMONCollection ActionMap, Dictionary<string, SIMONFunction> SimonFunctions, double learningRate)
        {
            List<List<List<SIMONGene>>> selectedDNAPool = Selection(GroupCollection, ActionMap, SimonFunctions);
            List<List<List<SIMONGene>>> crossedDNAPool = CrossOver(selectedDNAPool);
            List<List<List<SIMONGene>>> mutatedDNAPool = Mutation(crossedDNAPool);
            Evolution(GroupCollection, ActionMap, mutatedDNAPool, learningRate);

            return null;
        }
예제 #15
0
 /// <summary>
 /// Group의 모든 내용을 비웁니다.
 /// </summary>
 /// <param name="Group">비울 대상 Group Collection입니다.</param>
 public void CleanGroup(SIMONCollection Group)
 {
     Group.Clear();
 }
예제 #16
0
 /// <summary>
 /// 그룹에 대한 ActionMap을 구현합니다.
 /// </summary>
 /// <param name="group">ActionMap을 구조할 group입니다.</param>
 /// <returns>만들어진 ActionMap SIMONCollection을 반환합니다.</returns>
 private SIMONCollection CreateActionMap(SIMONCollection group)
 {
     SIMONCollection actionMap = new SIMONCollection();
     for (int i = 0; i < group.Count; i++)
     {
         SIMONObject element = (SIMONObject)group.ValueOfIndex(i);
         for (int j = 0; j < element.Actions.Count; j++)
         {
             if (!actionMap.Contains(element.Actions[j].ActionName))
             {
                 actionMap.Add(element.Actions[j].ActionName, new List<SIMONObject>());
             }
             DictionaryEntry val = (DictionaryEntry)actionMap[element.Actions[j].ActionName];
             var mapElement = val.Value;
             ((List<SIMONObject>)mapElement).Add(element);
             actionMap[element.Actions[j].ActionName] = mapElement;
         }
     }
     return actionMap;
 }
        /// <summary>
        /// SIMONObjectCollection 집합에 대해서 다음 세대의 DNA를 적용시켜서 진화시킵니다.
        /// </summary>
        /// <param name="ObjectCollection">3차원의 대상 SIMON Collection 입니다.</param>
        /// <param name="ActionMap">3차원의 ActionMap 입니다.</param>
        /// <param name="nextDNA">진화시킬 다음 세대의 3차원 DNA입니다.</param>
        /// <param name="learningRate">진화의 학습률입니다.</param>
        private void Evolution(SIMONCollection ObjectCollection, SIMONCollection ActionMap, List<List<List<SIMONGene>>> nextDNA, double learningRate)
        {
            if (ObjectCollection.Count <= 0 || nextDNA == null || nextDNA.Count <= 0)
                return;
            int numberOfDNA = nextDNA.Count;

            for (int i = 0; i < ActionMap.Count; i++)
            {
                if (nextDNA[i].Count < 1)
                    continue;
                int actionObjDNACnt = nextDNA[i].Count;
                for (int j = 0; j < actionObjDNACnt; j++)
                {
                    int nextDNAGeneCnt = nextDNA[i][j].Count;
                    for (int k = 0; k < nextDNAGeneCnt; k++)
                    {
                        nextDNA[i][j][k].ElementWeight *= learningRate;
                    }
                }
            }

            for (int i = 0; i < ActionMap.Count; i++)
            {
                if (nextDNA[i].Count < 1)
                    continue;
                Random rand = new Random();
                int randIdx = rand.Next(0, numberOfDNA);

                List<SIMONObject> actionObjectList = (List<SIMONObject>)ActionMap.ValueOfIndex(i);

                for (int j = 0; j < actionObjectList.Count; j++)
                {
                    for (int k = 0; k < actionObjectList[j].Actions.Count; k++)
                    {
                        if (ActionMap.KeyOfIndex(i).Equals(actionObjectList[j].Actions[k].ActionName))
                        {
                            int geneIdx = rand.Next(0, nextDNA[i].Count);
                            ((List<SIMONObject>)ActionMap.ValueOfIndex(i))[j].Actions[k].ActionDNA = nextDNA[i][geneIdx];
                        }
                    }
                }
            }
            
        }
예제 #18
0
        /// <summary>
        /// 학습률을 적용해서 SIMONCollection들에 대한 History를 이용해서 학습 효과를 조절할 수 있는 학습 루틴을 구현합니다.
        /// </summary>
        /// <param name="targetGroup">Simulate를 적용시킬 대상 Group입니다.</param>
        /// <param name="learningRate">적용시킬 학습률입니다.</param>
        public void LearnSimulate(SIMONCollection targetGroup, double learningRate)
        {
            /**********************************     학습      **************************************/

            SIMONCollection newActionMap = CreateActionMap(targetGroup);

            IntelligenceManager.LearnAsync(targetGroup, newActionMap, SimonFunctions, learningRate);

            IntelligenceManager.LearnPropertyAsync(targetGroup, SimonFunctions, learningRate);

            /***************************************************************************************/
        }
 /// <summary>
 /// ObjectCollection에 대해서 Property DNA를 업데이트합니다.
 /// </summary>
 /// <param name="ObjectCollection">Update를 수행할 대상 Collection.</param>
 private void UpdateObjectsPropertyDNA(SIMONCollection ObjectCollection)
 {
     for (int i = 0; i < ObjectCollection.Count; i++)
     {
         SIMONObject elementObject = (SIMONObject)ObjectCollection.ValueOfIndex(i);
         for (int j = 0; j < elementObject.Properties.Count; j++)
         {
             if (elementObject.Properties[j].Inherit)
             {
                 for (int k = 0; k < elementObject.PropertyDNA.Count; k++)
                 {
                     if (elementObject.PropertyDNA[k].ElementName.Equals(elementObject.Properties[j].PropertyName))
                     {
                         elementObject.Properties[j].PropertyValue = elementObject.PropertyDNA[k].ElementWeight;
                     }
                 }
             }
         }
     }
 }
예제 #20
0
 /// <summary>
 /// SIMONManager에 등록해서 사용할 새로운 SIMONCollection을 생성해서 반환합니다.
 /// </summary>
 /// <returns>SIMONCollection 객체를 반환합니다.</returns>
 public SIMONCollection CreateSIMONGroup()
 {
     SIMONCollection newGroup = new SIMONCollection();
     return newGroup;
 }
예제 #21
0
 /// <summary>
 /// SIMONObject들의 Property 학습을 수행하는 별도의 알고리즘 구현을 제공합니다.
 /// </summary>
 /// <param name="ObjectCollection"></param>
 /// <param name="SimonFunctions"></param>
 public void LearnProperty(SIMONCollection ObjectCollection, Dictionary<string, SIMONFunction> SimonFunctions)
 {
     try
     {
         isLearning = true;
         LearnResult = AlgorithmPerformer.Implementation(ObjectCollection, SimonFunctions);
         isLearning = false;
     }
     catch (Exception exp)
     {
         throw new Exception("[SIMON Framework] : Exception Occurs in learning property algorithm.\n" + exp.Message, exp);
     }
 }
예제 #22
0
 public SIMONObjectCollectionEnumerator(SIMONCollection simonCollection)
 {
     SIMONDictionary = new DictionaryEntry[simonCollection.Count];
     Array.Copy(simonCollection.SIMONDictionary, 0, SIMONDictionary, 0, simonCollection.Count);
 }
예제 #23
0
	public void CleanSIMONGroup(SIMONCollection Group){
		SimonManager.CleanGroup (Group);
	}
예제 #24
0
	public void SIMONLearnSimulate(SIMONCollection Group, double learningRate){
		SimonManager.LearnSimulate(Group, learningRate);
	}
예제 #25
0
 /// <summary>
 /// SIMONObject들의 그룹과 Action들의 Map, 학습에 이용되는 SimonFunction들에 대한 Dictionary 및 학습률을 적용시킨 비동기 학습루틴을 구현합니다.
 /// </summary>
 /// <param name="GroupCollection">학습 대상 SIMONObject 그룹입니다.</param>
 /// <param name="ActionMap">학습 대상에 대한 ActionMap입니다.</param>
 /// <param name="SimonFunctions">학습에 사용될 SIMONFunction ADT입니다.</param>
 /// <param name="learningRate">학습률입니다.</param>
 /// <returns>비동기 결과 객체입니다.</returns>
 public IAsyncResult LearnAsync(SIMONCollection GroupCollection, SIMONCollection ActionMap, Dictionary<string, SIMONFunction> SimonFunctions, double learningRate)
 {
     isLearning = true;
     return AlgorithmLearnInvoker.BeginInvoke(GroupCollection, ActionMap, SimonFunctions, learningRate, LearnCallbackInvoker, null);
 }