public void TrainNetwork(NetworkModel network, NetworksStorageModel storage, QueryDataFormat dataFormat, TaskProgressVM taskProgressVM = null)
        {
            if (taskProgressVM != null)
            {
                taskProgressVM.EndValue = TrainDatas.Count;
                taskProgressVM.TaskName = "Training network";
            }

            if (network.Generation == 0)
            {
                SaveHistory(network);
            }

            Parallel.ForEach(TrainDatas, (model) =>
            {
                var trainData = new MNIST28x28TrainData(model);
                network.Train(trainData);


                if (taskProgressVM != null)
                {
                    taskProgressVM.Value++;
                }
            });

            network.Generation++;
            SaveHistory(network);
            _workshopModel.SaveStorageAsync(storage.Id.ToString());
        }
        public async void LoadTrainFile(string fileName, QueryDataFormat dataFormat, TaskProgressVM taskVM = null)
        {
            TrainDatas.Clear();

            switch (dataFormat)
            {
            case QueryDataFormat.BlackMNIST28x28:
                var mnistDatas = await _fileService.ReadFromFileAsync(fileName, new CsvMNISTFileReadStrategy());

                if (taskVM != null)
                {
                    taskVM.EndValue = mnistDatas.Count();
                }

                foreach (var data in mnistDatas)
                {
                    var dataModel = new QueryDataModel();
                    dataModel.Marker      = data.Marker.ToString();
                    dataModel.InputValues = (from v in data.PixelsValues select(float) v).ToArray();
                    TrainDatas.Add(dataModel);

                    if (taskVM != null)
                    {
                        taskVM.Value++;
                    }
                }
                break;
            }
        }
        public string QueryNetwork(NetworkModel network, QueryDataModel queryData, QueryDataFormat dataFormat)
        {
            switch (dataFormat)
            {
            case QueryDataFormat.BlackMNIST28x28:
                var outputs = network.Query(queryData.InputValues);
                return(queryData.Marker = Array.IndexOf(outputs, outputs.Max()).ToString());

            default:
                return("Bad request");
            }
        }
        public QueryDataModel BackQuery(NetworkModel network, QueryDataModel targetData, QueryDataFormat dataFormat)
        {
            switch (dataFormat)
            {
            case QueryDataFormat.BlackMNIST28x28:
                var inputs = network.BackQuery(targetData.OutputValues);
                var data   = new QueryDataModel()
                {
                    InputValues  = inputs,
                    Marker       = targetData.Marker,
                    OutputValues = targetData.OutputValues
                };
                var readyData = new MNIST28x28BackQueryData(data);
                return(readyData);

            default:
                return(null);
            }
        }