2016-08-05 14:12:39 +00:00
|
|
|
<?php
|
|
|
|
|
2016-11-20 21:53:17 +00:00
|
|
|
declare(strict_types=1);
|
2016-08-05 14:12:39 +00:00
|
|
|
|
|
|
|
namespace Phpml\NeuralNetwork\Network;
|
|
|
|
|
2017-05-17 22:07:14 +00:00
|
|
|
use Phpml\Estimator;
|
2016-08-09 11:27:43 +00:00
|
|
|
use Phpml\Exception\InvalidArgumentException;
|
2017-11-06 07:56:37 +00:00
|
|
|
use Phpml\Helper\Predictable;
|
|
|
|
use Phpml\IncrementalEstimator;
|
2016-08-11 11:21:22 +00:00
|
|
|
use Phpml\NeuralNetwork\ActivationFunction;
|
2018-01-09 10:09:59 +00:00
|
|
|
use Phpml\NeuralNetwork\ActivationFunction\Sigmoid;
|
2016-08-09 11:27:43 +00:00
|
|
|
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;
|
2017-11-06 07:56:37 +00:00
|
|
|
use Phpml\NeuralNetwork\Training\Backpropagation;
|
2016-08-09 11:27:43 +00:00
|
|
|
|
2017-05-23 07:03:05 +00:00
|
|
|
abstract class MultilayerPerceptron extends LayeredNetwork implements Estimator, IncrementalEstimator
|
2016-08-05 14:12:39 +00:00
|
|
|
{
|
2017-05-17 22:07:14 +00:00
|
|
|
use Predictable;
|
|
|
|
|
2017-05-23 07:03:05 +00:00
|
|
|
/**
|
2017-11-22 21:16:10 +00:00
|
|
|
* @var array
|
2017-05-23 07:03:05 +00:00
|
|
|
*/
|
2017-11-22 21:16:10 +00:00
|
|
|
protected $classes = [];
|
2017-05-23 07:03:05 +00:00
|
|
|
|
|
|
|
/**
|
2018-01-06 12:09:33 +00:00
|
|
|
* @var ActivationFunction|null
|
2017-05-23 07:03:05 +00:00
|
|
|
*/
|
2017-11-22 21:16:10 +00:00
|
|
|
protected $activationFunction;
|
2017-05-23 07:03:05 +00:00
|
|
|
|
2016-08-09 11:27:43 +00:00
|
|
|
/**
|
2017-11-22 21:16:10 +00:00
|
|
|
* @var Backpropagation
|
2017-05-17 22:07:14 +00:00
|
|
|
*/
|
2018-01-06 12:09:33 +00:00
|
|
|
protected $backpropagation;
|
2017-05-17 22:07:14 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @var int
|
|
|
|
*/
|
2017-11-22 21:16:10 +00:00
|
|
|
private $inputLayerFeatures;
|
2017-05-17 22:07:14 +00:00
|
|
|
|
2017-05-23 07:03:05 +00:00
|
|
|
/**
|
2017-11-22 21:16:10 +00:00
|
|
|
* @var array
|
2017-05-23 07:03:05 +00:00
|
|
|
*/
|
2017-11-22 21:16:10 +00:00
|
|
|
private $hiddenLayers = [];
|
2017-05-23 07:03:05 +00:00
|
|
|
|
|
|
|
/**
|
2017-11-20 22:39:50 +00:00
|
|
|
* @var float
|
2017-05-23 07:03:05 +00:00
|
|
|
*/
|
2017-11-20 22:39:50 +00:00
|
|
|
private $learningRate;
|
2017-05-23 07:03:05 +00:00
|
|
|
|
2018-01-06 12:09:33 +00:00
|
|
|
/**
|
|
|
|
* @var int
|
|
|
|
*/
|
|
|
|
private $iterations;
|
|
|
|
|
2017-05-17 22:07:14 +00:00
|
|
|
/**
|
2016-08-09 11:27:43 +00:00
|
|
|
* @throws InvalidArgumentException
|
|
|
|
*/
|
2019-03-25 13:55:14 +00:00
|
|
|
public function __construct(
|
|
|
|
int $inputLayerFeatures,
|
|
|
|
array $hiddenLayers,
|
|
|
|
array $classes,
|
|
|
|
int $iterations = 10000,
|
|
|
|
?ActivationFunction $activationFunction = null,
|
|
|
|
float $learningRate = 1.
|
|
|
|
) {
|
2018-10-28 06:44:52 +00:00
|
|
|
if (count($hiddenLayers) === 0) {
|
2018-03-03 15:03:53 +00:00
|
|
|
throw new InvalidArgumentException('Provide at least 1 hidden layer');
|
2016-08-09 11:27:43 +00:00
|
|
|
}
|
|
|
|
|
2017-05-23 07:03:05 +00:00
|
|
|
if (count($classes) < 2) {
|
2018-03-03 15:03:53 +00:00
|
|
|
throw new InvalidArgumentException('Provide at least 2 different classes');
|
2017-05-17 22:07:14 +00:00
|
|
|
}
|
|
|
|
|
2018-10-15 17:47:42 +00:00
|
|
|
if (count($classes) !== count(array_unique($classes))) {
|
|
|
|
throw new InvalidArgumentException('Classes must be unique');
|
|
|
|
}
|
|
|
|
|
2017-05-23 07:03:05 +00:00
|
|
|
$this->classes = array_values($classes);
|
2017-05-17 22:07:14 +00:00
|
|
|
$this->iterations = $iterations;
|
2017-05-23 07:03:05 +00:00
|
|
|
$this->inputLayerFeatures = $inputLayerFeatures;
|
|
|
|
$this->hiddenLayers = $hiddenLayers;
|
|
|
|
$this->activationFunction = $activationFunction;
|
2017-11-20 22:39:50 +00:00
|
|
|
$this->learningRate = $learningRate;
|
2017-05-23 07:03:05 +00:00
|
|
|
|
|
|
|
$this->initNetwork();
|
|
|
|
}
|
2017-05-17 22:07:14 +00:00
|
|
|
|
2017-11-14 20:21:23 +00:00
|
|
|
public function train(array $samples, array $targets): void
|
2017-05-17 22:07:14 +00:00
|
|
|
{
|
2017-05-23 07:03:05 +00:00
|
|
|
$this->reset();
|
|
|
|
$this->initNetwork();
|
|
|
|
$this->partialTrain($samples, $targets, $this->classes);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-07-26 06:22:12 +00:00
|
|
|
* @throws InvalidArgumentException
|
2017-05-23 07:03:05 +00:00
|
|
|
*/
|
2017-11-14 20:21:23 +00:00
|
|
|
public function partialTrain(array $samples, array $targets, array $classes = []): void
|
2017-05-23 07:03:05 +00:00
|
|
|
{
|
2018-10-28 06:44:52 +00:00
|
|
|
if (count($classes) > 0 && array_values($classes) !== $this->classes) {
|
2017-05-23 07:03:05 +00:00
|
|
|
// We require the list of classes in the constructor.
|
2018-03-03 15:03:53 +00:00
|
|
|
throw new InvalidArgumentException(
|
|
|
|
'The provided classes don\'t match the classes provided in the constructor'
|
|
|
|
);
|
2017-05-23 07:03:05 +00:00
|
|
|
}
|
|
|
|
|
2017-05-17 22:07:14 +00:00
|
|
|
for ($i = 0; $i < $this->iterations; ++$i) {
|
|
|
|
$this->trainSamples($samples, $targets);
|
|
|
|
}
|
2016-08-09 11:27:43 +00:00
|
|
|
}
|
|
|
|
|
2017-12-05 20:09:06 +00:00
|
|
|
public function setLearningRate(float $learningRate): void
|
|
|
|
{
|
|
|
|
$this->learningRate = $learningRate;
|
|
|
|
$this->backpropagation->setLearningRate($this->learningRate);
|
|
|
|
}
|
|
|
|
|
2018-10-15 17:47:42 +00:00
|
|
|
public function getOutput(): array
|
|
|
|
{
|
|
|
|
$result = [];
|
|
|
|
foreach ($this->getOutputLayer()->getNodes() as $i => $neuron) {
|
|
|
|
$result[$this->classes[$i]] = $neuron->getOutput();
|
|
|
|
}
|
|
|
|
|
|
|
|
return $result;
|
|
|
|
}
|
|
|
|
|
2017-05-17 22:07:14 +00:00
|
|
|
/**
|
|
|
|
* @param mixed $target
|
|
|
|
*/
|
2018-10-28 06:44:52 +00:00
|
|
|
abstract protected function trainSample(array $sample, $target): void;
|
2017-05-17 22:07:14 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @return mixed
|
|
|
|
*/
|
2017-05-23 07:03:05 +00:00
|
|
|
abstract protected function predictSample(array $sample);
|
|
|
|
|
2017-11-14 20:21:23 +00:00
|
|
|
protected function reset(): void
|
2017-05-23 07:03:05 +00:00
|
|
|
{
|
|
|
|
$this->removeLayers();
|
|
|
|
}
|
2017-05-17 22:07:14 +00:00
|
|
|
|
2017-11-22 21:16:10 +00:00
|
|
|
private function initNetwork(): void
|
|
|
|
{
|
|
|
|
$this->addInputLayer($this->inputLayerFeatures);
|
|
|
|
$this->addNeuronLayers($this->hiddenLayers, $this->activationFunction);
|
2018-01-09 10:09:59 +00:00
|
|
|
|
|
|
|
// Sigmoid function for the output layer as we want a value from 0 to 1.
|
|
|
|
$sigmoid = new Sigmoid();
|
|
|
|
$this->addNeuronLayers([count($this->classes)], $sigmoid);
|
2017-11-22 21:16:10 +00:00
|
|
|
|
|
|
|
$this->addBiasNodes();
|
|
|
|
$this->generateSynapses();
|
|
|
|
|
|
|
|
$this->backpropagation = new Backpropagation($this->learningRate);
|
|
|
|
}
|
|
|
|
|
2017-11-14 20:21:23 +00:00
|
|
|
private function addInputLayer(int $nodes): void
|
2016-08-09 11:27:43 +00:00
|
|
|
{
|
|
|
|
$this->addLayer(new Layer($nodes, Input::class));
|
|
|
|
}
|
|
|
|
|
2018-02-01 22:15:36 +00:00
|
|
|
private function addNeuronLayers(array $layers, ?ActivationFunction $defaultActivationFunction = null): void
|
2016-08-09 11:27:43 +00:00
|
|
|
{
|
2018-02-01 22:15:36 +00:00
|
|
|
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));
|
|
|
|
}
|
2016-08-09 11:27:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-14 20:21:23 +00:00
|
|
|
private function generateSynapses(): void
|
2016-08-09 11:27:43 +00:00
|
|
|
{
|
|
|
|
$layersNumber = count($this->layers) - 1;
|
|
|
|
for ($i = 0; $i < $layersNumber; ++$i) {
|
|
|
|
$currentLayer = $this->layers[$i];
|
|
|
|
$nextLayer = $this->layers[$i + 1];
|
|
|
|
$this->generateLayerSynapses($nextLayer, $currentLayer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-14 20:21:23 +00:00
|
|
|
private function addBiasNodes(): void
|
2016-08-09 11:27:43 +00:00
|
|
|
{
|
|
|
|
$biasLayers = count($this->layers) - 1;
|
2016-11-20 21:53:17 +00:00
|
|
|
for ($i = 0; $i < $biasLayers; ++$i) {
|
2016-08-09 11:27:43 +00:00
|
|
|
$this->layers[$i]->addNode(new Bias());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-14 20:21:23 +00:00
|
|
|
private function generateLayerSynapses(Layer $nextLayer, Layer $currentLayer): void
|
2016-08-09 11:27:43 +00:00
|
|
|
{
|
|
|
|
foreach ($nextLayer->getNodes() as $nextNeuron) {
|
|
|
|
if ($nextNeuron instanceof Neuron) {
|
|
|
|
$this->generateNeuronSynapses($currentLayer, $nextNeuron);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-14 20:21:23 +00:00
|
|
|
private function generateNeuronSynapses(Layer $currentLayer, Neuron $nextNeuron): void
|
2016-08-09 11:27:43 +00:00
|
|
|
{
|
|
|
|
foreach ($currentLayer->getNodes() as $currentNeuron) {
|
|
|
|
$nextNeuron->addSynapse(new Synapse($currentNeuron));
|
|
|
|
}
|
|
|
|
}
|
2017-05-17 22:07:14 +00:00
|
|
|
|
2017-11-14 20:21:23 +00:00
|
|
|
private function trainSamples(array $samples, array $targets): void
|
2017-05-17 22:07:14 +00:00
|
|
|
{
|
|
|
|
foreach ($targets as $key => $target) {
|
|
|
|
$this->trainSample($samples[$key], $target);
|
|
|
|
}
|
|
|
|
}
|
2016-08-05 14:12:39 +00:00
|
|
|
}
|