/// <inheritdoc /> protected override void Then(TrainingWindow window) { ICourse result = ExtractTraining(window); IChapter firstChapter = result.Data.Chapters.First(); // The chapter exits Assert.NotNull(firstChapter); // The step exits IStep firstStep = firstChapter.Data.FirstStep; Assert.NotNull(firstChapter); IList <ITransition> transitions = GetTransitionsFromStep(firstStep); // It has two transition. Assert.That(transitions.Count == 2); ITransition firstTransition = transitions[0]; ITransition secondTransition = transitions[1]; IStep nextStep; // The first step's transition points to itself. if (TryToGetStepFromTransition(firstTransition, out nextStep)) { Assert.That(firstStep == nextStep); } // The second step's transition is the end of the course. Assert.False(TryToGetStepFromTransition(secondTransition, out nextStep)); }
/// <inheritdoc /> protected override void Then(TrainingWindow window) { ICourse result = ExtractTraining(window); IChapter firstChapter = result.Data.Chapters.First(); Assert.NotNull(firstChapter); IStep firstStep = firstChapter.Data.FirstStep; Assert.NotNull(firstStep); IList <ITransition> transitions = GetTransitionsFromStep(firstStep); Assert.That(transitions.Count == 1); IStep nextStep; if (TryToGetStepFromTransition(transitions.First(), out nextStep)) { Assert.Fail("First step is not the end of the chapter."); } Assert.Null(nextStep); }
/// <inheritdoc /> protected override TrainingWindow Given() { TrainingWindow window = base.Given(); iteratedSteps = 0; return(window); }
public void OnClickedTrainWindowButton() { this.ModelNotLoaded = false; TrainingViewModel = new TrainingWindowViewModel(ref NeuralNetwork); TrainingWindow trainWindow = new TrainingWindow(TrainingViewModel); trainWindow.ShowDialog(); }
/// <inheritdoc /> protected override void Then(TrainingWindow window) { ICourse result = ExtractTraining(window); IChapter firstChapter = result.Data.Chapters.First(); Assert.NotNull(firstChapter); IStep firstStep = firstChapter.Data.FirstStep; IList <IStep> steps = firstChapter.Data.Steps; validatedSteps.Clear(); ValidateLinearCourse(firstStep); Assert.That(iteratedSteps == steps.Count); }
public override void OnInspectorGUI() { serializedObject.Update(); UpdateSelectedConfigurationName(); UpdateSelectedCoursePath(); selectedConfigurationIndex = EditorGUILayout.Popup("Configuration", selectedConfigurationIndex, shortConfigurationTypeNames); configurationName.stringValue = configurationTypeNames[selectedConfigurationIndex]; selectedCourseIndex = EditorGUILayout.Popup("Selected Training Course", selectedCourseIndex, trainingCourseDisplayNames); if (trainingCourseStreamingAssetsPaths.Length > 0) { selectedCourseStreamingAssetsPath.stringValue = trainingCourseStreamingAssetsPaths[selectedCourseIndex]; } EditorGUI.BeginDisabledGroup(IsCourseListEmpty()); { GUILayout.BeginHorizontal(); { if (GUILayout.Button("Open course in Workflow Editor")) { TrainingWindow trainingWindow = TrainingWindow.GetWindow(); trainingWindow.LoadTrainingCourseFromFile(GetSelectedCourseAbsolutePath()); trainingWindow.Focus(); } if (GUILayout.Button(new GUIContent("Show course folder in Explorer...", Path.GetDirectoryName(GetSelectedCourseAbsolutePath())))) { EditorUtility.RevealInFinder(Path.GetDirectoryName(GetSelectedCourseAbsolutePath())); } } GUILayout.EndHorizontal(); } EditorGUI.EndDisabledGroup(); serializedObject.ApplyModifiedProperties(); }
public MainWindow() { //Static MainWindow mMainWindow = this; //Windows.main = this; DataContext = BindMngr; loadingScreen.Show(); InitializeComponent(); mTrainingWindow = new TrainingWindow(); // Setup background worker PreviewRoutine.previewSetup(); ConnectRoutine.connectionSetup(); ImageResizing.ImageResizingSetup(); ResNet.CNTK_ResNetSetup(); ZxingDecoder.DecoderSetup(); mTrainingWindow.TrainModelRoutineSetup(); OCR.OCRSetup(OCRMode.NUMBERS); // Create Directories GV.ML_Folders[(int)MLFolders.MLRoot] = Environment.CurrentDirectory + MLFolders.MLRoot.GetDescription(); GV.ML_Folders[(int)MLFolders.ML_CNTK] = Environment.CurrentDirectory + MLFolders.ML_CNTK.GetDescription(); GV.ML_Folders[(int)MLFolders.ML_CNTK_model] = Environment.CurrentDirectory + MLFolders.ML_CNTK_model.GetDescription(); GV.ML_Folders[(int)MLFolders.ML_YOLO] = Environment.CurrentDirectory + MLFolders.ML_YOLO.GetDescription(); GV.ML_Folders[(int)MLFolders.ML_YOLO_backup] = Environment.CurrentDirectory + MLFolders.ML_YOLO_backup.GetDescription(); GV.ML_Folders[(int)MLFolders.ML_YOLO_model] = Environment.CurrentDirectory + MLFolders.ML_YOLO_model.GetDescription(); GV.ML_Folders[(int)MLFolders.ML_YOLO_data] = Environment.CurrentDirectory + MLFolders.ML_YOLO_data.GetDescription(); GV.ML_Folders[(int)MLFolders.ML_YOLO_data_img] = Environment.CurrentDirectory + MLFolders.ML_YOLO_data_img.GetDescription(); foreach (string str in GV.ML_Folders) { if (str != null && !Directory.Exists(str)) { Directory.CreateDirectory(str); } } }
/// <inheritdoc /> protected override void Then(TrainingWindow window) { ICourse result = ExtractTraining(window); IChapter firstChapter = result.Data.Chapters.First(); Assert.NotNull(firstChapter); IStep firstStep = firstChapter.Data.FirstStep; Assert.NotNull(firstStep); IList <ITransition> transitions = GetTransitionsFromStep(firstStep); Assert.That(transitions.Count == 2); foreach (ITransition transition in transitions) { IStep nextStep; if (TryToGetStepFromTransition(transition, out nextStep) == false) { Assert.Fail("First step does not always go to another step."); } IList <ITransition> transitionsFromNextStep = GetTransitionsFromStep(nextStep); Assert.That(transitionsFromNextStep.Count == 1); IStep endOfChapter; if (TryToGetStepFromTransition(transitionsFromNextStep.First(), out endOfChapter)) { Assert.Fail("Branched step is not the end of the chapter."); } } }
private void open_TrainingWindow(object sender, RoutedEventArgs e) { GlobalVariable.messageQueueInterval = 15; trainingWindow = new TrainingWindow(); trainingWindow.Show(); }
private void EnterMovesButton_Click(object sender, RoutedEventArgs e) { var trainingWindow = new TrainingWindow(); trainingWindow.ShowDialog(); }
public DeepQLearn(int num_states, int num_actions, TrainingOptions opt) { this.util = new Util(); this.opt = opt; // in number of time steps, of temporal memory // the ACTUAL input to the net will be (x,a) temporal_window times, and followed by current x // so to have no information from previous time step going into value function, set to 0. this.temporal_window = opt.temporal_window != int.MinValue ? opt.temporal_window : 1; // size of experience replay memory this.experience_size = opt.experience_size != int.MinValue ? opt.experience_size : 30000; // number of examples in experience replay memory before we begin learning this.start_learn_threshold = opt.start_learn_threshold != double.MinValue ? opt.start_learn_threshold : Math.Floor(Math.Min(this.experience_size * 0.1, 1000)); // gamma is a crucial parameter that controls how much plan-ahead the agent does. In [0,1] this.gamma = opt.gamma != double.MinValue ? opt.gamma : 0.8; // number of steps we will learn for this.learning_steps_total = opt.learning_steps_total != int.MinValue ? opt.learning_steps_total : 100000; // how many steps of the above to perform only random actions (in the beginning)? this.learning_steps_burnin = opt.learning_steps_burnin != int.MinValue ? opt.learning_steps_burnin : 3000; // what epsilon value do we bottom out on? 0.0 => purely deterministic policy at end this.epsilon_min = opt.epsilon_min != double.MinValue ? opt.epsilon_min : 0.05; // what epsilon to use at test time? (i.e. when learning is disabled) this.epsilon_test_time = opt.epsilon_test_time != double.MinValue ? opt.epsilon_test_time : 0.00; // advanced feature. Sometimes a random action should be biased towards some values // for example in flappy bird, we may want to choose to not flap more often if (opt.random_action_distribution != null) { // this better sum to 1 by the way, and be of length this.num_actions this.random_action_distribution = opt.random_action_distribution; if (this.random_action_distribution.Count != num_actions) { Console.WriteLine("TROUBLE. random_action_distribution should be same length as num_actions."); } var sum_of_dist = this.random_action_distribution.Sum(); if (Math.Abs(sum_of_dist - 1.0) > 0.0001) { Console.WriteLine("TROUBLE. random_action_distribution should sum to 1!"); } } else { this.random_action_distribution = new List <double>(); } // states that go into neural net to predict optimal action look as // x0,a0,x1,a1,x2,a2,...xt // this variable controls the size of that temporal window. Actions are // encoded as 1-of-k hot vectors this.net_inputs = num_states * this.temporal_window + num_actions * this.temporal_window + num_states; this.num_states = num_states; this.num_actions = num_actions; this.window_size = Math.Max(this.temporal_window, 2); // must be at least 2, but if we want more context even more this.state_window = new List <Volume>(); this.action_window = new List <int>(); this.reward_window = new List <double>(); this.net_window = new List <double[]>(); // Init wth dummy data for (int i = 0; i < window_size; i++) { this.state_window.Add(new Volume(1, 1, 1)); } for (int i = 0; i < window_size; i++) { this.action_window.Add(0); } for (int i = 0; i < window_size; i++) { this.reward_window.Add(0.0); } for (int i = 0; i < window_size; i++) { this.net_window.Add(new double[] { 0.0 }); } // create [state -> value of all possible actions] modeling net for the value function var layer_defs = new List <LayerDefinition>(); if (opt.layer_defs != null) { // this is an advanced usage feature, because size of the input to the network, and number of // actions must check out. This is not very pretty Object Oriented programming but I can't see // a way out of it :( layer_defs = opt.layer_defs; if (layer_defs.Count < 2) { Console.WriteLine("TROUBLE! must have at least 2 layers"); } if (layer_defs[0].type != "input") { Console.WriteLine("TROUBLE! first layer must be input layer!"); } if (layer_defs[layer_defs.Count - 1].type != "regression") { Console.WriteLine("TROUBLE! last layer must be input regression!"); } if (layer_defs[0].out_depth * layer_defs[0].out_sx * layer_defs[0].out_sy != this.net_inputs) { Console.WriteLine("TROUBLE! Number of inputs must be num_states * temporal_window + num_actions * temporal_window + num_states!"); } if (layer_defs[layer_defs.Count - 1].num_neurons != this.num_actions) { Console.WriteLine("TROUBLE! Number of regression neurons should be num_actions!"); } } else { // create a very simple neural net by default layer_defs.Add(new LayerDefinition { type = "input", out_sx = 1, out_sy = 1, out_depth = this.net_inputs }); if (opt.hidden_layer_sizes != null) { // allow user to specify this via the option, for convenience var hl = opt.hidden_layer_sizes; for (var k = 0; k < hl.Length; k++) { layer_defs.Add(new LayerDefinition { type = "fc", num_neurons = hl[k], activation = "relu" }); // relu by default } } } // Create the network this.value_net = new Net(); this.value_net.makeLayers(layer_defs); // and finally we need a Temporal Difference Learning trainer! var options = new Options { learning_rate = 0.01, momentum = 0.0, batch_size = 64, l2_decay = 0.01 }; if (opt.options != null) { options = opt.options; // allow user to overwrite this } this.tdtrainer = new Trainer(this.value_net, options); // experience replay this.experience = new List <Experience>(); //DeepQLearn.experienceShared = new List<ExperienceShared>(); // static list not threadsafe DeepQLearn.experienceShared = new ConcurrentDictionary <int, ExperienceShared>(); // various housekeeping variables this.age = 0; // incremented every backward() this.forward_passes = 0; // incremented every forward() this.epsilon = 1.0; // controls exploration exploitation tradeoff. Should be annealed over time this.latest_reward = 0; //this.last_input = []; this.average_reward_window = new TrainingWindow(1000, 10); this.average_loss_window = new TrainingWindow(1000, 10); this.learning = true; }
/// <inheritdoc /> protected override TrainingWindow Given() { TrainingWindow window = base.Given(); return(window); }