Пример #1
0
        public TrainingRecord[] Parse(string imagesFile, string labelsFile)
        {
            var records = new List <TrainingRecord>();

            using (var imagesFileReader = new BinaryReader(File.Open(imagesFile, FileMode.Open)))
                using (var labelsFileReader = new BinaryReader(File.Open(labelsFile, FileMode.Open)))
                {
                    imagesFileReader.ReadInt32();
                    int images    = ReadBigEndianInt32(imagesFileReader);
                    int columns   = ReadBigEndianInt32(imagesFileReader);
                    int rows      = ReadBigEndianInt32(imagesFileReader);
                    int imageSize = columns * rows;

                    labelsFileReader.ReadInt32();
                    int labels = ReadBigEndianInt32(labelsFileReader);

                    Debug.Assert(images == labels);

                    for (int i = 0; i < images; i++)
                    {
                        var record = new TrainingRecord
                        {
                            Input  = ConvertToInput(imagesFileReader.ReadBytes(imageSize)),
                            Output = ConvertToOutput(labelsFileReader.ReadByte())
                        };
                        records.Add(record);
                    }

                    return(records.ToArray());
                }
        }
Пример #2
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,Title,Description,TimeStamp")] TrainingRecord trainingRecord)
        {
            if (id != trainingRecord.Id || !userService.IsCurrentUsersTraining(id, await _userManager.GetUserAsync(User)))
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(trainingRecord);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!TrainingRecordExists(trainingRecord.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(trainingRecord));
        }
        public ActionResult DeleteConfirmed(int id)
        {
            TrainingRecord trainingRecord = db.TrainingRecords.Find(id);

            db.TrainingRecords.Remove(trainingRecord);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
Пример #4
0
        public void Train(TrainingRecord[] trainingData, double learningRate, int miniBatchSize)
        {
            var batches = Batch.Split(Batch.Shuffle(trainingData), miniBatchSize);

            foreach (var batch in batches)
            {
                Train(batch, learningRate);
            }
        }
 public ActionResult Edit([Bind(Include = "id,nonPlayer_id,date,location,description,accidents")] TrainingRecord trainingRecord)
 {
     if (ModelState.IsValid)
     {
         db.Entry(trainingRecord).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(trainingRecord));
 }
Пример #6
0
        private Gradient BackPropagate(TrainingRecord record)
        {
            int layers = Weights.Length;

            //Feedforward
            double[][] a = new double[layers + 1][];
            double[][] z = new double[layers + 1][];
            a[0] = record.Input;

            for (int layer = 0; layer < layers; layer++)
            {
                z[layer + 1] = Math.Add(
                    Math.Product(Weights[layer], a[layer]),
                    Biases[layer + 1]);

                a[layer + 1] = Math.Sigmoid(z[layer + 1]);
            }

            //Backpropagate
            double[][] delta = Math.EmptyClone(Biases);

            delta[layers] = Math.HadamardProduct(
                Math.Subtract(a[layers], record.Output),
                Math.SigmoidPrime(z[layers]));

            for (int layer = layers - 1; layer > 0; layer--)
            {
                delta[layer] = Math.HadamardProduct(
                    Math.Product(Math.Transpose(Weights[layer]), delta[layer + 1]),
                    Math.SigmoidPrime(z[layer]));
            }

            //Gradient
            var gradient = new Gradient {
                Weights = Math.EmptyClone(Weights)
            };

            for (int layer = 0; layer < layers; layer++)
            {
                for (int j = 0; j < Weights[layer].Length; j++)
                {
                    for (int k = 0; k < Weights[layer][j].Length; k++)
                    {
                        gradient.Weights[layer][j][k] = a[layer][k] * delta[layer + 1][j];
                    }
                }
            }

            gradient.Biases = delta;

            return(gradient);
        }
        // GET: TrainingRecords/Details/5
        public ActionResult Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            TrainingRecord trainingRecord = db.TrainingRecords.Find(id);

            if (trainingRecord == null)
            {
                return(HttpNotFound());
            }
            return(View(trainingRecord));
        }
