MultilayerPerceptron::getLearningRate() - Code Metrics - Inspection of "Remove phpunit readAttributes deprecated methods (..." - php-ai/php-ml - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — master ( db82af...f6aa1a )

by Arkadiusz

created 2019-04-12 05:49 UTC

MultilayerPerceptron::getLearningRate() A

↳ Parent: MultilayerPerceptron

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?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\ActivationFunction\Sigmoid;
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|null
     */
    protected $activationFunction;

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

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

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

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

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

    /**
     * @throws InvalidArgumentException
     */
    public function __construct(
        int $inputLayerFeatures,
        array $hiddenLayers,
        array $classes,
        int $iterations = 10000,
        ?ActivationFunction $activationFunction = null,
        float $learningRate = 1.
    ) {
        if (count($hiddenLayers) === 0) {
            throw new InvalidArgumentException('Provide at least 1 hidden layer');
        }

        if (count($classes) < 2) {
            throw new InvalidArgumentException('Provide at least 2 different classes');
        }

        if (count($classes) !== count(array_unique($classes))) {
            throw new InvalidArgumentException('Classes must be unique');
        }

        $this->classes = array_values($classes);
        $this->iterations = $iterations;
        $this->inputLayerFeatures = $inputLayerFeatures;
        $this->hiddenLayers = $hiddenLayers;
        $this->activationFunction = $activationFunction;
        $this->learningRate = $learningRate;

        $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 (count($classes) > 0 && array_values($classes) !== $this->classes) {
            // We require the list of classes in the constructor.
            throw new InvalidArgumentException(
                'The provided classes don\'t match the classes provided in the constructor'
            );
        }

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

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

    public function getOutput(): array
    {
        $result = [];
        foreach ($this->getOutputLayer()->getNodes() as $i => $neuron) {
            $result[$this->classes[$i]] = $neuron->getOutput();
        }

        return $result;
    }

    public function getLearningRate(): float
    {
        return $this->learningRate;
    }

    public function getBackpropagation(): Backpropagation
    {
        return $this->backpropagation;
    }

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

    /**
     * @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);

        // Sigmoid function for the output layer as we want a value from 0 to 1.
        $sigmoid = new Sigmoid();
        $this->addNeuronLayers([count($this->classes)], $sigmoid);

        $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 $defaultActivationFunction = null): void
    {
        foreach ($layers as $layer) {
            if (is_array($layer)) {
                $function = $layer[1] instanceof ActivationFunction ? $layer[1] : $defaultActivationFunction;
                $this->addLayer(new Layer($layer[0], Neuron::class, $function));
            } elseif ($layer instanceof Layer) {
                $this->addLayer($layer);
            } else {
                $this->addLayer(new Layer($layer, Neuron::class, $defaultActivationFunction));
            }
        }
    }

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


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Phpml\NeuralNetwork\Network;
6
7			use Phpml\Estimator;
8			use Phpml\Exception\InvalidArgumentException;
9			use Phpml\Helper\Predictable;
10			use Phpml\IncrementalEstimator;
11			use Phpml\NeuralNetwork\ActivationFunction;
12			use Phpml\NeuralNetwork\ActivationFunction\Sigmoid;
13			use Phpml\NeuralNetwork\Layer;
14			use Phpml\NeuralNetwork\Node\Bias;
15			use Phpml\NeuralNetwork\Node\Input;
16			use Phpml\NeuralNetwork\Node\Neuron;
17			use Phpml\NeuralNetwork\Node\Neuron\Synapse;
18			use Phpml\NeuralNetwork\Training\Backpropagation;
19
20			abstract class MultilayerPerceptron extends LayeredNetwork implements Estimator, IncrementalEstimator
21			{
22			use Predictable;
23
24			/**
25			* @var array
26			*/
27			protected $classes = [];
28
29			/**
30			* @var ActivationFunction\|null
31			*/
32			protected $activationFunction;
33
34			/**
35			* @var Backpropagation
36			*/
37			protected $backpropagation;
38
39			/**
40			* @var int
41			*/
42			private $inputLayerFeatures;
43
44			/**
45			* @var array
46			*/
47			private $hiddenLayers = [];
48
49			/**
50			* @var float
51			*/
52			private $learningRate;
53
54			/**
55			* @var int
56			*/
57			private $iterations;
58
59			/**
60			* @throws InvalidArgumentException
61			*/
62			public function __construct(
63			int $inputLayerFeatures,
64			array $hiddenLayers,
65			array $classes,
66			int $iterations = 10000,
67			?ActivationFunction $activationFunction = null,
68			float $learningRate = 1.
69			) {
70			if (count($hiddenLayers) === 0) {
71			throw new InvalidArgumentException('Provide at least 1 hidden layer');
72			}
73
74			if (count($classes) < 2) {
75			throw new InvalidArgumentException('Provide at least 2 different classes');
76			}
77
78			if (count($classes) !== count(array_unique($classes))) {
79			throw new InvalidArgumentException('Classes must be unique');
80			}
81
82			$this->classes = array_values($classes);
83			$this->iterations = $iterations;
84			$this->inputLayerFeatures = $inputLayerFeatures;
85			$this->hiddenLayers = $hiddenLayers;
86			$this->activationFunction = $activationFunction;
87			$this->learningRate = $learningRate;
88
89			$this->initNetwork();
90			}
91
92			public function train(array $samples, array $targets): void
93			{
94			$this->reset();
95			$this->initNetwork();
96			$this->partialTrain($samples, $targets, $this->classes);
97			}
98
99			/**
100			* @throws InvalidArgumentException
101			*/
102			public function partialTrain(array $samples, array $targets, array $classes = []): void
103			{
104			if (count($classes) > 0 && array_values($classes) !== $this->classes) {
105			// We require the list of classes in the constructor.
106			throw new InvalidArgumentException(
107			'The provided classes don\'t match the classes provided in the constructor'
108			);
109			}
110
111			for ($i = 0; $i < $this->iterations; ++$i) {
112			$this->trainSamples($samples, $targets);
113			}
114			}
115
116			public function setLearningRate(float $learningRate): void
117			{
118			$this->learningRate = $learningRate;
119			$this->backpropagation->setLearningRate($this->learningRate);
120			}
121
122			public function getOutput(): array
123			{
124			$result = [];
125			foreach ($this->getOutputLayer()->getNodes() as $i => $neuron) {
126			$result[$this->classes[$i]] = $neuron->getOutput();
127			}
128
129			return $result;
130			}
131
132			public function getLearningRate(): float
133			{
134			return $this->learningRate;
135			}
136
137			public function getBackpropagation(): Backpropagation
138			{
139			return $this->backpropagation;
140			}
141
142			/**
143			* @param mixed $target
144			*/
145			abstract protected function trainSample(array $sample, $target): void;
146
147			/**
148			* @return mixed
149			*/
150			abstract protected function predictSample(array $sample);
151
152			protected function reset(): void
153			{
154			$this->removeLayers();
155			}
156
157			private function initNetwork(): void
158			{
159			$this->addInputLayer($this->inputLayerFeatures);
160			$this->addNeuronLayers($this->hiddenLayers, $this->activationFunction);
161
162			// Sigmoid function for the output layer as we want a value from 0 to 1.
163			$sigmoid = new Sigmoid();
164			$this->addNeuronLayers([count($this->classes)], $sigmoid);
165
166			$this->addBiasNodes();
167			$this->generateSynapses();
168
169			$this->backpropagation = new Backpropagation($this->learningRate);
170			}
171
172			private function addInputLayer(int $nodes): void
173			{
174			$this->addLayer(new Layer($nodes, Input::class));
175			}
176
177			private function addNeuronLayers(array $layers, ?ActivationFunction $defaultActivationFunction = null): void
178			{
179			foreach ($layers as $layer) {
180			if (is_array($layer)) {
181			$function = $layer[1] instanceof ActivationFunction ? $layer[1] : $defaultActivationFunction;
182			$this->addLayer(new Layer($layer[0], Neuron::class, $function));
183			} elseif ($layer instanceof Layer) {
184			$this->addLayer($layer);
185			} else {
186			$this->addLayer(new Layer($layer, Neuron::class, $defaultActivationFunction));
187			}
188			}
189			}
190
191			private function generateSynapses(): void
192			{
193			$layersNumber = count($this->layers) - 1;
194			for ($i = 0; $i < $layersNumber; ++$i) {
195			$currentLayer = $this->layers[$i];
196			$nextLayer = $this->layers[$i + 1];
197			$this->generateLayerSynapses($nextLayer, $currentLayer);
198			}
199			}
200
201			private function addBiasNodes(): void
202			{
203			$biasLayers = count($this->layers) - 1;
204			for ($i = 0; $i < $biasLayers; ++$i) {
205			$this->layers[$i]->addNode(new Bias());
206			}
207			}
208
209			private function generateLayerSynapses(Layer $nextLayer, Layer $currentLayer): void
210			{
211			foreach ($nextLayer->getNodes() as $nextNeuron) {
212			if ($nextNeuron instanceof Neuron) {
213			$this->generateNeuronSynapses($currentLayer, $nextNeuron);
214			}
215			}
216			}
217
218			private function generateNeuronSynapses(Layer $currentLayer, Neuron $nextNeuron): void
219			{
220			foreach ($currentLayer->getNodes() as $currentNeuron) {
221			$nextNeuron->addSynapse(new Synapse($currentNeuron));
222			}
223			}
224
225			private function trainSamples(array $samples, array $targets): void
226			{
227			foreach ($targets as $key => $target) {
228			$this->trainSample($samples[$key], $target);
229			}
230			}
231			}
232

php-ai / php-ml

Push — master ( db82af...f6aa1a )

MultilayerPerceptron::getLearningRate() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like