Phpml\Classification\NaiveBayes

Complexity

Total Complexity

21

Size/Duplication

Total Lines	147
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	train()	0	15	2
B	calculateStatistics()	0	27	3
B	sampleProbability()	0	20	5
A	getSamplesByLabel()	0	10	3
C	predictSample()	0	34	8

<?php

declare(strict_types=1);

namespace Phpml\Classification;

use Phpml\Helper\Predictable;
use Phpml\Helper\Trainable;
use Phpml\Math\Statistic\Mean;
use Phpml\Math\Statistic\StandardDeviation;

class NaiveBayes implements Classifier
{
    use Trainable, Predictable;
    const CONTINUOS    = 1;
    const NOMINAL    = 2;
    const SMALL_VALUE = 1e-32;
    private $std = array();
    private $mean= array();
    private $discreteProb = array();
    private $dataType = array();
    private $p = array();
    private $sampleCount = 0;
    private $featureCount = 0;
    private $labels = array();
    public function train(array $samples, array $targets)
    {
        $this->samples = $samples;
        $this->targets = $targets;
        $this->sampleCount = count($samples);
        $this->featureCount = count($samples[0]);
        // Get distinct targets
        $this->labels = $targets;
        array_unique($this->labels);
        foreach ($this->labels as $label) {
            $samples = $this->getSamplesByLabel($label);
            $this->p[$label] = count($samples) / $this->sampleCount;
            $this->calculateStatistics($label, $samples);
        }
    }

    /**
     * Calculates vital statistics for each label & feature. Stores these
     * values in private array in order to avoid repeated calculation
     * @param string $label
     * @param array $samples
     */
    private function calculateStatistics($label, $samples)
    {
        $this->std[$label] = array_fill(0, $this->featureCount, 0);
        $this->mean[$label]= array_fill(0, $this->featureCount, 0);
        $this->dataType[$label] = array_fill(0, $this->featureCount, self::CONTINUOS);
        $this->discreteProb[$label] = array_fill(0, $this->featureCount, self::CONTINUOS);
        for ($i=0; $i<$this->featureCount; $i++) {
            // Get the values of nth column in the samples array
            // Mean::arithmetic is called twice, can be optimized
            $values = array_column($samples, $i);
            $numValues = count($values);
            $freq = array_count_values($values);
            // if values are of only a few types or the column contain categorical/string
            // values, then it should be treated as nominal/categorical/discrete column
            if (count($freq) <= $numValues / 2) {
                $this->dataType[$label][$i] = self::NOMINAL;
                $this->discreteProb[$label][$i] = $freq;
                $db = &$this->discreteProb[$label][$i];
                $db = array_map(function ($el) use ($numValues) {
                    return $el / $numValues;
                }, $db);
            } else {
                $this->mean[$label][$i] = Mean::arithmetic($values);
                $this->std[$label][$i] = StandardDeviation::population($values, false);
            }
        }
    }

    /**
     * Calculates the probability P(label|sample_n) assuming
     * the feature is a continuous value
     * @param array $sample
     * @param int $feature
     * @param string $label
     */
    private function sampleProbability($sample, $feature, $label)
    {
        $value = $sample[$feature];
        if ($this->dataType[$label][$feature] == self::NOMINAL) {
            if (! isset($this->discreteProb[$label][$feature][$value]) ||
                $this->discreteProb[$label][$feature][$value] == 0) {
                return self::SMALL_VALUE;
            }
            return $this->discreteProb[$label][$feature][$value];
        }
        $std = $this->std[$label][$feature] ;
        $mean= $this->mean[$label][$feature];
        $std2 = $std * $std;
        if ($std2 == 0) {
            $std2 = self::SMALL_VALUE;
        }
        // Calculate the probability density by use of normal/Gaussian distribution
        // Ref: https://en.wikipedia.org/wiki/Normal_distribution
        return (1 / sqrt(2 * $std2 * pi())) * exp(- pow($value - $mean, 2) / (2 * $std2));
    }

    /**
     * Return samples belonging to specific label
     * @param string $label
     * @return array
     */
    private function getSamplesByLabel($label)
    {
        $samples = array();
        for ($i=0; $i<$this->sampleCount; $i++) {
            if ($this->targets[$i] == $label) {
                $samples[] = $this->samples[$i];
            }
        }
        return $samples;
    }

    /**
     * @param array $sample
     * @return mixed
     */
    protected function predictSample(array $sample)
    {
        $isArray = is_array($sample[0]);
        $samples = $sample;
        if (!$isArray) {
            $samples = array($sample);
        }
        $samplePredictions = array();
        foreach ($samples as $sample) {
            // Use NaiveBayes assumption for each label using:
            //	P(label|features) = P(label) * P(feature0|label) * P(feature1|label) .... P(featureN|label)

36% of this comment could be valid code. Did you maybe forget this after debugging?

            // Then compare probability for each class to determine which is most likely
            $predictions = array();
            foreach ($this->labels as $label) {
                $p = $this->p[$label];
                for ($i=0; $i<$this->featureCount; $i++) {
                    $Plf = $this->sampleProbability($sample, $i, $label);
                    // Correct the value for small and zero values
                    if (is_nan($Plf) || $Plf < self::SMALL_VALUE) {
                        $Plf = self::SMALL_VALUE;
                    }
                    $p *= $Plf;
                }
                $predictions[$label] = $p;
            }
            arsort($predictions, SORT_NUMERIC);
            reset($predictions);
            $samplePredictions[] = key($predictions);
        }
        if (! $isArray) {
            return $samplePredictions[0];
        }
        return $samplePredictions;
    }
}