Added configuration panel datasets, back-end refactor and others

app/Models/ActivationsFunctions.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace App\Models;
+
+enum ActivationsFunctions: string
+{
+    case STEP = 'step';
+    case SIGMOID = 'sigmoid';
+    case RELU = 'relu';
+}

app/Models/NetworkTraining.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Models;
+
+use App\Events\PerceptronTrainingEnded;
+use App\Services\DataSetReader;
+use App\Services\PerceptronIterationEventBuffer;
+
+abstract class NetworkTraining
+{
+    protected int $iteration = 0;
+
+    /**
+     * @abstract
+     * @var ActivationsFunctions
+     */
+    public ActivationsFunctions $activationFunction;
+
+    public function __construct(
+        protected DataSetReader $datasetReader,
+        protected int $maxIterations,
+        protected PerceptronIterationEventBuffer $iterationEventBuffer,
+        protected string $sessionId,
+        protected string $trainingId,
+    ) {
+    }
+
+    abstract public function start() : void;
+    abstract protected function stopCondition(): bool;
+
+    protected function checkPassedMaxIterations() {
+        if ($this->iteration >= $this->maxIterations) {
+            event(new PerceptronTrainingEnded('Le nombre maximal d\'itérations a été atteint', $this->sessionId, $this->trainingId));
+        }
+    }
+
+    protected function addIterationToBuffer(float $error, array $synapticWeights) {
+        $this->iterationEventBuffer->addIteration($this->iteration, $this->datasetReader->getLastReadLineIndex(), $error, $synapticWeights);
+    }
+}

app/Models/Perceptron.php

@@ -9,7 +9,7 @@ abstract class Perceptron extends Model
     public function __construct(
         private array $synaptic_weights,
     ) {
-        $this->synaptic_weights = $synaptic_weights; // Add bias weight
+        $this->synaptic_weights = $synaptic_weights;
     }
 
     public function test(array $inputs): int
@@ -24,7 +24,7 @@ abstract class Perceptron extends Model
         return $this->activationFunction($weighted_sum);
     }
 
-    abstract protected function activationFunction(float $weighted_sum): int;
+    abstract public function activationFunction(float $weighted_sum): int;
 
     public function getSynapticWeights(): array
     {

app/Models/SimplePerceptron.php

@@ -10,7 +10,7 @@ class SimplePerceptron extends Perceptron {
         parent::__construct($synaptic_weights);
     }
 
-    protected function activationFunction(float $weighted_sum): int
+    public function activationFunction(float $weighted_sum): int
     {
         return $weighted_sum >= 0 ? 1 : 0;
     }

app/Models/SimplePerceptronTraining.php

@@ -0,0 +1,87 @@
+<?php
+
+namespace App\Models;
+
+use App\Events\PerceptronTrainingEnded;
+use App\Services\DataSetReader;
+use App\Services\ISynapticWeightsProvider;
+use App\Services\PerceptronIterationEventBuffer;
+use Illuminate\Support\Facades\Log;
+
+class SimplePerceptronTraining extends NetworkTraining
+{
+    private Perceptron $perceptron;
+    private int $iterationErrorCounter = 0;
+
+    public ActivationsFunctions $activationFunction = ActivationsFunctions::STEP;
+
+    public const MIN_ERROR = 0;
+
+    public function __construct(
+        DataSetReader $datasetReader,
+        protected float $learningRate,
+        int $maxIterations,
+        protected ISynapticWeightsProvider $synapticWeightsProvider,
+        PerceptronIterationEventBuffer $iterationEventBuffer,
+        string $sessionId,
+        string $trainingId,
+    ) {
+        parent::__construct($datasetReader, $maxIterations, $iterationEventBuffer, $sessionId, $trainingId);
+        $this->perceptron = new SimplePerceptron($synapticWeightsProvider->generate(2));
+    }
+
+    public function start(): void
+    {
+        $this->iteration = 0;
+        $error = 0;
+        do {
+            $this->iterationErrorCounter = 0;
+            $this->iteration++;
+
+            while ($nextRow = $this->datasetReader->getRandomLine()) {
+                $inputs = array_slice($nextRow, 0, -1);
+                $correctOutput = end($nextRow);
+                $correctOutput = $correctOutput > 0 ? 1 : 0; // Modify labels for non binary datasets
+
+                $error = $this->iterationFunction($inputs, $correctOutput);
+
+                $error = abs($error); // Use absolute error
+
+                // Broadcast the training iteration event
+                $this->addIterationToBuffer($error, [[$this->perceptron->getSynapticWeights()]]);
+            }
+            $this->datasetReader->reset(); // Reset the dataset for the next iteration
+        } while ($this->iteration < $this->maxIterations && !$this->stopCondition());
+
+        $this->iterationEventBuffer->flush(); // Ensure all iterations are sent to the frontend
+
+        $this->checkPassedMaxIterations();
+    }
+
+    protected function stopCondition(): bool
+    {
+        $condition = $this->iterationErrorCounter == 0;
+        if ($condition === true) {
+            event(new PerceptronTrainingEnded('Le perceptron ne commet plus d\'erreurs sur aucune des données', $this->sessionId, $this->trainingId));
+        }
+        return $this->iterationErrorCounter == 0;
+    }
+
+    private function iterationFunction(array $inputs, int $correctOutput)
+    {
+        $output = $this->perceptron->test($inputs);
+
+        $error = $correctOutput - $output;
+        if (abs($error) > $this::MIN_ERROR) {
+            $this->iterationErrorCounter++;
+        }
+
+        if ($error !== 0) { // Update synaptic weights if needed
+            $synaptic_weights = $this->perceptron->getSynapticWeights();
+            $inputs_with_bias = array_merge([1], $inputs); // Add bias input
+            $new_weights = array_map(fn($weight, $input) => $weight + $this->learningRate * $error * $input, $synaptic_weights, $inputs_with_bias);
+            $this->perceptron->setSynapticWeights($new_weights);
+        }
+        return $error;
+    }
+}