public async Task <List <Word> > GetWords(int count, LearningStatus status)
{
var words = new List <Word>();
var allWords = await _db.GetWordsWithStatus(status);
if (allWords.Count == 0)
{
return(null);
}
var wordsEstimates = allWords.ToDictionary(x => x, x => x.CalculateEstimation());
for (var i = 0; i < count; i++)
{
var wordsProbabilities = wordsEstimates.GetProbabilities();
var randomValue = Rand.NextDouble();
var value = 0d;
foreach (var(word, p) in wordsProbabilities)
{
value += p;
if (randomValue <= value)
{
words.Add(word);
wordsEstimates.Remove(word);
break;
}
}
}
return(words);
}
public async Task <List <Word> > GetWordsWithStatus(LearningStatus status)
{
using var db = Con;
var words = await db.QueryAsync <Word>(Sql.SelectWordsWithStatus, new { status });
return(words.ToList());
}
public StudentXRoadStep(Student student, RoadStep roadStep, LearningStatus learningStatus)
{
RoadStep = roadStep;
Student = student;
CreateDate = DateTime.Now;
LearningStatus = learningStatus;
StudentResourceRatings = new List <StudentResourceRating>();
}
void StartLearning()
{
var result = _learningService.SetupAndGetFirstQuestion(_questions);
_currentState = StatesTypeEnum.Answer;
_currentQuestion = result.NextQuestion;
_status = result.Status;
SetDialog();
}
// again clicked
private void Button3_Click(object sender, EventArgs e)
{
var result = _learningService.ProcessResultAndGetNextQuestion(_currentQuestion, QuestionResult.Again);
_currentQuestion = result.NextQuestion;
_status = result.Status;
_currentState = StatesTypeEnum.Answer;
SetDialog();
}
private void startButton_Click(object sender, EventArgs e)
{
saveLayerActivationCheckBox.Enabled = false;
saveWeightCheckBox.Enabled = false;
learningStatus = LearningStatus.Training;
startButton.Enabled = false;
pauseButton.Enabled = true;
exitButton.Enabled = false;
processThread = new Thread(new ThreadStart(ProcessThread));
controlRefreshThread = new Thread(new ThreadStart(ControlRefreshThread));
processThread.Start();
controlRefreshThread.Start();
}
// memorized clicked
private void Button1_Click(object sender, EventArgs e)
{
var result = _learningService.ProcessResultAndGetNextQuestion(_currentQuestion, QuestionResult.Memorized);
_currentQuestion = result.NextQuestion;
_status = result.Status;
if (result.Status.IsAnythingToLearn)
{
_currentState = StatesTypeEnum.Answer;
}
else
{
_currentState = StatesTypeEnum.NothingElseToLearn;
}
SetDialog();
}
private void LoadWordsWithStatus(LearningStatus status)
{
_db.GetWordsWithStatus(status).ContinueWith(InitWordsPage);
}
private void ProcessThread()
{
for (int batchIndex = currentBathDataIndex; batchIndex < batchDataList.Count; batchIndex++)
{
learningStatus = LearningStatus.Training;
currentBathDataIndex = batchIndex;
simulator = batchDataList[batchIndex].Simulator;
learningSetupList = batchDataList[batchIndex].LearningSetupList;
simulator.UseActivationInformation = saveLayerActivationCheckBox.Checked;
simulator.UseWeightInformation = saveWeightCheckBox.Checked;
this.Invoke(new MethodInvoker(delegate
{
BatchListBoxRefresh();
TestDisplayRefresh();
}));
for (int learningSetupIndex = currentLearningSetupIndex; learningSetupIndex < learningSetupList.Count; learningSetupIndex++)
{
totalEpoch = 0;
for (int i = 0; i < learningSetupIndex; i++)
{
totalEpoch += learningSetupList[i].TrainingEpoch;
}
currentLearningSetupIndex = learningSetupIndex;
List <MatchingInformation> currentTrainingMatchingInformationList = learningSetupList[learningSetupIndex].TrainingMatchingInformationList;
List <MatchingInformation> currentTestMatchingInformationList = learningSetupList[learningSetupIndex].TestMatchingInformationList;
List <TrialInformation> testMatrixTrialInformationList = new List <TrialInformation>();
foreach (MatchingInformation testMatchingInformation in currentTestMatchingInformationList)
{
bool isSRN = false;
foreach (Order order in simulator.ProcessDictionary[testMatchingInformation.ProcessName])
{
if (order.Code == OrderCode.SRNTraining || order.Code == OrderCode.SRNTest)
{
isSRN = true;
}
}
List <StimuliMatrix> stimuliMatrixList;
if (isSRN && learningSetupList[learningSetupIndex].MatrixCalculationSize == 1)
{
stimuliMatrixList = simulator.StimuliPackDictionary[testMatchingInformation.StimuliPackName].GetMatrixStimuliData(true, true, 1);
}
else
{
stimuliMatrixList = simulator.StimuliPackDictionary[testMatchingInformation.StimuliPackName].GetMatrixStimuliData(false, false, simulator.StimuliPackDictionary[testMatchingInformation.StimuliPackName].Count);
}
foreach (StimuliMatrix stimuliMatrix in stimuliMatrixList)
{
TrialInformation newTestTrialInformation = new TrialInformation();
newTestTrialInformation.Process = simulator.ProcessDictionary[testMatchingInformation.ProcessName];
newTestTrialInformation.PatternSetup = testMatchingInformation.PatternSetup;
newTestTrialInformation.StimuliMatrix = stimuliMatrix;
testMatrixTrialInformationList.Add(newTestTrialInformation);
}
}
if (currentEpoch == 0)
{
learningStatus = LearningStatus.Test;
if (simulator.UseWeightInformation)
{
simulator.WeightInformationReader(totalEpoch + 0);
}
for (int testIndex = 0; testIndex < testMatrixTrialInformationList.Count; testIndex++)
{
simulator.Process(testMatrixTrialInformationList[testIndex], totalEpoch + 0);
}
}
for (int epochIndex = currentEpoch; epochIndex < learningSetupList[learningSetupIndex].TrainingEpoch; epochIndex++)
{
learningStatus = LearningStatus.Training;
currentTick = DateTime.Now.Ticks;
currentEpoch = epochIndex;
List <TrialInformation> trainingMatrixTrialInformationList = new List <TrialInformation>();
foreach (MatchingInformation trainingMatchingInformation in currentTrainingMatchingInformationList)
{
List <StimuliMatrix> stimuliMatrixList = new List <StimuliMatrix>();
switch (learningSetupList[learningSetupIndex].TrainingProcessMode)
{
case ProcessMode.RandomAll:
case ProcessMode.RandomInStimuliPack:
stimuliMatrixList = simulator.StimuliPackDictionary[trainingMatchingInformation.StimuliPackName].GetMatrixStimuliData(true, true, learningSetupList[learningSetupIndex].MatrixCalculationSize);
break;
case ProcessMode.SequentialAll:
case ProcessMode.SequentialinStimuliPack:
stimuliMatrixList = simulator.StimuliPackDictionary[trainingMatchingInformation.StimuliPackName].GetMatrixStimuliData(true, false, learningSetupList[learningSetupIndex].MatrixCalculationSize);
break;
}
foreach (StimuliMatrix stimuliMatrix in stimuliMatrixList)
{
TrialInformation newTrainingTrialInformation = new TrialInformation();
newTrainingTrialInformation.Process = simulator.ProcessDictionary[trainingMatchingInformation.ProcessName];
newTrainingTrialInformation.PatternSetup = trainingMatchingInformation.PatternSetup;
newTrainingTrialInformation.StimuliMatrix = stimuliMatrix;
trainingMatrixTrialInformationList.Add(newTrainingTrialInformation);
}
}
switch (learningSetupList[learningSetupIndex].TrainingProcessMode)
{
case ProcessMode.RandomAll:
case ProcessMode.SequentialinStimuliPack:
trainingMatrixTrialInformationList = trainingMatrixTrialInformationList.OrderBy(x => (SimulatorAccessor.random.Next())).ToList();
break;
}
currentTrialInformationCount = trainingMatrixTrialInformationList.Count;
for (int trainingIndex = 0; trainingIndex < trainingMatrixTrialInformationList.Count; trainingIndex++)
{
currentProcessName = trainingMatrixTrialInformationList[trainingIndex].Process.Name;
currentStimuliPackName = trainingMatrixTrialInformationList[trainingIndex].StimuliMatrix.PackName;
simulator.Process(trainingMatrixTrialInformationList[trainingIndex], totalEpoch + epochIndex + 1);
currentTrainingIndex = trainingIndex;
}
if ((epochIndex + 1) % learningSetupList[learningSetupIndex].TestTiming == 0)
{
learningStatus = LearningStatus.Test;
if (simulator.UseWeightInformation)
{
simulator.WeightInformationReader(totalEpoch + epochIndex + 1);
}
for (int testIndex = 0; testIndex < testMatrixTrialInformationList.Count; testIndex++)
{
simulator.Process(testMatrixTrialInformationList[testIndex], totalEpoch + epochIndex + 1);
}
try { this.Invoke(new MethodInvoker(delegate { TestDisplayRefresh(); })); }
catch { }
}
if (learningStatus == LearningStatus.Pausing)
{
currentEpoch = epochIndex + 1;
break;
}
currentTick = DateTime.Now.Ticks;
}
if (learningStatus == LearningStatus.Pausing)
{
if (currentEpoch >= learningSetupList[learningSetupIndex].TrainingEpoch)
{
currentEpoch = 0;
currentLearningSetupIndex = learningSetupIndex + 1;
}
if (currentLearningSetupIndex >= learningSetupList.Count)
{
currentLearningSetupIndex = 0;
currentBathDataIndex = batchIndex + 1;
}
break;
}
else
{
string resultPath = simulator.OutputResult();
simulator.WeightSave(resultPath + "Status.WDATA");
currentLearningSetupIndex = 0;
currentEpoch = 0;
totalEpoch = 0;
}
}
if (learningStatus == LearningStatus.Pausing)
{
learningStatus = LearningStatus.Paused;
break;
}
}
if (learningStatus == LearningStatus.Training || learningStatus == LearningStatus.Test)
{
learningStatus = LearningStatus.End;
}
}
private void pauseButton_Click(object sender, EventArgs e)
{
learningStatus = LearningStatus.Pausing;
pauseButton.Enabled = false;
}
private void startButton_Click(object sender, EventArgs e)
{
saveLayerActivationCheckBox.Enabled = false;
saveWeightCheckBox.Enabled = false;
learningStatus = LearningStatus.Training;
startButton.Enabled = false;
pauseButton.Enabled = true;
exitButton.Enabled = false;
processThread = new Thread(new ThreadStart(ProcessThread));
controlRefreshThread = new Thread(new ThreadStart(ControlRefreshThread));
processThread.Start();
controlRefreshThread.Start();
}
private void ProcessThread()
{
for (int batchIndex = currentBathDataIndex; batchIndex < batchDataList.Count; batchIndex++)
{
learningStatus = LearningStatus.Training;
currentBathDataIndex = batchIndex;
simulator = batchDataList[batchIndex].Simulator;
learningSetupList = batchDataList[batchIndex].LearningSetupList;
simulator.UseActivationInformation = saveLayerActivationCheckBox.Checked;
simulator.UseWeightInformation = saveWeightCheckBox.Checked;
this.Invoke(new MethodInvoker(delegate
{
BatchListBoxRefresh();
TestDisplayRefresh();
}));
for (int learningSetupIndex = currentLearningSetupIndex; learningSetupIndex < learningSetupList.Count; learningSetupIndex++)
{
totalEpoch = 0;
for (int i = 0; i < learningSetupIndex; i++) totalEpoch += learningSetupList[i].TrainingEpoch;
currentLearningSetupIndex = learningSetupIndex;
List<MatchingInformation> currentTrainingMatchingInformationList = learningSetupList[learningSetupIndex].TrainingMatchingInformationList;
List<MatchingInformation> currentTestMatchingInformationList = learningSetupList[learningSetupIndex].TestMatchingInformationList;
List<TrialInformation> testMatrixTrialInformationList = new List<TrialInformation>();
foreach (MatchingInformation testMatchingInformation in currentTestMatchingInformationList)
{
bool isSRN = false;
foreach (Order order in simulator.ProcessDictionary[testMatchingInformation.ProcessName])
{
if (order.Code == OrderCode.SRNTraining || order.Code == OrderCode.SRNTest) isSRN = true;
}
List<StimuliMatrix> stimuliMatrixList;
if (isSRN && learningSetupList[learningSetupIndex].MatrixCalculationSize == 1) stimuliMatrixList = simulator.StimuliPackDictionary[testMatchingInformation.StimuliPackName].GetMatrixStimuliData(true, true, 1);
else stimuliMatrixList = simulator.StimuliPackDictionary[testMatchingInformation.StimuliPackName].GetMatrixStimuliData(false, false, simulator.StimuliPackDictionary[testMatchingInformation.StimuliPackName].Count);
foreach (StimuliMatrix stimuliMatrix in stimuliMatrixList)
{
TrialInformation newTestTrialInformation = new TrialInformation();
newTestTrialInformation.Process = simulator.ProcessDictionary[testMatchingInformation.ProcessName];
newTestTrialInformation.PatternSetup = testMatchingInformation.PatternSetup;
newTestTrialInformation.StimuliMatrix = stimuliMatrix;
testMatrixTrialInformationList.Add(newTestTrialInformation);
}
}
if (currentEpoch == 0)
{
learningStatus = LearningStatus.Test;
if (simulator.UseWeightInformation) simulator.WeightInformationReader(totalEpoch + 0);
for (int testIndex = 0; testIndex < testMatrixTrialInformationList.Count; testIndex++)
{
simulator.Process(testMatrixTrialInformationList[testIndex], totalEpoch + 0);
}
}
for (int epochIndex = currentEpoch; epochIndex < learningSetupList[learningSetupIndex].TrainingEpoch; epochIndex++)
{
learningStatus = LearningStatus.Training;
currentTick = DateTime.Now.Ticks;
currentEpoch = epochIndex;
List<TrialInformation> trainingMatrixTrialInformationList = new List<TrialInformation>();
foreach (MatchingInformation trainingMatchingInformation in currentTrainingMatchingInformationList)
{
List<StimuliMatrix> stimuliMatrixList = new List<StimuliMatrix>();
switch (learningSetupList[learningSetupIndex].TrainingProcessMode)
{
case ProcessMode.RandomAll:
case ProcessMode.RandomInStimuliPack:
stimuliMatrixList = simulator.StimuliPackDictionary[trainingMatchingInformation.StimuliPackName].GetMatrixStimuliData(true, true, learningSetupList[learningSetupIndex].MatrixCalculationSize);
break;
case ProcessMode.SequentialAll:
case ProcessMode.SequentialinStimuliPack:
stimuliMatrixList = simulator.StimuliPackDictionary[trainingMatchingInformation.StimuliPackName].GetMatrixStimuliData(true, false, learningSetupList[learningSetupIndex].MatrixCalculationSize);
break;
}
foreach (StimuliMatrix stimuliMatrix in stimuliMatrixList)
{
TrialInformation newTrainingTrialInformation = new TrialInformation();
newTrainingTrialInformation.Process = simulator.ProcessDictionary[trainingMatchingInformation.ProcessName];
newTrainingTrialInformation.PatternSetup = trainingMatchingInformation.PatternSetup;
newTrainingTrialInformation.StimuliMatrix = stimuliMatrix;
trainingMatrixTrialInformationList.Add(newTrainingTrialInformation);
}
}
switch (learningSetupList[learningSetupIndex].TrainingProcessMode)
{
case ProcessMode.RandomAll:
case ProcessMode.SequentialinStimuliPack:
trainingMatrixTrialInformationList = trainingMatrixTrialInformationList.OrderBy(x => (SimulatorAccessor.random.Next())).ToList();
break;
}
currentTrialInformationCount = trainingMatrixTrialInformationList.Count;
for (int trainingIndex = 0; trainingIndex < trainingMatrixTrialInformationList.Count; trainingIndex++)
{
currentProcessName = trainingMatrixTrialInformationList[trainingIndex].Process.Name;
currentStimuliPackName = trainingMatrixTrialInformationList[trainingIndex].StimuliMatrix.PackName;
simulator.Process(trainingMatrixTrialInformationList[trainingIndex], totalEpoch + epochIndex + 1);
currentTrainingIndex = trainingIndex;
}
if ((epochIndex + 1) % learningSetupList[learningSetupIndex].TestTiming == 0)
{
learningStatus = LearningStatus.Test;
if (simulator.UseWeightInformation) simulator.WeightInformationReader(totalEpoch + epochIndex + 1);
for (int testIndex = 0; testIndex < testMatrixTrialInformationList.Count; testIndex++)
{
simulator.Process(testMatrixTrialInformationList[testIndex], totalEpoch + epochIndex + 1);
}
try { this.Invoke(new MethodInvoker(delegate { TestDisplayRefresh(); })); }
catch { }
}
if (learningStatus == LearningStatus.Pausing)
{
currentEpoch = epochIndex + 1;
break;
}
currentTick = DateTime.Now.Ticks;
}
if (learningStatus == LearningStatus.Pausing)
{
if (currentEpoch >= learningSetupList[learningSetupIndex].TrainingEpoch)
{
currentEpoch = 0;
currentLearningSetupIndex = learningSetupIndex + 1;
}
if(currentLearningSetupIndex >= learningSetupList.Count)
{
currentLearningSetupIndex = 0;
currentBathDataIndex = batchIndex + 1;
}
break;
}
else
{
string resultPath = simulator.OutputResult();
simulator.WeightSave(resultPath + "Status.WDATA");
currentLearningSetupIndex = 0;
currentEpoch = 0;
totalEpoch = 0;
}
}
if (learningStatus == LearningStatus.Pausing)
{
learningStatus = LearningStatus.Paused;
break;
}
}
if (learningStatus == LearningStatus.Training || learningStatus == LearningStatus.Test) learningStatus = LearningStatus.End;
}
private void pauseButton_Click(object sender, EventArgs e)
{
learningStatus = LearningStatus.Pausing;
pauseButton.Enabled = false;
}
