void taskSolver_SolutionsMergingFinished(EventArgs eventArgs, TaskSolver sender) { var _bestSolution = new Solutions() { Id = allSolutions.Id, CommonData = allSolutions.CommonData, ProblemType = allSolutions.ProblemType, Solutions1 = new SolutionsSolution[1] { new SolutionsSolution() { Data = taskSolver.Solution, TaskIdSpecified = false, TimeoutOccured = allSolutions.Solutions1.Any(sol => sol.TimeoutOccured), ComputationsTime = allTime, Type = SolutionsSolutionType.Final } } }; bool result = Send(SerializeMessage <Solutions>(_bestSolution)); Console.WriteLine("Sending final solution to server."); Console.WriteLine("Work done"); m_lockStatus.WaitOne(); m_lastChangeTime = DateTime.Now; m_status.Threads[0] = new StatusThread() { State = StatusThreadState.Idle, HowLong = 0, ProblemInstanceIdSpecified = false, ProblemType = "", TaskIdSpecified = false }; m_lockStatus.Release(); }
private void importTask(ArchiveTask archTask) { models.Task task = new models.Task(archTask); task.save(); List <Entity> temps = new List <Entity>(); foreach (ArchiveTemplate archTemp in archTask.Templates) { TaskTemplate temp = new TaskTemplate(archTemp); temp.TaskID = task.ID; temps.Add(temp); } DatabaseManager.SharedManager.insertMultipleEntities(temps); foreach (ArchiveTemplate archTemp in archTask.Templates) { archTemp.ID = temps[archTask.Templates.IndexOf(archTemp)].ID; importSelectionsAndParameters(archTemp); } List <Entity> solvers = new List <Entity>(); foreach (ArchiveTaskSolver archSolv in archTask.Solvers) { TaskSolver solv = new TaskSolver(archSolv); solv.TaskID = task.ID; solvers.Add(solv); } DatabaseManager.SharedManager.insertMultipleEntities(solvers); foreach (ArchiveTaskSolver archSolv in archTask.Solvers) { archSolv.ID = solvers[archTask.Solvers.IndexOf(archSolv)].ID; } }
public void CreateSolver(string name, models.Task task) { int layers = 2 + HiddenLayers.Count; int[] neurons = new int[layers]; bool[] delays = new bool[layers - 1]; string[] afs = new string[layers - 1]; neurons[0] = InputNeuronsCount; for (int i = 1; i < layers - 1; i++) { neurons[i] = HiddenLayers[i - 1].NeuronsCount; } neurons[layers - 1] = OutputLayer.NeuronsCount; for (int i = 0; i < layers - 2; i++) { delays[i] = HiddenLayers[i].IsUsingW0; afs[i] = HiddenLayers[i].SelectedAF; } delays[layers - 2] = OutputLayer.IsUsingW0; afs[layers - 2] = OutputLayer.SelectedAF; PerceptronTopology t = new PerceptronTopology(layers, neurons, delays, afs); TaskSolver ts = new TaskSolver() { Name = name, TypeName = "Perceptron", TaskID = task.ID, Description = t }; ts.save(); }
/// <summary> /// Throws an exception occured in task solver if it is in error state. /// </summary> /// <param name="taskSolver">Extended task solver instance.</param> public static void ThrowIfError(this TaskSolver taskSolver) { if (taskSolver.State == TaskSolver.TaskSolverState.Error) { throw taskSolver.Exception ?? new Exception("Unidentified error in task solver."); } }
/// <summary> /// Method used to register ComputationalNode by sending register Message /// </summary> /// <returns>Method return true, if ComputationalNode successfully send RegisterMessage; otherwise false</returns> private bool RegisterComponent() { var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies().ToList(); var loadedPaths = loadedAssemblies.Select(a => a.Location).ToArray(); var referencedPaths = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory, "*.dll"); var toLoad = referencedPaths.Where(r => !loadedPaths.Contains(r, StringComparer.InvariantCultureIgnoreCase)).ToList(); toLoad.ForEach(path => loadedAssemblies.Add(AppDomain.CurrentDomain.Load(AssemblyName.GetAssemblyName(path)))); List <Assembly> list = AppDomain.CurrentDomain.GetAssemblies().ToList(); List <Type> myTypes = new List <Type>(); foreach (var asem in list) { foreach (var type in asem.GetTypes()) { if (type.BaseType == typeof(TaskSolver)) { myTypes.Add(type); } } } Register register = new Register(); register.Type = RegisterType.ComputationalNode; register.SolvableProblems = new string[myTypes.Count]; for (int i = 0; i < myTypes.Count; i++) { TaskSolver solv = (TaskSolver)Activator.CreateInstance(myTypes[i], new byte[0]); register.SolvableProblems[i] = solv.Name; } register.ParallelThreads = (byte)m_status.Threads.Length; return(Send(SerializeMessage <Register>(register))); }
public KohonenInfoViewModel(models.Task task, models.TaskSolver solver) { this.task = task; taskSolver = solver; KohonenNNTopology t = solver.Description as KohonenNNTopology; Inputs = Convert.ToInt32(t.GetInputsCount()); Outputs = Convert.ToInt32(t.GetOutputsCount()); Width = t.GetLayerWidth(); Height = t.GetLayerHeight(); Metric = t.GetMetric(); ClassInitializer = t.GetClassInitializer(); ClassEps = t.GetClassEps(); Name = solver.Name; TaskName = task.Name; TileGraphs = new ObservableCollection <TileGraphViewModel>(); SizeOfTile = 10; paramNames = new string[] { }; data = new List <Tuple <int2d, double> >[] { }; addHandler = new ActionHandler( () => { TileGraphs.Add(new TileGraphViewModel(Width, Height, SizeOfTile) { DeleteCallback = DeleteGraph, ParameterNames = paramNames, Data = data }); }, (e) => true); }
private void ReceivePartialSolutions(Solutions _solution) { bool isEnd = false; /* var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies().ToList(); * List<string> loadedP = new List<string>(); * foreach (var asembly in loadedAssemblies) * { * try * { * string s = asembly.Location; * loadedP.Add(s); * } * catch (Exception) { } * } * var loadedPaths = loadedP.ToArray(); * var referencedPaths = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory, "*.dll"); * var toLoad = referencedPaths.Where(r => !loadedPaths.Contains(r, StringComparer.InvariantCultureIgnoreCase)).ToList(); * toLoad.ForEach(path => loadedAssemblies.Add(AppDomain.CurrentDomain.Load(AssemblyName.GetAssemblyName(path))));*/ List <Assembly> list = AppDomain.CurrentDomain.GetAssemblies().ToList(); Type myType = null; foreach (var asem in list) { foreach (var type in asem.GetTypes()) { if (type.BaseType == typeof(TaskSolver)) { TaskSolver solv = (TaskSolver)Activator.CreateInstance(type, new byte[0]); if (solv.Name == _solution.ProblemType) { myType = type; isEnd = true; break; } } } if (isEnd) { break; } } taskSolver = (UCCTaskSolver.TaskSolver)Activator.CreateInstance(myType, _solution.CommonData); Console.WriteLine("Trying to choose final solution of problem ID = {0}", _solution.Id); m_lockStatus.WaitOne(); m_lastChangeTime = DateTime.Now; m_status.Threads[0] = new StatusThread() { State = StatusThreadState.Busy, HowLong = 0, ProblemInstanceIdSpecified = true, ProblemInstanceId = _solution.Id, ProblemType = _solution.ProblemType, TaskIdSpecified = false }; m_lockStatus.Release(); Solutions finalSolution; ChooseFinalSolution(_solution); }
private void importTasksFromArchive(Archive archive) { List <Entity> tasks = models.Task.all(typeof(models.Task)); List <ArchiveTask> archTasks = archive.Tasks; foreach (ArchiveTask archTask in archTasks) { var task = tasks.FirstOrDefault(x => archTask.equalsEntity(x)); if (task != null) { List <TaskTemplate> templates = TaskTemplate.templatesOfTaskId(task.ID); List <ArchiveTemplate> archTemps = archTask.Templates; foreach (ArchiveTemplate archTemp in archTemps) { var template = templates.FirstOrDefault(x => archTemp.equalsEntity(x)); if (template != null) { List <Selection> selections = Selection.selectionsOfTaskTemplateId(template.ID); List <ArchiveSelection> archSels = archTemp.Selections; foreach (ArchiveSelection archSel in archSels) { var selection = selections.FirstOrDefault(x => archSel.equalsEntity(x)); if (selection == null) { importSelection(archSel, template.ID); } else { archSel.ID = selection.ID; } } } else { importTemplate(archTemp, task.ID); } } List <TaskSolver> solvers = TaskSolver.solversOfTaskId(task.ID); List <ArchiveTaskSolver> archSolvs = archTask.Solvers; foreach (ArchiveTaskSolver archSolver in archSolvs) { var solver = solvers.FirstOrDefault(x => archSolver.equalsEntity(x)); if (solver == null) { importTaskSolver(archSolver, task.ID); } else { archSolver.ID = solver.ID; } } } else { importTask(archTask); } } }
private void importTaskSolver(ArchiveTaskSolver archSolver, int taskId) { TaskSolver solver = new TaskSolver(archSolver); solver.TaskID = taskId; solver.save(); archSolver.ID = solver.ID; }
public LearnSolverViewModel(models.Task task, TaskSolver taskSolver) { TaskName = task.Name; SolverName = taskSolver.Name; solver = taskSolver; LearningList = new ObservableCollection <LearningModel>(); addHandler = new ActionHandler(() => Add(new LearningModel(this, task, taskSolver)), e => true); learnHandler = new ActionHandler(learnSolver, e => LearningList.All(lm => lm.CanSolve)); }
public void CreateSolver(string name, models.Task task) { InputLayer input = new InputLayer { NeuronsCount = InputNeuronsCount, ForwardConnection = InputLayerAC }; var layers = new List <WardLayer>(); for (int i = 0; i < HiddenLayers.Count; i++) { var groups = new List <NeuronsGroup>(); for (int j = 0; j < HiddenLayers[i].Groups.Count; j++) { groups.Add(new NeuronsGroup { NeuronsCount = HiddenLayers[i].Groups[j].NeuronsCount, ActivationFunction = HiddenLayers[i].Groups[j].SelectedAF, HasDelay = HiddenLayers[i].Groups[j].IsUsingW0 }); } layers.Add(new WardLayer { ForwardConnection = HiddenLayers[i].AC, Groups = groups }); } var groupsOutput = new List <NeuronsGroup>(); for (int j = 0; j < OutputLayer.Groups.Count; j++) { groupsOutput.Add(new NeuronsGroup { NeuronsCount = OutputLayer.Groups[j].NeuronsCount, ActivationFunction = OutputLayer.Groups[j].SelectedAF, HasDelay = OutputLayer.Groups[j].IsUsingW0 }); } layers.Add(new WardLayer { ForwardConnection = OutputLayer.AC, Groups = groupsOutput }); WardNNTopology wnn = new WardNNTopology(input, layers); TaskSolver ts = new TaskSolver() { Name = name, TypeName = "WardNN", TaskID = task.ID, Description = wnn }; ts.save(); }
protected virtual void OnSolutionsMergingFinished(TaskSolver sender) { ComputationsFinishedEventHandler handler = SolutionsMergingFinished; if (handler != null) { handler(EventArgs.Empty, sender); } }
protected virtual void OnProblemDividingFinished(TaskSolver sender) { ComputationsFinishedEventHandler handler = ProblemDividingFinished; if (handler != null) { handler(EventArgs.Empty, sender); } }
public void UpdateTaskTree() { for (int i = Tasks.Count - 1; i >= 0; i--) { Tasks.RemoveAt(i); } List <Entity> tasks = models.Task.all(typeof(models.Task)); foreach (models.Task task in tasks) { List <TaskSolver> solvers = TaskSolver.solversOfTaskId(task.ID); List <Selection> selections = Selection.selectionsOfDefaultTemplateWithTaskId(task.ID); var pers = new List <TaskSolver>(); var wards = new List <TaskSolver>(); var convnets = new List <TaskSolver>(); var dectrees = new List <TaskSolver>(); var kohnets = new List <TaskSolver>(); foreach (TaskSolver solver in solvers) { if (solver.TypeName.Equals("Perceptron")) { pers.Add(solver); } else if (solver.TypeName.Equals("WardNN")) { wards.Add(solver); } else if (solver.TypeName.Equals("ConvNN")) { convnets.Add(solver); } else if (solver.TypeName.Equals("DecisionTree")) { dectrees.Add(solver); } else if (solver.TypeName.Equals("KohonenNet")) { kohnets.Add(solver); } } Tasks.Add(new TaskTree (task, selections.ToArray(), pers.ToArray(), dectrees.ToArray(), wards.ToArray(), convnets.ToArray(), kohnets.ToArray(), new string[] { }, this)); } }
public void CreateSolver(string name, models.Task task) { KohonenNNTopology t = new KohonenNNTopology(Inputs, Outputs, Width, Height, float.Parse(ClassEps), SelectedInitializer, SelectedMetric); TaskSolver solver = new TaskSolver() { Name = name, TaskID = task.ID, Description = t, TypeName = "KohonenNet" }; solver.save(); }
public LearningModel(LearnSolverViewModel main, models.Task task, TaskSolver taskSolver) { CurTaskSolver = taskSolver; Task = task; deleteHandler = new ActionHandler(() => main.Delete(this), e => true); Selections = Selections; SelectedSelection = Selections[0]; SelectedScenario = LearningScenarios[0]; Preprocessings = Preprocessings; selectedPreprocessing = Preprocessings[0]; Number = -1; LearningScenarioID = -1; SelectionID = -1; CanSolve = true; }
static void Main(String[] args) { if (args.Length == 1) { //TaskSolver solver = new TaskSolver(new StringReaderInitializer()); TaskSolver solver = new TaskSolver(new FileForReading(args[0])); solver.Process(); solver.Output(new FileOutput(args[0])); //solver.Output(new ConsoleOutputExample1()); } else { Console.WriteLine("You should pass a parameter from the command line." + "This parameter must be a file name or a full path to a text file."); } }
public void CreateSolver(string name, models.Task task) { int depth = MaxTreeDepth; //WARNING!!! //Here must be selected task template //and number of inputs and outputs in it. TreeDescription td = new TreeDescription(Inputs, Outputs, depth); TaskSolver ts = new TaskSolver() { Name = name, TypeName = "DecisionTreeCART", TaskID = task.ID, Description = td }; ts.save(); }
protected override void ProcessDivideProblemMessage(DivideProblemMessage message) { if (SolvableProblems.FirstOrDefault(x => x == message.ProblemType) == null) { EventLogger.GetLog().ErrorFormat("Nie obsługiwany problem: {0}", message.ProblemType); return; } TaskSolver taskSolver = null; switch (message.ProblemType) { case ("MultiplyProblem"): taskSolver = new MultiplyTaskSolver(message.Data); break; case ("DVRP"): taskSolver = new DllProject.DvrpTaskSolver(message.Data); break; } var problemSolvingHelper = new ProblemSolvingHelper() { ProblemId = message.Id, ProblemType = message.ProblemType, TaskSolver = taskSolver, }; _problems.Add(message.Id, problemSolvingHelper); taskSolver.ProblemDividingFinished += taskSolver_ProblemDividingFinished; taskSolver.SolutionsMergingFinished += taskSolver_SolutionsMergingFinished; var thread = new IOThread { ProblemType = message.ProblemType, State = EState.Busy, RealThread = new Thread(() => DivideProblem(message, taskSolver)), ProblemInstanceId = message.Id }; _runningThreads.Add(thread); thread.RealThread.Start(); }
public void CreateSolver(string name, models.Task task) { var layers = new List <ILayer>(); foreach (ConvNNLayerViewModel layerVM in Layers) { layers.Add(layerVM.LayerParameters.LayerModel); } var t = new ConvNNTopology(InputWidth, InputHeight, InputDepth, layers); TaskSolver ts = new TaskSolver() { Name = name, TypeName = "ConvNN", TaskID = task.ID, Description = t }; ts.save(); }
private void DivideProblem(DivideProblemMessage msg, TaskSolver taskSolver) { var partialProblemsData = taskSolver.DivideProblem((int)msg.ComputationalNodes); var messagesList = new List <SolvePartialProblemsMessage>(); for (int i = partialProblemsData.Length - 1; i >= 0; i -= PartialProblemsPackageSize) { var packageSize = i + 1 < PartialProblemsPackageSize ? i + 1 : PartialProblemsPackageSize; var partialProblemsPackage = new byte[packageSize][]; for (int j = 0; j < packageSize; j++) { partialProblemsPackage[j] = partialProblemsData[i - j]; } var partialProblemsObjects = new List <PartialProblem>(); foreach (var partialData in partialProblemsPackage) { partialProblemsObjects.Add(new PartialProblem() { Data = partialData, TaskId = ++_maxTaskId }); } _problems[msg.Id].PartialProblems.AddRange(partialProblemsObjects); //TODO: NA PEWNO NIE MILIJON TAJMAŁTUW var partialProblemsMsg = new SolvePartialProblemsMessage(msg.ProblemType, msg.Id, new byte[0], 100000000, partialProblemsObjects); messagesList.Add(partialProblemsMsg); } foreach (var partialProblemsMessage in messagesList) { var serialized = partialProblemsMessage.Serialize(); SendMessage(serialized); } var thread = GetThreadByProblemInstanceId(msg.Id); thread.State = EState.Idle; }
static void Main() { TaskSolver.Run(); }
private void ReceivePartialProblem() { try { var partialProblem = DeserializeMessage <SolvePartialProblems>(Receive()); if (partialProblem != null) { Console.WriteLine("Partial problem received from server"); Console.WriteLine("I will try to solve PartialProblem ID = {0} Task ID = {1}", partialProblem.Id, partialProblem.PartialProblems[0].TaskId); // for (int i = 0; i < partialProblem.PartialProblems.Length; i++) // { m_lockStatus.WaitOne(); m_lastChangeTime = DateTime.Now; if (m_status.Threads[0].State == StatusThreadState.Busy) { throw new Exception("Hard exception, I have work yet"); } m_status.Threads[0] = new StatusThread() { HowLong = 0, ProblemInstanceId = partialProblem.Id, ProblemInstanceIdSpecified = true, ProblemType = partialProblem.ProblemType, State = StatusThreadState.Busy, TaskId = partialProblem.PartialProblems[0].TaskId, TaskIdSpecified = true }; m_lockStatus.Release(); //int[] boundaries = SerializeToClass<int[]>(partialProblem.PartialProblems[0].Data); bool isEnd = false; /* var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies().ToList(); * var loadedPaths = loadedAssemblies.Select(a => a.Location).ToArray(); * var referencedPaths = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory, "*.dll"); * var toLoad = referencedPaths.Where(r => !loadedPaths.Contains(r, StringComparer.InvariantCultureIgnoreCase)).ToList(); * toLoad.ForEach(path => loadedAssemblies.Add(AppDomain.CurrentDomain.Load(AssemblyName.GetAssemblyName(path))));*/ List <Assembly> list = AppDomain.CurrentDomain.GetAssemblies().ToList(); Type myType = null; foreach (var asem in list) { foreach (var type in asem.GetTypes()) { if (type.BaseType == typeof(TaskSolver)) { TaskSolver solv = (TaskSolver)Activator.CreateInstance(type, new byte[0]); if (solv.Name == partialProblem.ProblemType) { myType = type; isEnd = true; break; } } } if (isEnd) { break; } } taskSolver = (UCCTaskSolver.TaskSolver)Activator.CreateInstance(myType, partialProblem.CommonData); byte[] sol = taskSolver.Solve(partialProblem.PartialProblems[0].Data, partialProblem.SolvingTimeoutSpecified ? TimeSpan.FromMilliseconds(partialProblem.SolvingTimeout) : TimeSpan.Zero); m_lockStatus.WaitOne(); Solutions solution = new Solutions() { Id = partialProblem.Id, CommonData = partialProblem.CommonData, ProblemType = partialProblem.ProblemType, Solutions1 = new SolutionsSolution[1] { new SolutionsSolution() { ComputationsTime = (ulong)((DateTime.Now - m_lastChangeTime).TotalMilliseconds), TimeoutOccured = false, TaskId = partialProblem.PartialProblems[0].TaskId, TaskIdSpecified = true, Type = SolutionsSolutionType.Partial, Data = sol } } }; m_lastChangeTime = DateTime.Now; SendPartialSolution(solution); m_lockStatus.Release(); } } catch (Exception) { if (host.Connected) { Console.WriteLine("Wrong type of message"); } else { throw new Exception(); } } }
private void SendPartialProblems(ulong id) { try { taskSolver = new DVRPTaskSolver(problem.Data); var dividedProblems = taskSolver.DivideProblem((int) problem.ComputationalNodes); var solvePartialProblemsPartialProblem = new SolvePartialProblemsPartialProblem[dividedProblems.Length]; for (int i = 0; i < dividedProblems.Length; i++) { solvePartialProblemsPartialProblem[i] = new SolvePartialProblemsPartialProblem {Data = dividedProblems[i], TaskId = ++taskId}; } var partialProblems = new SolvePartialProblems { CommonData = problem.Data, Id = id, ProblemType = "DVRP", PartialProblems = solvePartialProblemsPartialProblem, SolvingTimeout = 100000, SolvingTimeoutSpecified = true }; networkAdapter.Send(partialProblems, true); Console.WriteLine("SendSolvePartialProblems"); } catch (Exception e) { Console.WriteLine("Cannot send partial problems to server: " + e.Message); } }
void taskSolver_SolutionsMergingFinished(EventArgs eventArgs, TaskSolver sender) { EventLogger.GetLog().InfoFormat("TaskSolver {0} skonczyl mergowanie problemu", sender.Name); }
public Archive generateArchiveSystem() { scenarioRelations.Clear(); selectionRelations.Clear(); taskSolverRelations.Clear(); Archive archive = new Archive(); List <Entity> tasks = models.Task.all(typeof(models.Task)); foreach (models.Task task in tasks) { ArchiveTask archTask = new ArchiveTask(task); List <TaskTemplate> templates = TaskTemplate.templatesOfTaskId(task.ID); foreach (TaskTemplate template in templates) { ArchiveTemplate archTemp = new ArchiveTemplate(template); List <Selection> selections = Selection.selectionsOfTaskTemplateId(template.ID); foreach (Selection sel in selections) { ArchiveSelection archSel = new ArchiveSelection(sel); selectionRelations.Add(new RelationExport(sel.ID, archSel)); archTemp.Selections.Add(archSel); } List <Parameter> parameters = Parameter.parametersOfTaskTemplateId(template.ID); foreach (Parameter par in parameters) { ArchiveParameter archPar = new ArchiveParameter(par); archTemp.Parameters.Add(archPar); } archTask.Templates.Add(archTemp); } List <TaskSolver> solvers = TaskSolver.solversOfTaskId(task.ID); foreach (TaskSolver solver in solvers) { ArchiveTaskSolver archSol = new ArchiveTaskSolver(solver); taskSolverRelations.Add(new RelationExport(solver.ID, archSol)); archTask.Solvers.Add(archSol); } archive.Tasks.Add(archTask); } List <Entity> scenarios = LearningScenario.all(typeof(LearningScenario)); foreach (LearningScenario scenario in scenarios) { ArchiveScenario archScenario = new ArchiveScenario(scenario); scenarioRelations.Add(new RelationExport(scenario.ID, archScenario)); archive.Scenarios.Add(archScenario); } List <Entity> lSolvers = LearnedSolver.all(typeof(LearnedSolver)); foreach (LearnedSolver solver in lSolvers) { ArchiveLearnedSolver archSol = new ArchiveLearnedSolver(solver); List <LearningQuality> quailties = LearningQuality.qualitiesOfSolverId(solver.ID); foreach (LearningQuality quality in quailties) { ArchiveLearningQuality archQ = new ArchiveLearningQuality(quality); archSol.Qualities.Add(archQ); } var find = taskSolverRelations.Find(x => x.ID == solver.TaskSolverID); archSol.TaskSolver = (find != null) ? (ArchiveTaskSolver)find.model : null; find = selectionRelations.Find(x => x.ID == solver.SelectionID); archSol.Selection = (find != null) ? (ArchiveSelection)find.model : null; find = scenarioRelations.Find(x => x.ID == solver.LearningScenarioID); archSol.Scenario = (find != null) ? (ArchiveScenario)find.model : null; archive.LearnedSolvers.Add(archSol); } return(archive); }
void taskSolver_ProblemDividingFinished(EventArgs eventArgs, TaskSolver sender) { EventLogger.GetLog().InfoFormat("TaskSolver {0} skonczyl dzielenie problemu", sender.Name); }
public SelectionLearnStatisticViewModel(Selection selection, string taskName) { CurSelection = selection; List <Entity> selections = Selection.where (new Query("Selection").addTypeQuery(TypeQuery.select) .addCondition("Name", "=", selection.Name), typeof(Selection)); List <Entity> learnedSolvers = new List <Entity>(); foreach (Selection sel in selections) { learnedSolvers.AddRange(LearnedSolver.where (new Query("LearnedSolver").addTypeQuery(TypeQuery.select) .addCondition("SelectionID", "=", sel.ID.ToString()), typeof(LearnedSolver))); } List <LearnedSolverViewModel> listLearnedSolverViewModel = new List <LearnedSolverViewModel>(); ISet <string> nameLearnedSolver = new HashSet <string>(); Dictionary <string, List <LearnedSolver> > dictionarytaskSolverToLearnedSolver = new Dictionary <string, List <LearnedSolver> >(); foreach (LearnedSolver learnedSolver in learnedSolvers) { TaskSolver taskSolver = (TaskSolver)TaskSolver.getById(learnedSolver.TaskSolverID, typeof(TaskSolver)); List <LearnedSolver> learnedSolverForCurSolver; if (dictionarytaskSolverToLearnedSolver.TryGetValue(taskSolver.Name, out learnedSolverForCurSolver)) { learnedSolverForCurSolver.Add(learnedSolver); dictionarytaskSolverToLearnedSolver[taskSolver.Name] = learnedSolverForCurSolver; } else { learnedSolverForCurSolver = new List <LearnedSolver>() { learnedSolver }; dictionarytaskSolverToLearnedSolver.Add(taskSolver.Name, learnedSolverForCurSolver); } } foreach (KeyValuePair <string, List <LearnedSolver> > pair in dictionarytaskSolverToLearnedSolver) { listLearnedSolverViewModel.Add(new LearnedSolverViewModel(pair.Value) { Name = pair.Key }); } LearnedSolvers = listLearnedSolverViewModel.ToArray(); SolversToLearn = new ObservableCollection <SolverLearnRowViewModel> { new SolverLearnRowViewModel(this) { SelectedName = "Персептрон 1" } }; TaskName = taskName; SelectionName = selection.Name; addHandler = new ActionHandler( () => { SolversToLearn.Add(new SolverLearnRowViewModel(this) { SelectedName = "Персептрон " + (SolversToLearn.Count + 1) }); }, e => true); learnCommand = new ActionHandler(learnSolver, e => true); }
private void learnSolver() { foreach (SolverLearnRowViewModel solverLearnRowViewModel in SolversToLearn) { TaskSolver Solver = (TaskSolver)TaskSolver.where (new Query("TaskSolver").addTypeQuery(TypeQuery.select) .addCondition("Name", "=", solverLearnRowViewModel.SelectedName), typeof(TaskSolver))[0]; foreach (LearningDetailsViewModel learningDetailsViewModel in solverLearnRowViewModel.LearningDetails) { TaskTemplate taskTemplate = (TaskTemplate)TaskTemplate.where (new Query("TaskTemplate").addTypeQuery(TypeQuery.select) .addCondition("Name", "=", learningDetailsViewModel.SelectedPreprocessing), typeof(TaskTemplate))[0]; Selection selection = (Selection)Selection.where (new Query("Selection").addTypeQuery(TypeQuery.select) .addCondition("TaskTemplateID", "=", taskTemplate.ID.ToString()) .addCondition("Name", "=", CurSelection.Name), typeof(Selection))[0]; int countRows = selection.RowCount; LearningScenario learningScenario = (LearningScenario)LearningScenario.where (new Query("LearningScenario").addTypeQuery(TypeQuery.select) .addCondition("Name", "=", learningDetailsViewModel.SelectedScenario), typeof(LearningScenario))[0]; List <Entity> selectionRows = SelectionRow.where (new Query("SelectionRow").addTypeQuery(TypeQuery.select) .addCondition("SelectionID", "=", selection.ID.ToString()), typeof(SelectionRow)); List <Entity> parameters = dms.models.Parameter.where (new Query("Parameter").addTypeQuery(TypeQuery.select) .addCondition("TaskTemplateID", "=", selection.TaskTemplateID.ToString()), typeof(dms.models.Parameter)); int stepRow = 0; float[][] inputData = new float[countRows][]; float[] outputData = new float[countRows]; for (int i = 0; i < countRows; i++) { inputData[i] = new float[parameters.Count - 1]; } int outputParam = 0; foreach (Entity selRow in selectionRows) { int selectionRowId = selRow.ID; int stepParam = 0; foreach (Entity param in parameters) { int paramId = param.ID; List <Entity> value = ValueParameter.where (new Query("ValueParameter").addTypeQuery(TypeQuery.select) .addCondition("ParameterID", "=", paramId.ToString()). addCondition("SelectionRowID", "=", selectionRowId.ToString()), typeof(ValueParameter)); if (((dms.models.Parameter)param).IsOutput == 1) { outputParam = param.ID; string outputValue = ((ValueParameter)value[0]).Value; float outputFloat; if (float.TryParse(outputValue, out outputFloat)) { outputData[stepRow] = outputFloat; } } else { inputData[stepRow][stepParam] = float.Parse(((ValueParameter)value[0]).Value, CultureInfo.InvariantCulture.NumberFormat); } stepParam++; } stepRow++; } ISolver isolver = null; if (Solver.Description is PerceptronTopology) { PerceptronTopology topology = Solver.Description as PerceptronTopology; isolver = new PerceptronManaged(topology); } else if (Solver.Description is ConvNNTopology) { ConvNNTopology topology = Solver.Description as ConvNNTopology; isolver = new ConvNNManaged(topology); } else if (Solver.Description is WardNNTopology) { WardNNTopology topology = Solver.Description as WardNNTopology; isolver = new WardNNManaged(topology); } else if (Solver.Description is TreeDescription) { TreeDescription topology = Solver.Description as TreeDescription; isolver = new DecisionTree(topology); } else { throw new EntryPointNotFoundException(); } SeparationOfDataSet s = new SeparationOfDataSet(isolver, learningScenario, inputData, outputData); LearnedSolver ls = new LearnedSolver() { SelectionID = selection.ID, LearningScenarioID = learningScenario.ID, TaskSolverID = Solver.ID, Soul = s.separationAndLearn(selection.ID, outputParam) }; ls.save(); LearningQuality lq = new LearningQuality() { LearnedSolverID = ls.ID, MistakeTrain = Convert.ToInt32(s.MistakeTrain), MistakeTest = Convert.ToInt32(s.MistakeTest), ClosingError = s.ClosingError }; lq.save(); } } }
private void DivideProblem(DivideProblem _problem) { bool isEnd = false; /* var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies().ToList(); * List<string> loadedP=new List<string>(); * foreach (var asembly in loadedAssemblies) * { * try * { * string s = asembly.Location; * loadedP.Add(s); * } * catch (Exception) { } * } * * * var loadedPaths = loadedP.ToArray(); * var referencedPaths = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory, "*.dll"); * var toLoad = referencedPaths.Where(r => !loadedPaths.Contains(r, StringComparer.InvariantCultureIgnoreCase)).ToList(); * toLoad.ForEach(path => loadedAssemblies.Add(AppDomain.CurrentDomain.Load(AssemblyName.GetAssemblyName(path))));*/ List <Assembly> list = AppDomain.CurrentDomain.GetAssemblies().ToList(); Type myType = null; foreach (var asem in list) { foreach (var type in asem.GetTypes()) { if (type.BaseType == typeof(TaskSolver)) { TaskSolver solv = (TaskSolver)Activator.CreateInstance(type, new byte[0]); if (solv.Name == _problem.ProblemType) { myType = type; isEnd = true; break; } } } if (isEnd) { break; } } taskSolver = (UCCTaskSolver.TaskSolver)Activator.CreateInstance(myType, _problem.Data); byte[][] partials = taskSolver.DivideProblem((int)_problem.ComputationalNodes); SendPartialProblem(_problem, partials); m_lockStatus.WaitOne(); m_lastChangeTime = DateTime.Now; m_status.Threads[0] = new StatusThread() { State = StatusThreadState.Idle, HowLong = 0, ProblemInstanceIdSpecified = false, ProblemType = "", TaskIdSpecified = false }; m_lockStatus.Release(); //List<List<List<List<int>>>> permutationForNodes = new List<List<List<List<int>>>>(); //for (int i = 0; i < (int)_problem.ComputationalNodes; i++) // permutationForNodes.Add(new List<List<List<int>>>()); //int ind = 0; //foreach (var set in allDevisions) // { // permutationForNodes[ind].Add(set); // ind = (ind + 1) % (int)_problem.ComputationalNodes; // } // SendPartialProblem(_problem, permutationForNodes); }
public void Run(TaskSolver solver, CancellationToken cancellationToken) { _currentTask = Task.Factory.StartNew(() => solver.Calculate(cancellationToken), cancellationToken) .ContinueWith(result => OnTaskFinished(result.Result), cancellationToken); }