Ninluc/perceptron-viewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Multilayer neuron network
linter / quality (push) Successful in 7m10s
Details
tests / ci (8.4) (push) Successful in 4m43s
Details
tests / ci (8.5) (push) Successful in 4m47s
Details

Browse Source
This commit is contained in:
Matthias Guillitte
2026-09-08 16:29:02 +02:00
parent 2f4db07918
commit 08aa04fe56
17 changed files with 630 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/Events/PerceptronTrainingIteration.php
+10 -1
View File
@@ -38,8 +38,17 @@ class PerceptronTrainingIteration implements ShouldBroadcast
public function broadcastWith(): array
{
$lastIterationIndex = count($this->iterations) - 1;
$iterations = array_map(
fn (array $iteration, int $index): array => $index === $lastIterationIndex
? $iteration
: [...$iteration, 'weights' => []],
$this->iterations,
array_keys($this->iterations),
);
return [
'iterations' => $this->iterations,
'iterations' => $iterations,
'trainingId' => $this->trainingId,
];
}
app/Http/Controllers/PerceptronController.php
+41 -6
View File
@@ -6,6 +6,7 @@ use App\Events\PerceptronInitialization;
use App\Models\NetworksTraining\ADALINEPerceptronTraining;
use App\Models\NetworksTraining\GradientDescentPerceptronTraining;
use App\Models\NetworksTraining\MonoLayerPerceptronTraining;
use App\Models\NetworksTraining\MultiLayerPerceptronTraining;
use App\Models\NetworksTraining\SimpleBinaryPerceptronTraining;
use App\Services\DatasetReader\IDataSetReader;
use App\Services\DatasetReader\LinearOrderDataSetReader;
@@ -13,12 +14,11 @@ use App\Services\DatasetReader\RandomOrderDataSetReader;
use App\Services\IterationEventBuffer\PerceptronIterationEventBuffer;
use App\Services\IterationEventBuffer\PerceptronLimitedEpochEventBuffer;
use App\Services\SynapticWeightsProvider\ISynapticWeightsProvider;
use App\Services\SynapticWeightsProvider\RandomSynapticWeights;
use App\Services\SynapticWeightsProvider\ZeroSynapticWeights;
use Illuminate\Contracts\Queue\Job;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Symfony\Contracts\EventDispatcher\Event;
use Tests\Services\IterationEventBuffer\DullIterationEventBuffer;
use Illuminate\Support\Facades\Validator;
class PerceptronController extends Controller
{
@@ -38,9 +38,16 @@ class PerceptronController extends Controller
$learningRate = 0.015;
$maxIterations = 150;
break;
case 'gradientdescent' || 'adaline':
case 'gradientdescent':
case 'adaline':
$learningRate = 0.00003;
break;
case 'monolayer':
$learningRate = 0.03;
break;
case 'multilayer':
$learningRate = 0.8;
break;
}
return inertia('PerceptronViewer', [
@@ -50,6 +57,7 @@ class PerceptronController extends Controller
'minError' => $minError,
'learningRate' => $learningRate,
'maxIterations' => $maxIterations,
'maxDisplayedWeights' => config('perceptron.max_displayed_weights'),
]);
}
@@ -106,7 +114,8 @@ class PerceptronController extends Controller
case 'simple':
$dataset['defaultLearningRate'] = 0.015;
break;
case 'gradientdescent' || 'adaline':
case 'gradientdescent':
case 'adaline':
$dataset['defaultLearningRate'] = 0.001;
break;
}
@@ -114,6 +123,15 @@ class PerceptronController extends Controller
case 'table_2_11':
$dataset['defaultMinError'] = 0.02;
break;
case 'table_4_12':
switch ($perceptronType) {
case 'multilayer':
$dataset['defaultLearningRate'] = 0.8;
$dataset['defaultMinError'] = 0.001;
$dataset['defaultMaxIterations'] = 2000;
break;
}
break;
}
$datasets[] = $dataset;
}
@@ -133,7 +151,19 @@ class PerceptronController extends Controller
{
$startTime = microtime(true);
// Verifications
$validator = Validator::make($request->all(), config('perceptron.run_inputs_validation'));
if ($validator->fails()) {
return response()->json([
'message' => 'Invalid input parameters',
'errors' => $validator->errors(),
], 400);
}
$perceptronType = $request->input('type');
$hiddenLayers = $request->input('hidden_layers', 2);
$hiddenLayersNeurons = $request->input('hidden_layers_neurons', 3);
$minError = $request->input('min_error', 0.01);
$weightInitMethod = $request->input('weight_init_method', 'random');
$dataSet = $request->input('dataset');
@@ -145,7 +175,11 @@ class PerceptronController extends Controller
// Remove the jobs for the sessionId
DB::table('jobs')->where('payload', 'like', '%s:9:\"sessionId\";s:40:\"'. $sessionId .'\";%')->delete();
if ($weightInitMethod === 'zeros') {
// Zero initialization prevents hidden layers from receiving a gradient.
if ($perceptronType === 'multilayer' && $weightInitMethod === 'zeros') {
$synapticWeightsProvider = new RandomSynapticWeights;
}
else if ($weightInitMethod === 'zeros') {
$synapticWeightsProvider = new ZeroSynapticWeights;
}
@@ -162,6 +196,7 @@ class PerceptronController extends Controller
'gradientdescent' => new GradientDescentPerceptronTraining($datasetReader, $learningRate, $maxEpochs, $synapticWeightsProvider, $iterationEventBuffer, $sessionId, $trainingId, $minError),
'adaline' => new ADALINEPerceptronTraining($datasetReader, $learningRate, $maxEpochs, $synapticWeightsProvider, $iterationEventBuffer, $sessionId, $trainingId, $minError),
'monolayer' => new MonoLayerPerceptronTraining($datasetReader, $learningRate, $maxEpochs, $synapticWeightsProvider, $iterationEventBuffer, $sessionId, $trainingId, $minError),
'multilayer' => new MultiLayerPerceptronTraining($datasetReader, $learningRate, $maxEpochs, $hiddenLayers, $hiddenLayersNeurons, $synapticWeightsProvider, $iterationEventBuffer, $sessionId, $trainingId, $minError),
default => null,
};
app/Models/NetworksTraining/MonoLayerPerceptronTraining.php
+1 -3
View File
@@ -7,8 +7,6 @@ use App\Models\ActivationsFunctions;
use App\Models\Perceptrons\GradientDescentPerceptron;
use App\Models\Perceptrons\NetworkPerceptron;
use App\Models\Perceptrons\Perceptron;
use App\Models\Perceptrons\SimpleBinaryPerceptron2;
use App\Models\Perceptrons\SimpleBinaryPerceptron;
use App\Services\DatasetReader\IDataSetReader;
use App\Services\IterationEventBuffer\IPerceptronIterationEventBuffer;
use App\Services\SynapticWeightsProvider\ISynapticWeightsProvider;
@@ -47,7 +45,7 @@ class MonoLayerPerceptronTraining extends NetworkTraining
),
$datasetReader->getInputSize(),
GradientDescentPerceptron::class, // No hidden layer
SimpleBinaryPerceptron2::class,
GradientDescentPerceptron::class,
);
$this->labels = $datasetReader->getLabels();
}
app/Models/NetworksTraining/MultiLayerPerceptronTraining.php
+259
View File
@@ -0,0 +1,259 @@
<?php
namespace App\Models\NetworksTraining;
use App\Events\PerceptronTrainingEnded;
use App\Models\ActivationsFunctions;
use App\Models\Perceptrons\GradientDescentPerceptron;
use App\Models\Perceptrons\NetworkPerceptron;
use App\Models\Perceptrons\Perceptron;
use App\Models\Perceptrons\SigmoidPerceptron;
use App\Services\DatasetReader\IDataSetReader;
use App\Services\IterationEventBuffer\IPerceptronIterationEventBuffer;
use App\Services\SynapticWeightsProvider\ISynapticWeightsProvider;
use App\Services\SynapticWeightsProvider\SimpleNetworkWeightsProvider;
use Illuminate\Support\Arr;
class MultiLayerPerceptronTraining extends NetworkTraining
{
private Perceptron $network;
private array $labels;
private bool $isRegression;
public ActivationsFunctions $activationFunction = ActivationsFunctions::SIGMOID;
public ?ActivationsFunctions $presentationLayerActivationFunction = ActivationsFunctions::STEP;
private float $epochError;
public function __construct(
IDataSetReader $datasetReader,
protected float $learningRate,
int $maxEpochs,
protected int $hiddenLayers,
protected int $hiddenLayersNeurons,
ISynapticWeightsProvider $synapticWeightsProvider,
IPerceptronIterationEventBuffer $iterationEventBuffer,
string $sessionId,
string $trainingId,
private float $minError,
) {
parent::__construct($datasetReader, $maxEpochs, $iterationEventBuffer, $sessionId, $trainingId);
$this->labels = $datasetReader->getLabels();
$this->isRegression = $datasetReader->getOutputSize() === 1
|| ($datasetReader->getOutputSize() > 2
&& $datasetReader->getOutputSize() * 2 >= $datasetReader->getEpochExamplesCount());
if ($this->isRegression) {
$this->activationFunction = ActivationsFunctions::LINEAR;
}
$networkWeightsProvider = new SimpleNetworkWeightsProvider($synapticWeightsProvider);
$this->network = new NetworkPerceptron(
$networkWeightsProvider->generate(
$datasetReader->getInputSize(),
$this->isRegression ? 1 : $datasetReader->getOutputSize(),
$this->hiddenLayers,
$this->hiddenLayersNeurons,
),
$datasetReader->getInputSize(),
SigmoidPerceptron::class,
GradientDescentPerceptron::class,
);
}
public function start(): void
{
$this->epoch = 0;
do {
$this->epochError = 0;
$this->epoch++;
$inputsForCurrentEpoch = [];
while ($nextRow = $this->datasetReader->getNextLine()) {
$inputsForCurrentEpoch[] = $nextRow;
$inputs = array_slice($nextRow, 0, -1);
$correctOutput = (float) end($nextRow);
$iterationError = $this->iterationFunction($inputs, $correctOutput);
// Synaptic weights correction after each example
$synaptic_weights = $this->network->getSynapticWeights();
$inputs_with_bias = array_merge([1], $inputs); // Add bias input
// Updates the weights
$this->network->setSynapticWeights(
$this->getUpdatedSynapticWeights($synaptic_weights, $iterationError, $inputs_with_bias)
);
// Broadcast the training iteration event
$this->addIterationToBuffer(array_sum($iterationError), $this->network->getSynapticWeights());
// $this->iterationEventBuffer->flush();
}
// Calculte the average error for the epoch with the last synaptic weights
foreach ($inputsForCurrentEpoch as $inputsWithLabel) {
$inputs = array_slice($inputsWithLabel, 0, -1);
$correctOutput = (float) end($inputsWithLabel);
$iterationError = $this->iterationFunction($inputs, $correctOutput);
foreach ($iterationError as $error) {
$this->epochError += ($error ** 2) / 2; // Squared error for the example
}
}
$this->epochError /= $this->datasetReader->getEpochExamplesCount(); // Average error for the epoch
$this->datasetReader->reset(); // Reset the dataset for the next iteration
} while ($this->epoch < $this->maxEpochs && ! $this->stopCondition());
$this->iterationEventBuffer->flush(); // Ensure all iterations are sent to the frontend
$this->checkPassedMaxIterations($this->epochError);
}
protected function stopCondition(): bool
{
$condition = $this->epochError <= $this->minError;
if ($condition === true) {
event(new PerceptronTrainingEnded('Le perceptron à atteint l\'erreur minimale', $this->sessionId, $this->trainingId));
}
return $condition;
}
private function iterationFunction(array $inputs, float $correctOutput): array
{
$outputs = $this->network->test($inputs);
$desiredOutput = $this->getDesiredOutputFromCorrectOutput($correctOutput);
$errors = [];
foreach ($outputs as $index => $output) {
$error = $desiredOutput[$index] - $output;
$errors[] = $error;
}
return $errors;
}
/**
* Backpropagation of error gradients to update synaptic weights.
*
*/
private function getUpdatedSynapticWeights(array $synaptic_weights, array $iterationError, array $inputs): array
{
$layerInputs = [$inputs];
// Reproduce NetworkPerceptron::test() using each neuron's activation function.
foreach ($synaptic_weights as $layerIndex => $layerWeights) {
$previousLayerOutputs = $layerInputs[array_key_last($layerInputs)];
$layerOutputs = [];
foreach ($layerWeights as $neuronIndex => $neuronWeights) {
$weightedSum = array_sum(array_map(
fn ($input, $weight): float => $input * $weight,
$previousLayerOutputs,
$neuronWeights,
));
$neuron = $this->network->network[$layerIndex + 1][$neuronIndex];
$layerOutputs[] = $neuron->activationFunction($weightedSum);
}
$layerInputs[] = array_merge([1], $layerOutputs);
}
$deltas = array_fill(0, count($synaptic_weights), []);
$lastLayerIndex = count($synaptic_weights) - 1;
// Output delta includes the output neuron's activation derivative.
foreach ($iterationError as $neuronIndex => $error) {
$neuron = $this->network->network[$lastLayerIndex + 1][$neuronIndex];
$output = $layerInputs[$lastLayerIndex + 1][$neuronIndex + 1];
$deltas[$lastLayerIndex][$neuronIndex] =
$error * $this->activationDerivative($neuron, $output);
}
// Hidden-layer deltas use the original, unchanged weights.
for ($layerIndex = $lastLayerIndex - 1; $layerIndex >= 0; $layerIndex--) {
foreach ($synaptic_weights[$layerIndex] as $neuronIndex => $unusedNeuronWeights) {
$nextLayerDelta = 0.0;
foreach ($synaptic_weights[$layerIndex + 1] as $nextNeuronIndex => $nextNeuronWeights) {
// Index zero is the next layer's bias weight.
$nextLayerDelta +=
$nextNeuronWeights[$neuronIndex + 1]
* $deltas[$layerIndex + 1][$nextNeuronIndex];
}
$neuron = $this->network->network[$layerIndex + 1][$neuronIndex];
$output = $layerInputs[$layerIndex + 1][$neuronIndex + 1];
$deltas[$layerIndex][$neuronIndex] =
$nextLayerDelta * $this->activationDerivative($neuron, $output);
}
}
$updatedWeights = [];
foreach ($synaptic_weights as $layerIndex => $layerWeights) {
$updatedLayerWeights = [];
foreach ($layerWeights as $neuronIndex => $neuronWeights) {
$updatedLayerWeights[] = array_map(
fn ($weight, $weightIndex): float => $weight
+ $this->learningRate
* $deltas[$layerIndex][$neuronIndex]
* $layerInputs[$layerIndex][$weightIndex],
$neuronWeights,
array_keys($neuronWeights),
);
}
$updatedWeights[] = $updatedLayerWeights;
}
return $updatedWeights;
}
private function activationDerivative(Perceptron $neuron, float $output): float
{
// Numerical derivative works for any activationFunction implementation.
// $epsilon = 1e-6;
// The activation function requires weighted input, which is unavailable here.
// For sigmoid, use its derivative directly.
if ($neuron instanceof SigmoidPerceptron) {
return $output * (1 - $output);
}
// Linear activation, used commonly by gradient-descent output neurons.
return 1.0;
}
private function getDesiredOutputFromCorrectOutput(float $correctOutput): array
{
if ($this->isRegression) {
return [$correctOutput];
}
$desiredOutput = array_fill(0, count($this->labels), 0);
$labelIndex = Arr::first(
array_keys($this->labels),
fn ($key) => $this->labels[$key] == $correctOutput
);
if ($labelIndex !== null) {
$desiredOutput[$labelIndex] = 1;
}
return $desiredOutput;
}
public function getSynapticWeights(): array
{
return [[$this->network->getSynapticWeights()]];
}
}
app/Models/Perceptrons/NetworkPerceptron.php
+1 -1
View File
@@ -25,7 +25,7 @@ class NetworkPerceptron extends Perceptron
}
// Hidden Layer
for ($layerIndex = 0; $layerIndex < count($synaptic_weights) - 2; $layerIndex++) {
for ($layerIndex = 0; $layerIndex < count($synaptic_weights) - 1; $layerIndex++) {
$this->network[$layerIndex + 1] = [];
foreach ($synaptic_weights[$layerIndex] as $neuronWeights) {
app/Models/Perceptrons/SigmoidPerceptron.php
+13
View File
@@ -0,0 +1,13 @@
<?php
namespace App\Models\Perceptrons;
class SigmoidPerceptron extends Perceptron
{
public function activationFunction(float $weighted_sum): float
{
$weighted_sum = max(-40, min(40, $weighted_sum));
return 1 / (1 + exp(-$weighted_sum));
}
}
app/Services/IterationEventBuffer/PerceptronIterationEventBuffer.php
+12 -1
View File
@@ -28,13 +28,24 @@ class PerceptronIterationEventBuffer implements IPerceptronIterationEventBuffer
public function addIteration(int $epoch, int $exampleIndex, float $error, array $synaptic_weights): void
{
$this->data[] = [
$iteration = [
'epoch' => $epoch,
'exampleIndex' => $exampleIndex,
'error' => $error,
'weights' => $synaptic_weights,
];
$payload = [
'iterations' => [...$this->data, $iteration],
'trainingId' => $this->trainingId,
];
if ($this->data !== [] && strlen(json_encode($payload, JSON_THROW_ON_ERROR)) > config('broadcasting.broadcast_max_payload_size')) {
$this->flush();
}
$this->data[] = $iteration;
if ($this->underSizeIncreaseCount <= $this->sizeIncreaseStart) { // We can still send a single date because we are under the increase start threshold
$this->underSizeIncreaseCount++;
$this->flush();
app/Services/SynapticWeightsProvider/SimpleNetworkWeightsProvider.php
+3 -1
View File
@@ -18,9 +18,11 @@ class SimpleNetworkWeightsProvider implements INetworkSynapticWeightsProvider
// Generate Hidden Layer weights
for ($hiddenLayerNeuronIndex = 0; $hiddenLayerNeuronIndex < $hidden_layers_count; $hiddenLayerNeuronIndex++) {
$layer = [];
for ($neuronIndex = 0; $neuronIndex < $hidden_layers_neurons_count; $neuronIndex++) {
$synaptic_weights[] = $this->synapticWeightsProvider->generate($lastLayerSize);
$layer[] = $this->synapticWeightsProvider->generate($lastLayerSize);
}
$synaptic_weights[] = $layer;
$lastLayerSize = $hidden_layers_neurons_count;
}
config/broadcasting.php
+5
View File
@@ -79,4 +79,9 @@ return [
],
/**
* Keep broadcast payloads below Pusher's event size limit.
*/
'broadcast_max_payload_size' => 9000,
];
config/perceptron.php
+13
View File
@@ -14,6 +14,19 @@ return [
*/
'limited_broadcast_number' => 100,
/**
* The maximum number of iterations that can be sent in a single broadcast.
*/
'broadcast_iteration_size' => 75,
/**
* Hide the weight columns in the iteration table above this count.
*/
'max_displayed_weights' => 25,
'run_inputs_validation' => [
'hidden_layers' => 'required|integer|min:1|max:5',
'hidden_layers_neurons' => 'required|integer|min:1|max:5',
'max_iterations' => 'required|integer|min:1|max:5000',
]
];
resources/js/components/IterationTable.vue
+12 -3
View File
@@ -6,6 +6,7 @@ const props = defineProps<{
iterations: Iteration[];
trainingEnded: boolean;
trainingEndReason: string;
maxDisplayedWeights: number;
}>();
// All weight in a simple array
@@ -16,6 +17,12 @@ const allWeightPerIteration: ComputedRef<number[][]> = computed(() => {
});
});
const displayedWeights = computed(() => {
const weights = allWeightPerIteration.value.find((weights) => weights.length > 0) || [];
return weights.length <= props.maxDisplayedWeights ? weights : [];
});
const rowBgDark = computed(() => {
let isEven = false;
return props.iterations.map((iteration, index, arr) => {
@@ -33,7 +40,7 @@ const rowBgDark = computed(() => {
<th>Époch</th>
<th>Exemple</th>
<th
v-for="(weight, index) in allWeightPerIteration[0]"
v-for="(weight, index) in displayedWeights"
v-bind:key="index"
>
X<sub>{{ index }}</sub>
@@ -49,12 +56,14 @@ const rowBgDark = computed(() => {
>
<td>{{ iteration.epoch }}</td>
<td>{{ iteration.exampleIndex }}</td>
<template v-if="displayedWeights.length > 0">
<td
v-for="(weight, index) in allWeightPerIteration[index]"
v-bind:key="index"
v-for="(weight, weightIndex) in allWeightPerIteration[index]"
v-bind:key="weightIndex"
>
{{ weight.toFixed(2) }}
</td>
</template>
<td>{{ iteration.error.toFixed(2) }}</td>
</tr>
resources/js/components/PerceptronDecisionGraph.vue
+153 -22
View File
@@ -10,10 +10,16 @@ import { Chart } from 'vue-chartjs';
import { colors, gridColor, gridColorBold } from '@/types/graphs';
import type { Iteration } from '@/types/perceptron';
type GraphDataset = ChartDataset<
keyof ChartTypeRegistry,
(number | Point | [number, number] | BubbleDataPoint | null)[]
>;
const props = defineProps<{
cleanedDataset: { label: number; data: { x: number; y: number }[] }[];
iterations: Iteration[];
activationFunction: (x: number) => number;
isRegression: boolean;
}>();
const examplesNumber = computed(() => {
@@ -60,8 +66,9 @@ const farTopDataPointY = computed(() => {
function getPerceptronOutput(
weightsNetwork: number[][][],
inputs: number[],
activationFunction: (x: number) => number = props.activationFunction,
): number[] {
for (const layer of weightsNetwork) {
for (const [layerIndex, layer] of weightsNetwork.entries()) {
const nextInputs: number[] = [];
for (const neuron of layer) {
@@ -74,7 +81,8 @@ function getPerceptronOutput(
sum += weights[i] * inputs[i];
}
const activated = props.activationFunction(sum);
const isOutputLayer = layerIndex === weightsNetwork.length - 1;
const activated = isOutputLayer ? sum : activationFunction(sum);
nextInputs.push(activated);
}
@@ -84,17 +92,126 @@ function getPerceptronOutput(
return inputs;
}
function normalizeNetworkWeights(weightsNetwork: number[][][][] | number[][][]): number[][][] {
if (
weightsNetwork.length === 1 &&
weightsNetwork[0].length === 1 &&
Array.isArray(weightsNetwork[0][0]) &&
Array.isArray(weightsNetwork[0][0][0])
) {
return weightsNetwork[0][0] as unknown as number[][][];
}
return weightsNetwork as number[][][];
}
const nonLinearGraph = ref<boolean>(false);
function getPerceptronDecisionBoundaryDataset(
networkWeights: number[][][],
rawNetworkWeights: number[][][] | number[][][][],
activationFunction: (x: number) => number = (x) => x,
): ChartDataset<
keyof ChartTypeRegistry,
number | Point | [number, number] | BubbleDataPoint | null
>[] {
): GraphDataset[] {
const networkWeights = normalizeNetworkWeights(rawNetworkWeights);
const label = 'Ligne de décision du Perceptron';
console.log('Calculating decision boundary with weights:', networkWeights);
if (props.isRegression) {
const hiddenActivation = (value: number) =>
1 / (1 + Math.exp(-value));
const inputCount = networkWeights[0]?.[0]?.length - 1;
if (inputCount === 1) {
if (networkWeights.length > 1) {
nonLinearGraph.value = true;
const data: Point[] = [];
const firstIntegerX = Math.ceil(farLeftDataPointX.value - 1);
const lastIntegerX = Math.floor(farRightDataPointX.value + 1);
for (
let x = firstIntegerX;
x <= lastIntegerX;
x+= 0.1
) {
data.push({
x,
y: getPerceptronOutput(
networkWeights,
[x],
hiddenActivation,
)[0],
});
}
return [
{
type: 'line',
label: 'Prédictions de régression',
data,
borderColor: '#FFF',
backgroundColor: '#FFF',
pointBackgroundColor: '#FFF',
pointRadius: 0,
borderWidth: 2,
tension: 0.4,
order: -1,
},
];
}
nonLinearGraph.value = false;
const data: Point[] = [
{
x: farLeftDataPointX.value - 1,
y: getPerceptronOutput(
networkWeights,
[farLeftDataPointX.value - 1],
hiddenActivation,
)[0],
},
{
x: farRightDataPointX.value + 1,
y: getPerceptronOutput(
networkWeights,
[farRightDataPointX.value + 1],
hiddenActivation,
)[0],
},
];
return [
{
type: 'line',
label: 'Régression du Perceptron',
data,
borderColor: '#FFF',
borderWidth: 2,
pointRadius: 0,
order: -1,
},
];
}
nonLinearGraph.value = true;
const predictionPoints = props.cleanedDataset.flatMap((dataset) =>
dataset.data.map((point) => ({
x: point.x,
y: point.y,
})),
);
return [
{
type: 'scatter',
label: 'Prédictions de régression',
data: predictionPoints,
backgroundColor: '#FFF',
pointBackgroundColor: '#FFF8',
pointRadius: 5,
borderWidth: 0,
order: -1,
},
];
}
if (
networkWeights.length == 1 &&
networkWeights[0].length == 1 &&
@@ -107,7 +224,7 @@ function getPerceptronDecisionBoundaryDataset(
function perceptronLine(x: number): number {
if (perceptronWeights.length < 3) {
// If we have less than 3 weights, we assume missing weights are zero
return getPerceptronOutput(networkWeights, [x])[0];
return getPerceptronOutput(networkWeights, [x], activationFunction)[0];
}
// w0 + w1*x + w2*y = 0 => y = -(w1/w2)*x - w0/w2
@@ -139,15 +256,14 @@ function getPerceptronDecisionBoundaryDataset(
nonLinearGraph.value = true;
const bubbleTransparency = '30';
const isInDataThreshold = 0.0;
// -------- 1️⃣ Construction des datasets --------
// -------- Construction des datasets --------
const datasets: {
type: string;
type: 'scatter';
label: string;
data: Point[];
backgroundColor: string;
pointBackgroundColor: string;
pointRadius: number;
borderWidth: number;
order: number;
@@ -155,11 +271,21 @@ function getPerceptronDecisionBoundaryDataset(
// For the number of neuron in the last layer
const lastLayer = networkWeights[networkWeights.length - 1];
for (let i = 0; i < lastLayer.length; i++) {
const dataset = {
const dataset: {
type: 'scatter';
label: string;
data: Point[];
backgroundColor: string;
pointBackgroundColor: string;
pointRadius: number;
borderWidth: number;
order: number;
} = {
type: 'scatter',
label: label,
data: [], // Will be filled with the decision boundary points
backgroundColor: colors[i] + bubbleTransparency || '#AAA',
backgroundColor: colors[i] || '#AAA',
pointBackgroundColor: (colors[i] || '#AAA') + bubbleTransparency,
pointRadius: 15,
borderWidth: 0,
order: -1,
@@ -167,7 +293,7 @@ function getPerceptronDecisionBoundaryDataset(
datasets.push(dataset);
}
// -------- 2️⃣ Échantillonnage grille --------
// -------- Échantillonnage grille --------
const step =
Math.abs(
farRightDataPointX.value + 1 - (farLeftDataPointX.value - 1),
@@ -183,16 +309,21 @@ function getPerceptronDecisionBoundaryDataset(
y <= farTopDataPointY.value + 1;
y += step
) {
const values = getPerceptronOutput(networkWeights, [x, y]);
values.forEach((v, i) => {
if (v > isInDataThreshold) {
datasets[i].data.push({ x, y });
const values = getPerceptronOutput(
networkWeights,
[x, y],
activationFunction,
);
const dominantValue = Math.max(...values);
const dominantIndex = values.indexOf(dominantValue);
if (dominantIndex >= 0) {
datasets[dominantIndex].data.push({ x, y });
}
});
}
}
// -------- 3️⃣ Dataset ChartJS --------
// -------- Dataset ChartJS --------
return datasets;
}
}
@@ -259,7 +390,7 @@ function getPerceptronDecisionBoundaryDataset(
datasets: [
// Points from the dataset
...props.cleanedDataset.map((dataset, index) => ({
type: 'scatter',
type: 'scatter' as const,
label: `Label ${dataset.label}`,
data: dataset.data,
backgroundColor: colors[index] || '#AAA',
resources/js/components/PerceptronIterationsErrorsGraph.vue
+10 -3
View File
@@ -8,6 +8,7 @@ import Toggle from './ui/toggle/Toggle.vue';
const props = defineProps<{
iterations: Iteration[];
isRegression: boolean;
}>();
const epochErrorOnly = ref<boolean>(false);
@@ -42,7 +43,11 @@ const datasets = computed<
};
datasets.push(dataset);
}
dataset.data.push(iteration.error);
dataset.data.push(
props.isRegression
? Math.abs(iteration.error)
: iteration.error,
);
}
exampleCountPerEpoch[iteration.epoch] = (exampleCountPerEpoch[iteration.epoch] || 0) + 1;
@@ -91,7 +96,9 @@ const datasets = computed<
plugins: {
title: {
display: true,
text: 'Nombre d\'erreurs par epoch',
text: props.isRegression
? 'Erreur de prédiction par epoch'
: 'Nombre d\'erreurs par epoch',
},
},
animation: {
@@ -104,7 +111,7 @@ const datasets = computed<
},
y: {
stacked: true,
beginAtZero: true,
beginAtZero: !props.isRegression,
grid: {
color: function (context) {
if (context.tick.value == 0) {
resources/js/components/PerceptronSetup.vue
+47 -1
View File
@@ -30,6 +30,8 @@ const props = defineProps<{
datasets: Dataset[];
selectedDataset: string;
initializationMethod: InitializationMethod;
hiddenLayers: number;
hiddenLayersNeurons: number;
minError: number;
defaultLearningRate: number;
sessionId: string;
@@ -38,6 +40,8 @@ const props = defineProps<{
const selectedDatasetCopy = ref(props.selectedDataset);
const selectedMethod = ref(props.initializationMethod);
const hiddenLayers = ref(props.hiddenLayers);
const hiddenLayersNeurons = ref(props.hiddenLayersNeurons);
const minError = ref(props.minError);
const learningRate = ref(props.defaultLearningRate);
const maxIterations = ref(props.defaultMaxIterations);
@@ -59,6 +63,9 @@ watch(selectedDatasetCopy, (newvalue) => {
}
// MaxIterations
maxIterations.value = props.defaultMaxIterations;
if (selectedDatasetCopy && selectedDatasetCopy.defaultMaxIterations !== undefined) {
maxIterations.value = selectedDatasetCopy.defaultMaxIterations;
}
})
const trainingId = ref<string>('');
@@ -82,6 +89,8 @@ function startTraining() {
type: props.type,
dataset: selectedDatasetCopy.value,
weight_init_method: selectedMethod.value,
hidden_layers: hiddenLayers.value,
hidden_layers_neurons: hiddenLayersNeurons.value,
min_error: minError.value,
learning_rate: learningRate.value,
session_id: props.sessionId,
@@ -158,7 +167,7 @@ watch(selectedDatasetCopy, (newValue) => {
class="cursor-pointer"
>
<NativeSelectOption
v-for="method in ['zeros', 'random']"
v-for="method in (props.type == 'multilayer' ? ['random'] : ['zeros', 'random'])"
v-bind:key="method"
:value="method"
>
@@ -169,6 +178,42 @@ watch(selectedDatasetCopy, (newValue) => {
</FormItem>
</FormField>
<!-- HIDDEN LAYERS -->
<FormField name="hidden_layers" v-if="props.type === 'multilayer'">
<FormItem>
<FormLabel>Nombre de couches cachées</FormLabel>
<FormControl>
<!-- TODO : MAX input -->
<Input
type="number"
v-model="hiddenLayers"
min="1"
max="5"
step="1"
class="w-min"
/>
</FormControl>
</FormItem>
</FormField>
<!-- HIDDEN LAYERS NEURONS -->
<FormField name="hidden_layers_neurons" v-if="props.type === 'multilayer'">
<FormItem>
<FormLabel>Nombre de neurones par couche cachée</FormLabel>
<FormControl>
<!-- TODO : MAX input -->
<Input
type="number"
v-model="hiddenLayersNeurons"
min="1"
max="5"
step="1"
class="w-min"
/>
</FormControl>
</FormItem>
</FormField>
<!-- MIN ERROR -->
<FormField name="min_error" v-if="props.type !== 'simple'">
<FormItem>
@@ -210,6 +255,7 @@ watch(selectedDatasetCopy, (newValue) => {
type="number"
v-model="maxIterations"
min="0"
max="5000"
step="1"
class="w-min"
/>
resources/js/pages/PerceptronViewer.vue
+10 -2
View File
@@ -47,6 +47,7 @@ const props = defineProps<{
minError: number;
learningRate: number;
maxIterations: number;
maxDisplayedWeights: number;
}>();
const selectedDatasetName = ref<string>('');
@@ -82,7 +83,9 @@ const cleanedDataset = computed<
});
return cleanedDataset;
});
const initializationMethod = ref<InitializationMethod>('zeros');
const hiddenLayers = ref(3);
const hiddenLayersNeurons = ref(3);
const initializationMethod = ref<InitializationMethod>(props.type === 'multilayer' ? 'random' : 'zeros');
console.log('Session ID:', props.sessionId);
@@ -145,7 +148,7 @@ function perceptroninitialization(data: any) {
);
return;
}
activationFunction.value = data.activation_function;
activationFunction.value = data.activationFunction;
}
function getActivationFunction(type: string): (x: number) => number {
switch (type) {
@@ -179,6 +182,8 @@ function resetTraining() {
:datasets="props.datasets"
:selectedDataset="selectedDatasetName"
:initializationMethod="initializationMethod"
:hidden-layers="hiddenLayers"
:hidden-layers-neurons="hiddenLayersNeurons"
:minError="props.minError"
:sessionId="props.sessionId"
:defaultLearningRate="props.learningRate"
@@ -203,6 +208,7 @@ function resetTraining() {
:iterations="iterations"
:trainingEnded="trainingEnded"
:trainingEndReason="trainingEndReason"
:maxDisplayedWeights="props.maxDisplayedWeights"
/>
</div>
<div class="sticky top-0 h-full w-full">
@@ -210,6 +216,7 @@ function resetTraining() {
<PerceptronDecisionGraph
:cleanedDataset="cleanedDataset"
:iterations="iterations"
:is-regression="activationFunction === 'linear'"
:activation-function="
getActivationFunction(activationFunction)
"
@@ -218,6 +225,7 @@ function resetTraining() {
<div>
<PerceptronIterationsErrorsGraph
:iterations="iterations"
:is-regression="activationFunction === 'linear'"
v-if="iterations.length > 0"
/>
</div>
resources/js/types/perceptron.ts
+2 -1
View File
@@ -10,6 +10,7 @@ export type Dataset = {
data: DatasetPoint[];
defaultLearningRate?: number;
defaultMinError?: number;
defaultMaxIterations?: number;
};
export type DatasetPoint = {
@@ -20,4 +21,4 @@ export type DatasetPoint = {
export type InitializationMethod = 'zeros' | 'random';
export type PerceptronType = 'simple';
export type PerceptronType = 'simple' | 'gradientdescent' | 'adaline' | 'monolayer' | 'multilayer';
tests/Unit/Training/MultiLayerPerceptronTest.php
+33
View File
@@ -0,0 +1,33 @@
<?php
namespace Tests\Unit\Training;
use App\Models\NetworksTraining\MultiLayerPerceptronTraining;
use App\Services\DatasetReader\LinearOrderDataSetReader;
use App\Services\SynapticWeightsProvider\ZeroSynapticWeights;
use Tests\Services\IterationEventBuffer\DullIterationEventBuffer;
class MultiLayerPerceptronTest extends TrainingTestCase
{
public function test_multilayer_perceptron_uses_one_output_for_continuous_targets(): void
{
$training = new MultiLayerPerceptronTraining(
datasetReader: new LinearOrderDataSetReader(public_path('data_sets/table_4_17.csv')),
learningRate: 0.01,
maxEpochs: 1,
hiddenLayers: 1,
hiddenLayersNeurons: 3,
synapticWeightsProvider: new ZeroSynapticWeights,
iterationEventBuffer: new DullIterationEventBuffer,
sessionId: 'test-session',
trainingId: 'test-training',
minError: 0,
);
$training->start();
$weights = $training->getSynapticWeights()[0][0];
$this->assertCount(1, $weights[count($weights) - 1]);
}
}