public SolverTree(models.Task task,
models.TaskSolver[] per,
models.TaskSolver[] desCART,
models.TaskSolver[] desC4_5,
models.TaskSolver[] wards,
models.TaskSolver[] convnets,
models.TaskSolver[] kohnets,
TaskTreeViewModel vm) : base("Решатели")
{
ParentTask = task.Name;
Content = new ObservableCollection <TreeSection>
{
new PerceptronTree(task, per, vm),
new DecisionTreesCARTTree(task, desCART, vm),
new DecisionTreesC4_5Tree(task, desC4_5, vm),
new WardTree(task, wards, vm),
new ConvNNTree(task, convnets, vm),
new KohonenTree(task, kohnets, vm)
};
createSolverCommand = new ActionHandler(() =>
{
SolverCreationViewModel t = new SolverCreationViewModel(task);
t.OnClose += (s, p) => vm.UpdateTaskTree();
vm.SendRequestCreateView(t);
}, o => true);
}
public PerceptronInfoViewModel(models.Task task, models.TaskSolver solver)
{
TaskName = task.Name;
Name = solver.Name;
PerceptronTopology topology = solver.Description as PerceptronTopology;
Layers = new Layer[topology.GetLayersCount() - 1];
var neurons = topology.GetNeuronsInLayersCount();
var delays = topology.HasLayersDelayWeight();
var afs = topology.GetActivationFunctionsNames();
CountInputNeurons = Convert.ToInt32(topology.GetInputsCount());
for (int i = 0; i < Layers.Length - 1; i++)
{
Layers[i] = new Layer
{
Name = String.Format("{0} слой", i + 1),
ActivateFunction = afs[i],
NeuronsCount = neurons[i + 1],
HasW0 = delays[i]
};
}
Layers[Layers.Length - 1] = new Layer
{
Name = "Выходной слой",
ActivateFunction = afs[Layers.Length - 1],
NeuronsCount = neurons[Layers.Length],
HasW0 = delays[Layers.Length - 1]
};
}
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();
}
public TaskTree(models.Task task,
models.Selection[] sel,
models.TaskSolver[] per,
models.TaskSolver[] desCART,
models.TaskSolver[] desC4_5,
models.TaskSolver[] wards,
models.TaskSolver[] convnets,
models.TaskSolver[] kohnets,
string[] solv,
TaskTreeViewModel vm)
{
Title = task.Name;
Content = new ObservableCollection <TreeSection>
{
new SelectionTree(task, sel, vm),
new SolverTree(task, per, desCART, desC4_5, wards, convnets, kohnets, vm),
new SolutionsTree(Title, solv, vm)
};
deleteCommand = new ActionHandler(
() =>
{
new dms.services.preprocessing.DataHelper().deleteTask(task);
vm.UpdateTaskTree();
}, e => true);
showInfoDialogCommand = new ActionHandler(() =>
{
TaskInfoViewModel t = new TaskInfoViewModel(task);
vm.SendRequestCreateView(t);
}, e => true);
showPreprocessingCreationHandler = new ActionHandler(() =>
{
PreprocessingViewModel t = new PreprocessingViewModel(task, -1);
vm.SendRequestCreateView(t);
}, e => true);
}
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 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);
}
public CreateSolutionViewModel(string taskName)
{
canSave = true;
Task = (models.Task)models.Task.where (new Query("Task").addTypeQuery(TypeQuery.select)
.addCondition("Name", "=", taskName), typeof(models.Task))[0];
createHandler = new ActionHandler(createSolution, e => CanSave());
TaskName = taskName;
TemplateName = Templates[0];
}
public DecisionTreesCARTTree(models.Task task, models.TaskSolver[] trees,
TaskTreeViewModel vm) : base("Деревья решений CART", trees.Select(x => x.Name).ToArray())
{
Content = new ObservableCollection <TreeSection>();
for (int i = 0; i < trees.Length; i++)
{
Content.Add(new SolverLeaf(task, trees[i], "DecisionTreeCART", vm));
}
}
public KohonenTree(models.Task task, models.TaskSolver[] koh_nets,
TaskTreeViewModel vm) : base("Сети Кохонена", koh_nets.Select(x => x.Name).ToArray())
{
Content = new ObservableCollection <TreeSection>();
for (int i = 0; i < koh_nets.Length; i++)
{
Content.Add(new SolverLeaf(task, koh_nets[i], "Сеть Кохонена", vm));
}
}
public WardTree(models.Task task, models.TaskSolver[] wards,
TaskTreeViewModel vm) : base("Сети Ворда", wards.Select(x => x.Name).ToArray())
{
Content = new ObservableCollection <TreeSection>();
for (int i = 0; i < wards.Length; i++)
{
Content.Add(new SolverLeaf(task, wards[i], "Нейронная сеть Ворда", vm));
}
}
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();
}
public PerceptronTree(models.Task task, models.TaskSolver[] perceptrons,
TaskTreeViewModel vm) : base("Персептроны", perceptrons.Select(x => x.Name).ToArray())
{
Content = new ObservableCollection <TreeSection>();
for (int i = 0; i < perceptrons.Length; i++)
{
Content.Add(new SolverLeaf(task, perceptrons[i], "Персептрон", vm));
}
}
public ConvNNTree(models.Task task, models.TaskSolver[] convs,
TaskTreeViewModel vm) : base("Сверточные НС", convs.Select(x => x.Name).ToArray())
{
Content = new ObservableCollection <TreeSection>();
for (int i = 0; i < convs.Length; i++)
{
Content.Add(new SolverLeaf(task, convs[i], "Сверточная нейронная сеть", vm));
}
}
public DecisionTreeC4_5InfoViewModel(models.Task task, models.TaskSolver solver)
{
TaskName = task.Name;
Name = solver.Name;
TreeDescriptionC4_5 td = solver.Description as TreeDescriptionC4_5;
MaxTreeDepth = td.MaxDepth;
}
public SolveViewModel(models.Task task, models.TaskSolver solver)
{
TaskID = task.ID;
SolvingList = new ObservableCollection <SolvingInstance>();
SolverName = solver.Name;
TaskName = task.Name;
List <LearningInfo> learningList = new List <LearningInfo>();
List <models.LearnedSolver> learnedSolvers = models.LearnedSolver.learnedSolversOfTaskSolverID(solver.ID);
foreach (models.LearnedSolver learnedSolver in learnedSolvers)
{
models.Selection selection = (models.Selection)models.Selection.getById(learnedSolver.SelectionID, typeof(models.Selection));
List <models.LearningQuality> qualities = models.LearningQuality.qualitiesOfSolverId(learnedSolver.ID);
models.LearningScenario scenario = (models.LearningScenario)models.LearningScenario.getById(learnedSolver.LearningScenarioID, typeof(models.LearningScenario));
models.TaskTemplate template = (models.TaskTemplate)models.TaskTemplate.getById(selection.TaskTemplateID, typeof(models.TaskTemplate));
models.LearningQuality quality = (qualities != null && qualities.Count > 0) ? qualities[0] : null;
List <models.Parameter> parameters = models.Parameter.parametersOfTaskTemplateId(template.ID);
int outputParam = 0;
foreach (models.Parameter param in parameters)
{
if (param.IsOutput == 1)
{
outputParam = param.ID;
break;
}
}
learningList.Add(new LearningInfo
{
SelectionID = selection.ID,
ParameterID = outputParam,
SelectionName = selection.Name,
LearningScenarioName = scenario.Name,
PreprocessingName = template.Name,
TestMistake = (quality != null) ? quality.MistakeTest : 0,
TrainMistake = (quality != null) ? quality.MistakeTrain : 0,
ClosingError = Convert.ToSingle((quality != null) ? quality.ClosingError : 0),
TaskTemplate = template,
LearnedSolver = learnedSolver
});
}
LearningList = learningList.ToArray();
addHandler = new ActionHandler(() =>
{
SolvingList.Add(new SolvingInstance(this, this.SelectedLearning.TaskTemplate));
solveHandler.RaiseCanExecuteChanged();
saveHandler.RaiseCanExecuteChanged();
SelectedSolution = Solutions[0];
NotifyPropertyChanged("SelectedSolution");
NotifyPropertyChanged("Solutions");
}, e => SelectedLearning != null);
solveHandler = new ActionHandler(Solve, e => SolvingList.Count > 0);
saveHandler = new ActionHandler(saveSolutions, e => SolvingList.Count > 0);
SelectedSolution = Solutions[0];
}
public SolverLeaf(models.Task task, models.TaskSolver solver, string solverType,
TaskTreeViewModel vm) : base(solver.Name)
{
parentTask = task;
this.solverType = solverType;
this.solver = solver;
showSolverInfoHandler = new ActionHandler(() => vm.SendRequestCreateView(CreateSolverInfoViewModel()), e => true);
showSolveDialogHandler = new ActionHandler(() => vm.SendRequestCreateView(new SolveViewModel(parentTask, solver)), e => true);
showLearnDialogHandler = new ActionHandler(() => vm.SendRequestCreateView(new LearnSolverViewModel(parentTask, solver)), e => true);
}
public SolverCreationViewModel(models.Task task)
{
parentTask = task;
TaskName = task.Name;
SolverName = "Решатель 1";
SolverTypes = SolverParameterFactory.Types;
SelectedType = SolverTypes[0];
createHandler = new ActionHandler(CreateSolver, o => Parameters.CanCreateSolver(SolverName, parentTask));
cancelHandler = new ActionHandler(() => OnClose?.Invoke(this, null), o => true);
}
public void CreateTask()
{
if (this.taskName == "")
{
return;
}
models.Task newTask = new models.Task();
newTask.Name = this.taskName;
newTask.save();
taskCreate.Invoke(true);
OnClose?.Invoke(this, null);
}
public TaskInfoViewModel(models.Task task)
{
TaskName = task.Name;
List <Entity> taskTemplates = TaskTemplate.where (new Query("TaskTemplate").addTypeQuery(TypeQuery.select)
.addCondition("TaskID", "=", task.ID.ToString()), typeof(TaskTemplate));
List <TaskTemplate> prepTemplates = new List <TaskTemplate>();
Templates = new TemplateViewModel[taskTemplates.Count];
int step = 0;
if (taskTemplates.Count != 0)
{
foreach (Entity template in taskTemplates)
{
if (((TaskTemplate)template).PreprocessingParameters != null)
{
prepTemplates.Add((TaskTemplate)template);
// really?
Templates[step] = new TemplateViewModel(((TaskTemplate)template).ID, step);
step++;
}
else
{
Templates[step] = new TemplateViewModel(((TaskTemplate)template).ID, step);
step++;
}
}
PreprocessingList = new Preprocessing[prepTemplates.Count];
int index = 0;
foreach (TaskTemplate template in prepTemplates)
{
PreprocessingViewModel.PreprocessingTemplate pp =
(PreprocessingViewModel.PreprocessingTemplate)template.PreprocessingParameters;
List <Parameter> parameters = pp.parameters;
List <string> types = pp.types;
Tuple <Parameter, string>[] tuple = new Tuple <Parameter, string> [parameters.Count];
for (int i = 0; i < parameters.Count; i++)
{//???
tuple[i] = new Tuple <Parameter, string>(parameters[i], types[i]);
}
PreprocessingList[index] = new Preprocessing(pp.PreprocessingName, pp.BaseTemplate.Name, template.Name, tuple, template.ID);
index++;
}
SelectedTemplate = Templates[0];
}
moreHandler = new ActionHandler(() => OnShowPreprocessingDetails?.Invoke(new PreprocessingViewModel(task, SelectedPreprocessing.PerformedTemplateId)), o => SelectedPreprocessing != null);
}
public ConvNNInfoViewModel(models.Task task, models.TaskSolver solver)
{
TaskName = task.Name;
Name = solver.Name;
var t = solver.Description as ConvNNTopology;
InputDimention = String.Format("{0}x{1}x{2}", t.GetInputWidth(), t.GetInputHeigth(), t.GetInputDepth());
ilayers = t.GetLayers().ToArray();
var volumes = t.GetVolumeDimentions();
Layers = new ConvNNLayer[ilayers.Length];
for (int i = 0; i < ilayers.Length; i++)
{
if (ilayers[i] is FullyConnectedLayer)
{
Layers[i] = new ConvNNLayer
{
Number = i + 1,
Type = "FC",
Width = volumes[i].Width,
Height = volumes[i].Heigth,
Depth = volumes[i].Depth
};
}
else if (ilayers[i] is ConvolutionLayer)
{
Layers[i] = new ConvNNLayer
{
Number = i + 1,
Type = "Conv",
Width = volumes[i].Width,
Height = volumes[i].Heigth,
Depth = volumes[i].Depth
};
}
else if (ilayers[i] is PoolingLayer)
{
Layers[i] = new ConvNNLayer
{
Number = i + 1,
Type = "Pool",
Width = volumes[i].Width,
Height = volumes[i].Heigth,
Depth = volumes[i].Depth
};
}
}
}
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;
}
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 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();
}
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();
}
public SelectionTree(models.Task task, models.Selection[] selections,
TaskTreeViewModel vm) : base("Выборки")
{
createSelection = new ActionHandler(() =>
{
SelectionCreationViewModel t = new SelectionCreationViewModel(task.ID, vm);
vm.SendRequestCreateView(t);
}, e => true);
ParentTask = task.Name;
Content = new ObservableCollection <TreeSection>();
for (int i = 0; i < selections.Length; i++)
{
int templateId = selections[i].TaskTemplateID;
TaskTemplate template = ((TaskTemplate)dms.services.DatabaseManager.SharedManager.
entityById(templateId, typeof(TaskTemplate)));
if (template.PreprocessingParameters == null)
{
Content.Add(new SelectionLeaf(task, selections[i], vm));
}
}
}
public SelectionLeaf(models.Task task, models.Selection selection, TaskTreeViewModel vm)
{
Title = selection.Name;
parentTask = task.Name;
deleteHandler = new ActionHandler(
() =>
{
new dms.services.preprocessing.DataHelper().deleteSelection(selection);
vm.UpdateTaskTree();
}, e => true);
showSelectionInfoHandler = new ActionHandler(
() =>
{
SelectionInfoViewModel t = new SelectionInfoViewModel(task.ID, selection.ID);
vm.SendRequestCreateView(t);
}, e => true);
showSelectionLearnHandler = new ActionHandler(
() =>
{
var t = new SelectionLearnStatisticViewModel(selection, task.Name);
vm.SendRequestCreateView(t);
}, e => true);
}
public async Task <IActionResult> AddTask(int userId, string taskText)
{
if (!IsUserAuthenticated(userId))
{
return(BadRequest());
}
var user = await _context.Users.FirstOrDefaultAsync(x => x.Id == userId);
var newTask = new models.Task()
{
TaskText = taskText,
IsDone = false,
User = user
};
await _context.Tasks.AddAsync(newTask);
_context.SaveChanges();
var toDoTasks = await _context.Tasks.Where(x => x.IsDone == false && x.User.Id == userId).ToListAsync();
return(StatusCode(201, toDoTasks));
}
public ArchiveTask(models.Task task)
{
this.ID = task.ID;
this.Name = task.Name;
}
public bool CanCreateSolver(string name, models.Task task)
{
return(true);
}
