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();
}
