First Commit

vendor/php-ai/php-ml/src/Classification/Linear/Perceptron.php

@@ -0,0 +1,264 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phpml\Classification\Linear;
+
+use Closure;
+use Phpml\Classification\Classifier;
+use Phpml\Exception\InvalidArgumentException;
+use Phpml\Helper\OneVsRest;
+use Phpml\Helper\Optimizer\GD;
+use Phpml\Helper\Optimizer\Optimizer;
+use Phpml\Helper\Optimizer\StochasticGD;
+use Phpml\Helper\Predictable;
+use Phpml\IncrementalEstimator;
+use Phpml\Preprocessing\Normalizer;
+
+class Perceptron implements Classifier, IncrementalEstimator
+{
+    use Predictable;
+    use OneVsRest;
+
+    /**
+     * @var Optimizer|GD|StochasticGD|null
+     */
+    protected $optimizer;
+
+    /**
+     * @var array
+     */
+    protected $labels = [];
+
+    /**
+     * @var int
+     */
+    protected $featureCount = 0;
+
+    /**
+     * @var array
+     */
+    protected $weights = [];
+
+    /**
+     * @var float
+     */
+    protected $learningRate;
+
+    /**
+     * @var int
+     */
+    protected $maxIterations;
+
+    /**
+     * @var Normalizer
+     */
+    protected $normalizer;
+
+    /**
+     * @var bool
+     */
+    protected $enableEarlyStop = true;
+
+    /**
+     * Initalize a perceptron classifier with given learning rate and maximum
+     * number of iterations used while training the perceptron
+     *
+     * @param float $learningRate  Value between 0.0(exclusive) and 1.0(inclusive)
+     * @param int   $maxIterations Must be at least 1
+     *
+     * @throws InvalidArgumentException
+     */
+    public function __construct(float $learningRate = 0.001, int $maxIterations = 1000, bool $normalizeInputs = true)
+    {
+        if ($learningRate <= 0.0 || $learningRate > 1.0) {
+            throw new InvalidArgumentException('Learning rate should be a float value between 0.0(exclusive) and 1.0(inclusive)');
+        }
+
+        if ($maxIterations <= 0) {
+            throw new InvalidArgumentException('Maximum number of iterations must be an integer greater than 0');
+        }
+
+        if ($normalizeInputs) {
+            $this->normalizer = new Normalizer(Normalizer::NORM_STD);
+        }
+
+        $this->learningRate = $learningRate;
+        $this->maxIterations = $maxIterations;
+    }
+
+    public function partialTrain(array $samples, array $targets, array $labels = []): void
+    {
+        $this->trainByLabel($samples, $targets, $labels);
+    }
+
+    public function trainBinary(array $samples, array $targets, array $labels): void
+    {
+        if ($this->normalizer !== null) {
+            $this->normalizer->transform($samples);
+        }
+
+        // Set all target values to either -1 or 1
+        $this->labels = [
+            1 => $labels[0],
+            -1 => $labels[1],
+        ];
+        foreach ($targets as $key => $target) {
+            $targets[$key] = (string) $target == (string) $this->labels[1] ? 1 : -1;
+        }
+
+        // Set samples and feature count vars
+        $this->featureCount = count($samples[0]);
+
+        $this->runTraining($samples, $targets);
+    }
+
+    /**
+     * Normally enabling early stopping for the optimization procedure may
+     * help saving processing time while in some cases it may result in
+     * premature convergence.<br>
+     *
+     * If "false" is given, the optimization procedure will always be executed
+     * for $maxIterations times
+     *
+     * @return $this
+     */
+    public function setEarlyStop(bool $enable = true)
+    {
+        $this->enableEarlyStop = $enable;
+
+        return $this;
+    }
+
+    /**
+     * Returns the cost values obtained during the training.
+     */
+    public function getCostValues(): array
+    {
+        return $this->costValues;
+    }
+
+    protected function resetBinary(): void
+    {
+        $this->labels = [];
+        $this->optimizer = null;
+        $this->featureCount = 0;
+        $this->weights = [];
+        $this->costValues = [];
+    }
+
+    /**
+     * Trains the perceptron model with Stochastic Gradient Descent optimization
+     * to get the correct set of weights
+     */
+    protected function runTraining(array $samples, array $targets): void
+    {
+        // The cost function is the sum of squares
+        $callback = function ($weights, $sample, $target): array {
+            $this->weights = $weights;
+
+            $prediction = $this->outputClass($sample);
+            $gradient = $prediction - $target;
+            $error = $gradient ** 2;
+
+            return [$error, $gradient];
+        };
+
+        $this->runGradientDescent($samples, $targets, $callback);
+    }
+
+    /**
+     * Executes a Gradient Descent algorithm for
+     * the given cost function
+     */
+    protected function runGradientDescent(array $samples, array $targets, Closure $gradientFunc, bool $isBatch = false): void
+    {
+        $class = $isBatch ? GD::class : StochasticGD::class;
+
+        if ($this->optimizer === null) {
+            $this->optimizer = (new $class($this->featureCount))
+                ->setLearningRate($this->learningRate)
+                ->setMaxIterations($this->maxIterations)
+                ->setChangeThreshold(1e-6)
+                ->setEarlyStop($this->enableEarlyStop);
+        }
+
+        $this->weights = $this->optimizer->runOptimization($samples, $targets, $gradientFunc);
+        $this->costValues = $this->optimizer->getCostValues();
+    }
+
+    /**
+     * Checks if the sample should be normalized and if so, returns the
+     * normalized sample
+     */
+    protected function checkNormalizedSample(array $sample): array
+    {
+        if ($this->normalizer !== null) {
+            $samples = [$sample];
+            $this->normalizer->transform($samples);
+            $sample = $samples[0];
+        }
+
+        return $sample;
+    }
+
+    /**
+     * Calculates net output of the network as a float value for the given input
+     *
+     * @return int|float
+     */
+    protected function output(array $sample)
+    {
+        $sum = 0;
+        foreach ($this->weights as $index => $w) {
+            if ($index == 0) {
+                $sum += $w;
+            } else {
+                $sum += $w * $sample[$index - 1];
+            }
+        }
+
+        return $sum;
+    }
+
+    /**
+     * Returns the class value (either -1 or 1) for the given input
+     */
+    protected function outputClass(array $sample): int
+    {
+        return $this->output($sample) > 0 ? 1 : -1;
+    }
+
+    /**
+     * Returns the probability of the sample of belonging to the given label.
+     *
+     * The probability is simply taken as the distance of the sample
+     * to the decision plane.
+     *
+     * @param mixed $label
+     */
+    protected function predictProbability(array $sample, $label): float
+    {
+        $predicted = $this->predictSampleBinary($sample);
+
+        if ((string) $predicted == (string) $label) {
+            $sample = $this->checkNormalizedSample($sample);
+
+            return (float) abs($this->output($sample));
+        }
+
+        return 0.0;
+    }
+
+    /**
+     * @return mixed
+     */
+    protected function predictSampleBinary(array $sample)
+    {
+        $sample = $this->checkNormalizedSample($sample);
+
+        $predictedClass = $this->outputClass($sample);
+
+        return $this->labels[$predictedClass];
+    }
+}