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);
}
