Phpml\NeuralNetwork\Network\MultilayerPerceptron

Complexity

Total Complexity

25

Size/Duplication

Total Lines	165
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	19	3
A	train()	0	6	1
A	partialTrain()	0	11	4
A	setLearningRate()	0	5	1
	trainSample()	0	1	?
A	reset()	0	4	1
A	initNetwork()	0	11	1
A	addInputLayer()	0	4	1
A	addNeuronLayers()	0	6	2
A	generateSynapses()	0	9	2
A	addBiasNodes()	0	7	2
A	generateLayerSynapses()	0	8	3
A	generateNeuronSynapses()	0	6	2
A	trainSamples()	0	6	2

<?php

declare(strict_types=1);

namespace Phpml\NeuralNetwork\Network;

use Phpml\Estimator;
use Phpml\Exception\InvalidArgumentException;
use Phpml\Helper\Predictable;
use Phpml\IncrementalEstimator;
use Phpml\NeuralNetwork\ActivationFunction;
use Phpml\NeuralNetwork\Layer;
use Phpml\NeuralNetwork\Node\Bias;
use Phpml\NeuralNetwork\Node\Input;
use Phpml\NeuralNetwork\Node\Neuron;
use Phpml\NeuralNetwork\Node\Neuron\Synapse;
use Phpml\NeuralNetwork\Training\Backpropagation;

abstract class MultilayerPerceptron extends LayeredNetwork implements Estimator, IncrementalEstimator
{
    use Predictable;

    /**
     * @var array
     */
    protected $classes = [];

    /**
     * @var ActivationFunction
     */
    protected $activationFunction;

    /**
     * @var Backpropagation
     */
    protected $backpropagation = null;

    /**
     * @var int
     */
    private $inputLayerFeatures;

    /**
     * @var array
     */
    private $hiddenLayers = [];

    /**
     * @var float
     */
    private $learningRate;

    /**
     * @throws InvalidArgumentException
     */
    public function __construct(int $inputLayerFeatures, array $hiddenLayers, array $classes, int $iterations = 10000, ?ActivationFunction $activationFunction = null, float $learningRate = 1)
    {
        if (empty($hiddenLayers)) {
            throw InvalidArgumentException::invalidLayersNumber();
        }

        if (count($classes) < 2) {
            throw InvalidArgumentException::invalidClassesNumber();
        }

        $this->classes = array_values($classes);
        $this->iterations = $iterations;

The property iterations does not exist. Did you maybe forget to declare it?

        $this->inputLayerFeatures = $inputLayerFeatures;
        $this->hiddenLayers = $hiddenLayers;
        $this->activationFunction = $activationFunction;
        $this->learningRate = $learningRate;

It seems like $learningRate can also be of type integer. However, the property $learningRate is declared as type double. Maybe add an additional type check?

        $this->initNetwork();
    }

    public function train(array $samples, array $targets): void
    {
        $this->reset();
        $this->initNetwork();
        $this->partialTrain($samples, $targets, $this->classes);
    }

    /**
     * @throws InvalidArgumentException
     */
    public function partialTrain(array $samples, array $targets, array $classes = []): void
    {
        if (!empty($classes) && array_values($classes) !== $this->classes) {
            // We require the list of classes in the constructor.
            throw InvalidArgumentException::inconsistentClasses();
        }

        for ($i = 0; $i < $this->iterations; ++$i) {
            $this->trainSamples($samples, $targets);
        }
    }

    public function setLearningRate(float $learningRate)
    {
        $this->learningRate = $learningRate;
        $this->backpropagation->setLearningRate($this->learningRate);
    }

    /**
     * @param mixed $target
     */
    abstract protected function trainSample(array $sample, $target);

    /**
     * @return mixed
     */
    abstract protected function predictSample(array $sample);

    protected function reset(): void
    {
        $this->removeLayers();
    }

    private function initNetwork(): void
    {
        $this->addInputLayer($this->inputLayerFeatures);
        $this->addNeuronLayers($this->hiddenLayers, $this->activationFunction);
        $this->addNeuronLayers([count($this->classes)], $this->activationFunction);

        $this->addBiasNodes();
        $this->generateSynapses();

        $this->backpropagation = new Backpropagation($this->learningRate);
    }

    private function addInputLayer(int $nodes): void
    {
        $this->addLayer(new Layer($nodes, Input::class));
    }

    private function addNeuronLayers(array $layers, ?ActivationFunction $activationFunction = null): void
    {
        foreach ($layers as $neurons) {
            $this->addLayer(new Layer($neurons, Neuron::class, $activationFunction));
        }
    }

    private function generateSynapses(): void
    {
        $layersNumber = count($this->layers) - 1;
        for ($i = 0; $i < $layersNumber; ++$i) {
            $currentLayer = $this->layers[$i];
            $nextLayer = $this->layers[$i + 1];
            $this->generateLayerSynapses($nextLayer, $currentLayer);
        }
    }

    private function addBiasNodes(): void
    {
        $biasLayers = count($this->layers) - 1;
        for ($i = 0; $i < $biasLayers; ++$i) {
            $this->layers[$i]->addNode(new Bias());
        }
    }

    private function generateLayerSynapses(Layer $nextLayer, Layer $currentLayer): void
    {
        foreach ($nextLayer->getNodes() as $nextNeuron) {
            if ($nextNeuron instanceof Neuron) {
                $this->generateNeuronSynapses($currentLayer, $nextNeuron);
            }
        }
    }

    private function generateNeuronSynapses(Layer $currentLayer, Neuron $nextNeuron): void
    {
        foreach ($currentLayer->getNodes() as $currentNeuron) {
            $nextNeuron->addSynapse(new Synapse($currentNeuron));
        }
    }

    private function trainSamples(array $samples, array $targets): void
    {
        foreach ($targets as $key => $target) {
            $this->trainSample($samples[$key], $target);
        }
    }
}