public double train(TrainingTemplate trainingTemplate, int extMaxGenerations, ErrorHistory errorProg) { //This is simple but the ideea is suposed to be that in larger networks here I do a foreach over the neurons double error = this.trainingMethod.trainNetwork(trainingTemplate, perceptron, extMaxGenerations, errorProg); return(error); }
public async Task <TrainingTemplateDto> ClonePublicTemplateAsync(int publicTemplateId, int userId) { TrainingTemplate trainingTemplate = (await publicTemplateRepository.GetByIdAsync(publicTemplateId))?.Template; return(await templateService.CloneAsync(trainingTemplate, userId)); }
public async Task <ActiveTrainingDto> StartTrainingAsync(int trainingTemplateId, int userId) { TrainingTemplate trainingTemplate = await trainingTemplateRepository.GetByIdAsync(trainingTemplateId); if ( trainingTemplate?.CreatorId != userId || trainingTemplate.Exercises.Count == 0 || trainingTemplate.Creator.ActiveTraining is not null) { return(null); } TrainingHistoryDto trainingHistoryDto = await trainingHistoryService.AddTrainingHistoryAsync(trainingTemplateId, userId); TrainingHistory trainingHistory = await trainingHistoryRepository.GetByIdAsync(trainingHistoryDto.Id); ActiveTraining activeTraining = new ActiveTraining() { UserId = trainingHistory.UserId, TrainingHistoryId = trainingHistory.Id, TrainingTemplateId = trainingTemplate.Id }; activeTraining = await activeTrainingRepository.AddAsync(activeTraining); await activeTrainingRepository.SaveChangesAsync(); return(mapper.Map <ActiveTraining, ActiveTrainingDto>(activeTraining)); }
public async Task <TrainingTemplateDto> CloneAsync(TrainingTemplate template, int userId) { User user = await userService.GetUserEntityByIdAsync(userId); if (template is null || user is null) { return(null); } TrainingTemplate templateClone = template.Clone(); templateClone.CreatorId = userId; TrainingTemplateDto templateDto = await AddTrainingTemplateAsync( mapper.Map <TrainingTemplate, TrainingTemplateModel>(templateClone), userId); if (templateDto is null) { return(null); } templateClone = await traingingTemplateRepository.GetByIdAsync(templateDto.Id); List <Exercise> clonedExercises = template.Exercises.Select(e => e.Clone()).ToList(); templateClone.Exercises = clonedExercises; templateClone = await traingingTemplateRepository.UpdateAsync(templateClone); await traingingTemplateRepository.SaveChangesAsync(); return(mapper.Map <TrainingTemplate, TrainingTemplateDto>(templateClone)); }
public static TrainingTemplate Clone(this TrainingTemplate template) { return(new TrainingTemplate() { Name = template.Name, Description = template.Description, CategoryId = template.CategoryId, CreatorId = template.CreatorId }); }
/// <summary> /// The constructor /// </summary> public NNSim() { this.xor_template = new TrainingTemplate(); xor_template.addTrainingRow(new TrainingRow(new List <double> { 0, 0 }, new List <double> { 0 })); xor_template.addTrainingRow(new TrainingRow(new List <double> { 0, 1 }, new List <double> { 1 })); xor_template.addTrainingRow(new TrainingRow(new List <double> { 1, 0 }, new List <double> { 1 })); xor_template.addTrainingRow(new TrainingRow(new List <double> { 1, 1 }, new List <double> { 0 })); this.input1Neuron = new Neuron("input1", 0, 1); this.input2Neuron = new Neuron("input2", 0, 1); this.hidden1Neuron = new Neuron("hidden1", 0, 1); this.hidden2Neuron = new Neuron("hidden2", 0, 1); this.outputNeuron = new Neuron("output", 0, 1); input1Neuron.fireRule = new SigmoidFireRule(); input2Neuron.fireRule = new SigmoidFireRule(); hidden1Neuron.fireRule = new SigmoidFireRule(); hidden1Neuron.fireRule = new SigmoidFireRule(); outputNeuron.fireRule = new SigmoidFireRule(); input1Neuron.addNewInput("network_in_1", 1, 1); input2Neuron.addNewInput("network_in_2", 1, 1); hidden1Neuron.inputs.Add(input1Neuron.output); hidden1Neuron.inputs.Add(input2Neuron.output); hidden2Neuron.inputs.Add(input1Neuron.output); hidden2Neuron.inputs.Add(input2Neuron.output); outputNeuron.inputs.Add(hidden1Neuron.output); outputNeuron.inputs.Add(hidden2Neuron.output); errors = new double[4]; }
public async Task <TrainingTemplateDto> CloneForCreatorAsync(int templateId, int userId) { TrainingTemplate template = await traingingTemplateRepository.GetByIdAsync(templateId); if (template?.CreatorId != userId) { return(null); } return(await CloneAsync(template, userId)); }
public async Task <TrainingTemplateDto> GetTrainingTemplateByIdAsync(int templateId, int userId) { TrainingTemplate template = await traingingTemplateRepository.GetByIdAsync(templateId); if (template?.CreatorId != userId) { return(null); } return(mapper.Map <TrainingTemplate, TrainingTemplateDto>(template)); }
public async Task <bool> DeleteTrainingTemplateAsync(int templateId, int userId) { TrainingTemplate trainingTemplate = await traingingTemplateRepository.GetByIdAsync(templateId); if (trainingTemplate is null || !trainingTemplate.CreatorId.Equals(userId)) { return(false); } await traingingTemplateRepository.DeleteAsync(trainingTemplate); await traingingTemplateRepository.SaveChangesAsync(); return(true); }
private async Task <ExerciseDto> UpsertExerciseAsync(Exercise exercise, int userId) { if (exercise is null) { return(null); } TrainingTemplate trainingTemplate = await trainingTemplateRepository.GetByIdAsync(exercise.TrainingTemplateId) ?? (await exerciseRepository.GetByIdAsync(exercise.Id)).TrainingTemplate; if (trainingTemplate is null || trainingTemplate.CreatorId != userId) { return(null); } IEnumerable <Exercise> exercises = trainingTemplate.Exercises; exercises = exercises.Where(e => e.Id != exercise.Id).ToList(); ReorderExercises(ref exercises, ref exercise); foreach (Exercise item in exercises) { await exerciseRepository.UpdateAsync(item); } Exercise upsertedExercise; if (exercises.Count() != trainingTemplate.Exercises.Count()) { Exercise exerciseToUpdate = await exerciseRepository.GetByIdAsync(exercise.Id); exerciseToUpdate.Copy(exercise); upsertedExercise = await exerciseRepository.UpdateAsync(exerciseToUpdate); } else { upsertedExercise = await exerciseRepository.AddAsync(exercise); } await exerciseRepository.SaveChangesAsync(); return(mapper.Map <Exercise, ExerciseDto>(upsertedExercise)); }
public async Task <TrainingHistoryDto> AddTrainingHistoryAsync(int trainingTemplateId, int userId) { TrainingTemplate template = await trainingTemplateRepository.GetByIdAsync(trainingTemplateId); if (template?.CreatorId != userId) { return(null); } TrainingHistory trainingHistory = mapper.Map <TrainingTemplate, TrainingHistory>(template); trainingHistory.Start = DateTime.Now.ToUniversalTime(); trainingHistory = await trainingHistoryRepository.AddAsync(trainingHistory); await trainingHistoryRepository.SaveChangesAsync(); return(mapper.Map <TrainingHistory, TrainingHistoryDto>(trainingHistory)); }
public async Task <PublicTrainingTemplateDto> AddPublicTemplateAsync(int templateId, int userId) { TrainingTemplate template = await templateRepository.GetByIdAsync(templateId); if (template is null || template.CreatorId != userId || template.publicTraining is not null) { return(null); } PublicTrainingTemplate publicTemplate = await publicTemplateRepository.AddAsync(new PublicTrainingTemplate() { Template = template }); await publicTemplateRepository.SaveChangesAsync(); return(mapper.Map <PublicTrainingTemplate, PublicTrainingTemplateDto>(publicTemplate)); }
private void button1_Click(object sender, EventArgs e) { neuron = new Neuron("AND-Neuron", 0, 2); neuron.addNewInput("input1", 0, 0); neuron.addNewInput("input2", 0, 0); PerceptronNetwork pn = new PerceptronNetwork(neuron); TrainingTemplate andTemplate = new TrainingTemplate("AND Template"); andTemplate.addTrainingRow(new TrainingRow(new List <double> { 0, 0 }, new List <double> { 0 })); andTemplate.addTrainingRow(new TrainingRow(new List <double> { 0, 1 }, new List <double> { 0 })); andTemplate.addTrainingRow(new TrainingRow(new List <double> { 1, 0 }, new List <double> { 0 })); andTemplate.addTrainingRow(new TrainingRow(new List <double> { 1, 1 }, new List <double> { 1 })); TrainingTemplate orTemplate = new TrainingTemplate("OR Template"); orTemplate.addTrainingRow(new TrainingRow(new List <double> { 0, 0 }, new List <double> { 0 })); orTemplate.addTrainingRow(new TrainingRow(new List <double> { 0, 1 }, new List <double> { 1 })); orTemplate.addTrainingRow(new TrainingRow(new List <double> { 1, 0 }, new List <double> { 1 })); orTemplate.addTrainingRow(new TrainingRow(new List <double> { 1, 1 }, new List <double> { 1 })); TrainingTemplate xorTemplate = new TrainingTemplate("XOR Template"); xorTemplate.addTrainingRow(new TrainingRow(new List <double> { 0, 0 }, new List <double> { 0 })); xorTemplate.addTrainingRow(new TrainingRow(new List <double> { 0, 1 }, new List <double> { 1 })); xorTemplate.addTrainingRow(new TrainingRow(new List <double> { 1, 0 }, new List <double> { 1 })); xorTemplate.addTrainingRow(new TrainingRow(new List <double> { 1, 1 }, new List <double> { 0 })); templatesList = new List <TrainingTemplate>(); ErrorHistory errorProg = new ErrorHistory(); double error = pn.train(xorTemplate, 100, errorProg); labelWeight1.Text = neuron.inputs[0].weight.ToString("N3"); labelWeight2.Text = neuron.inputs[1].weight.ToString("N3"); labelError.Text = error.ToString("N3"); for (int X = 0; X < errorProg.errorPoints.Count; X++) { chart1.Series["Error"].Points.AddXY(X, errorProg.errorPoints[X]); } //chart1.DataBind(errorProg); }
public double train(TrainingTemplate trainingTemplate, int extMaxGenerations, ErrorHistory errorProg) { //Note to self 0.1 is right out of my ass return(trainer.trainNetwork(trainingTemplate, inputLayer, outputLayer, hiddenLayer, extMaxGenerations, 0.1, errorProg)); }
static void Main(string[] args) { //We create the training template TrainingTemplate xor_template = new TrainingTemplate(); xor_template.addTrainingRow(new TrainingRow(new List <double> { 0, 0 }, new List <double> { 0 })); xor_template.addTrainingRow(new TrainingRow(new List <double> { 0, 1 }, new List <double> { 1 })); xor_template.addTrainingRow(new TrainingRow(new List <double> { 1, 0 }, new List <double> { 1 })); xor_template.addTrainingRow(new TrainingRow(new List <double> { 1, 1 }, new List <double> { 0 })); //We create the network SimpleNetwork sn = new SimpleNetwork(); // We create the neurons Neuron input1Neuron = new Neuron("input1", 0, 1); Neuron input2Neuron = new Neuron("input2", 0, 1); Neuron hidden1Neuron = new Neuron("hidden1", 0, 1); Neuron hidden2Neuron = new Neuron("hidden2", 0, 1); Neuron outputNeuron = new Neuron("output", 0, 1); //We asign them Sigmoid fire functions input1Neuron.fireRule = new SigmoidFireRule(); input2Neuron.fireRule = new SigmoidFireRule(); hidden1Neuron.fireRule = new SigmoidFireRule(); hidden1Neuron.fireRule = new SigmoidFireRule(); outputNeuron.fireRule = new SigmoidFireRule(); // We bind them together input1Neuron.addNewInput("network_in_1", 1, 1); input2Neuron.addNewInput("network_in_2", 1, 1); hidden1Neuron.inputs.Add(input1Neuron.output); hidden1Neuron.inputs.Add(input2Neuron.output); hidden2Neuron.inputs.Add(input1Neuron.output); hidden2Neuron.inputs.Add(input2Neuron.output); outputNeuron.inputs.Add(hidden1Neuron.output); // We put them into layers sn.inputLayer.neurons.Add(input1Neuron); sn.inputLayer.neurons.Add(input2Neuron); sn.hiddenLayer.neurons.Add(hidden1Neuron); sn.hiddenLayer.neurons.Add(hidden2Neuron); sn.outputLayer.neurons.Add(outputNeuron); // We train double error = sn.train(xor_template, 5000, new ErrorHistory()); Console.WriteLine(error); Console.ReadKey(); }