Пример #8
0
        private Gradient BackPropagate(TrainingRecord record)
        {
            int layers = Weights.Length;

            //Feedforward
            double[][] a = new double[layers + 1][];
            double[][] z = new double[layers + 1][];
            a[0] = record.Input;

            for (int layer = 0; layer < layers; layer++)
            {
                z[layer + 1] = Math.Add(
                    Math.Product(Weights[layer], a[layer]),
                    Biases[layer + 1]);

                a[layer + 1] = Math.Sigmoid(z[layer + 1]);
            }

            //Backpropagate
            double[][] delta = Math.EmptyClone(Biases);

            delta[layers] = Math.HadamardProduct(
                Math.Subtract(a[layers], record.Output),
                Math.SigmoidPrime(z[layers]));

            for (int layer = layers - 1; layer > 0; layer--)
            {
                delta[layer] = Math.HadamardProduct(
                    Math.Product(Math.Transpose(Weights[layer]), delta[layer + 1]),
                    Math.SigmoidPrime(z[layer]));
            }

            //Gradient
            var gradient = new Gradient {Weights = Math.EmptyClone(Weights)};

            for (int layer = 0; layer < layers; layer++)
            {
                for (int j = 0; j < Weights[layer].Length; j++)
                {
                    for (int k = 0; k < Weights[layer][j].Length; k++)
                    {
                        gradient.Weights[layer][j][k] = a[layer][k]*delta[layer + 1][j];
                    }
                }
            }

            gradient.Biases = delta;

            return gradient;
        }
        // GET: TrainingRecords/Edit/5
        public ActionResult Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            TrainingRecord trainingRecord = db.TrainingRecords.Find(id);

            if (trainingRecord == null)
            {
                return(HttpNotFound());
            }
            ViewBag.nonPlayer_id = new SelectList(db.nonPlayers, "id", "FullName", trainingRecord.nonPlayer_id);
            return(View(trainingRecord));
        }
