Exemple #1
0
        public static List <TrainingDataDto> GetTestingSet(NeuralNetworkTrainingConfig trainingConfig)
        {
            List <TrainingDataDto> trainingSet = new List <TrainingDataDto>();

            string line;

            // Read the file and display it line by line.
            System.IO.StreamReader file =
                new System.IO.StreamReader(System.IO.Path.Combine(trainingConfig.TrainingDatabaseFileRoute, trainingConfig.TrainingDatabaseTestFileName));
            while ((line = file.ReadLine()) != null)
            {
                var trainingRow = new TrainingDataDto();
                var lines       = line.Split(" ", StringSplitOptions.RemoveEmptyEntries);

                trainingRow.XEntries =
                    Array.ConvertAll(lines.Take(trainingConfig.InputSize).ToArray(),
                                     System.Convert.ToDouble)
                    .ToList();

                trainingRow.YExpected = Array.ConvertAll(lines.Skip(trainingConfig.InputSize)
                                                         .Take(trainingConfig.PredictedObjects.Count).ToArray(),
                                                         System.Convert.ToDouble)
                                        .ToList();

                trainingSet.Add(trainingRow);
            }
            file.Close();

            return(trainingSet);
        }
Exemple #2
0
        public async Task <IActionResult> UploadTrainingData(int id, TrainingDataDto model)
        {
            try
            {
                if (!ModelState.IsValid || model.TrainingSet == null)
                {
                    return(BadRequest("VALIDATION_INVALIDTRAININGDATA"));
                }
                var userId    = User.FindFirst(ClaimTypes.NameIdentifier).Value;
                var neuralNet = await _dbcontext.NeuralNets.Include(nn => nn.Layers).ThenInclude(l => l.Neurons).Where(nn => nn.Id == id && nn.UserId == userId).FirstOrDefaultAsync();

                if (neuralNet == null)
                {
                    return(BadRequest());
                }
                var inputLayer  = neuralNet.Layers.OrderBy(l => l.Order).FirstOrDefault().Neurons.Count();
                var outputLayer = neuralNet.Layers.OrderByDescending(l => l.Order).FirstOrDefault().Neurons.Count();

                if (model.TrainingSet.Any(ts => ts.Input.Count != inputLayer || ts.Output.Count != outputLayer))
                {
                    return(BadRequest("VALIDATION_INVALIDTRAININGDATA"));
                }

                var dbTrainingData = new TrainingData
                {
                    Name        = model.Name,
                    NeuralNetId = id,
                    TrainingSet = model.TrainingSet.Select(ts => new TrainingSet
                    {
                        Input  = ts.Input,
                        Output = ts.Output
                    }).ToList()
                };

                await _dbcontext.TrainingData.AddAsync(dbTrainingData);

                await _dbcontext.SaveChangesAsync();

                model.Id = dbTrainingData.Id;

                return(Ok(model));
            }
            catch (Exception ex)
            {
                return(BadRequest(ex));
            }
        }