Пример #10
0
        public async Task <IActionResult> Create([Bind("Id,Title,Description,TimeStamp")] TrainingRecord trainingRecord)
        {
            if (ModelState.IsValid)
            {
                var user = await _userManager.GetUserAsync(User);

                trainingRecord.TimeStamp = DateTime.Now;
                trainingRecord.User      = user;
                _context.TrainingRecords.Add(trainingRecord);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(trainingRecord));
        }
        public ActionResult Create(CoachesViewModel trainingRecord)
        {
            if (ModelState.IsValid)
            {
                TrainingRecord tr = new TrainingRecord();
                tr.nonPlayer_id = trainingRecord.nonplayer_id;
                tr.description  = trainingRecord.description;
                tr.date         = trainingRecord.date;
                tr.location     = trainingRecord.location;
                tr.accidents    = trainingRecord.accidents;
                tr.nonPlayer    = db.nonPlayers.Find(tr.nonPlayer_id);
                tr.FullName     = tr.nonPlayer.FullName;
                db.TrainingRecords.Add(tr);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            return(View(trainingRecord));
        }
Пример #12
0
    // Use this for initialization
    void Start()
    {
        List <TrainingRecord> training  = new List <TrainingRecord>();
        TrainingRecord        training1 = new TrainingRecord(TRAINING_TYPE.COIN_BANK);

        training1.AddScore(2);
        training1.AddScore(3);
        training1.AddScore(4);
        training1.AddScore(2);
        training1.AddScore(5);
        TrainingRecord training2 = new TrainingRecord(TRAINING_TYPE.DRESS_CHOICE);

        training2.AddScore(1);
        training2.AddScore(2);
        training2.AddScore(3);
        training2.AddScore(4);
        training2.AddScore(5);
        TrainingRecord training3 = new TrainingRecord(TRAINING_TYPE.PICTURE_PUZZLE);

        training3.AddScore(5);
        training3.AddScore(2);
        training3.AddScore(3);
        training3.AddScore(2);
        training3.AddScore(4);

        training.Add(training1);
        training.Add(training2);
        training.Add(training3);

        this.training = training;

        //you have to change in the ChangeChartScale's method.
        barchart.MakeChart(training,
                           ExtractRecordListUnitFromTrainingRecord,
                           ExtractIntFromRecordUnit,
                           ExtractNameFromTrainingRecord
                           );
    }
Пример #13
0
        private void Train(TrainingRecord[] batch, double learningRate)
        {
            var gradient = new Gradient
            {
                Weights = Math.EmptyClone(Weights),
                Biases = Math.EmptyClone(Biases)
            };

            foreach (var trainingRecord in batch)
            {
                var batchGradient = BackPropagate(trainingRecord);
                gradient.Weights = Math.Add(gradient.Weights, batchGradient.Weights);
                gradient.Biases = Math.Add(gradient.Biases, batchGradient.Biases);
            }

            Weights = Math.Subtract(
                Weights,
                Math.Product(learningRate/batch.Length, gradient.Weights));

            Biases = Math.Subtract(
                Biases,
                Math.Product(learningRate/batch.Length, gradient.Biases));
        }
        public TrainingRecord Post([FromBody] TrainingRecord view)
        {
            //TODO - Move validation errors to API way of doing things
            log.DebugFormat("POST {0} {1} {2}", Request.RequestUri, User.Identity.Name, JsonConvert.SerializeObject(view));
            if (!User.IsInRole("cdb.trainingeditors"))
            {
                ThrowAuthError();
            }
            //     if (!Permissions.IsAdmin && !Permissions.IsSelf(view.MemberId) && !Permissions.IsMembershipForPerson(view.MemberId)) return GetAjaxLoginError<MemberContactView>(null);
            //List<SubmitError> errors = new List<SubmitError>();

            //if (view.Member.Id == Guid.Empty)
            //{
            //    ThrowSubmitErrors(new [] { new SubmitError { Error = Strings.API_Required, Property = "Member" } });
            //}

            Data.TrainingAward model;
            model = (from a in db.TrainingAward.Include("Member").Include("Course") where a.Id == view.ReferenceId select a).FirstOrDefault();

            if (model == null)
            {
                model        = new Data.TrainingAward();
                model.Member = db.Members.Where(f => f.Id == view.Member.Id).FirstOrDefault();
                //if (model.Member == null)
                //{
                //    errors.Add(new SubmitError { Property = "Member", Error = Strings.API_NotFound });
                //    ThrowSubmitErrors(errors);
                //}
                db.TrainingAward.Add(model);
            }

            //try
            //{
            model.UploadsPending = (view.PendingUploads > 0);

            DateTime completed;

            if (string.IsNullOrWhiteSpace(view.Completed))
            {
                //                    errors.Add(new SubmitError { Property = "Completed", Error = Strings.API_Required });
            }
            else if (!DateTime.TryParse(view.Completed, out completed))
            {
                //                    errors.Add(new SubmitError { Error = Strings.API_InvalidDate, Property = "Completed" });
            }
            else
            {
                model.Completed = completed;
            }

            if (model.metadata != view.Comments)
            {
                model.metadata = view.Comments;
            }

            if (model.Member.Id != view.Member.Id)
            {
                throw new InvalidOperationException("Don't know how to change member yet");
            }

            if (view.Course.Id == null)
            {
                //                  errors.Add(new SubmitError { Error = Strings.API_Required, Id = new[] { view.ReferenceId }, Property = "Course" });
            }
            else if (model.Course == null || model.Course.Id != view.Course.Id)
            {
                model.Course = (from c in db.TrainingCourses where c.Id == view.Course.Id select c).First();
            }

            switch (view.ExpirySrc)
            {
            case "default":
                model.Expiry = model.Course.ValidMonths.HasValue ? model.Completed.AddMonths(model.Course.ValidMonths.Value) : (DateTime?)null;
                break;

            case "custom":
                if (!string.IsNullOrWhiteSpace(view.Expires))
                {
                    model.Expiry = DateTime.Parse(view.Expires);
                }
                else
                {
                    //                        errors.Add(new SubmitError { Error = Strings.API_TrainingRecord_CustomExpiryRequired, Property = "Expiry", Id = new[] { view.ReferenceId } });
                }
                break;

            case "never":
                model.Expiry = null;
                break;
            }

            // Documentation required.
            if (!model.UploadsPending && string.IsNullOrWhiteSpace(model.metadata))
            {
                //              errors.Add(new SubmitError { Error = Strings.API_TrainingRecord_DocumentationRequired, Property = BaseApiController.ModelRootNodeName });
            }

            // Prevent duplicate records
            if (db.TrainingAward.Where(f => f.Id != model.Id && f.Completed == model.Completed && f.Course.Id == model.Course.Id && f.Member.Id == model.Member.Id).Count() > 0)
            {
                //            ThrowSubmitErrors(new [] { new SubmitError { Error = Strings.API_TrainingRecord_Duplicate, Id = new[] { model.Id }, Property = BaseApiController.ModelRootNodeName }});
            }

            //if (errors.Count == 0)
            //{
            db.SaveChanges();
            Data.TrainingRecordCalculator calculator = new Data.TrainingRecordCalculator(db);
            calculator.Calculate(model.Member.Id);
            db.SaveChanges();
            //}

            view.ReferenceId  = model.Id;
            view.Course.Title = model.Course.DisplayName;
            //}
            //catch (RuleViolationsException ex)
            //{
            //  foreach (RuleViolation v in ex.Errors)
            //  {
            //    errors.Add(new SubmitError { Error = v.ErrorMessage, Property = v.PropertyName, Id = new[] { v.EntityKey } });
            //  }
            //  // throw new InvalidOperationException("TODO: report errors");
            //}

            //if (errors.Count > 0)
            //{
            //  ThrowSubmitErrors(errors);
            //}

            return(view);
        }
Пример #15
0
 public List <RecordUnit> ExtractRecordListUnitFromTrainingRecord(TrainingRecord tr)
 {
     return(tr.scores);
 }