Phpml\Classification\Ensemble\RandomForest

Complexity

Total Complexity

15

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
B	setFeatureSubsetRatio()	0	11	7
B	getRandomSubset()	0	30	5
A	predictSample()	0	17	3

<?php
declare(strict_types=1);

namespace Phpml\Classification\Ensemble;

use Phpml\Classification\Ensemble\Bagging;
use Phpml\Classification\DecisionTree;
use Phpml\Classification\NaiveBayes;

class RandomForest extends Bagging
{
    /**
     * @var array
     */
    protected $classifierColumns;

    /**
     * @var float
     */
    protected $subsetRatio = 1.0;

    /**
     * @var float|string
     */
    protected $featureSubsetRatio = 0.7;

    /**
     * This method is used to determine how much of the original columns (features)
     * will be used to construct subsets to train base classifiers.<br>
     *
     * Allowed values: 'sqrt', 'log' or any float number between 0.1 and 1.0 <br>
     *
     * If there are many features that diminishes classification performance, then
     * small values should be preferred, otherwise, with low number of features,
     * default value (0.7) will result in satisfactory performance.
     *
     * @param mixed $ratio string or float should be given
     * @return $this
     * @throws Exception
     */
    public function setFeatureSubsetRatio($ratio)
    {
        if (is_float($ratio) && ($ratio < 0.1 || $ratio > 1.0)) {
            throw new Exception("When a float given, feature subset ratio should be between 0.1 and 1.0");
        }
        if (is_string($ratio) && $ratio != 'sqrt' && $ratio != 'log') {
            throw new Exception("When a string given, feature subset ratio can only be 'sqrt' or 'log' ");
        }
        $this->featureSubsetRatio = $ratio;
        return $this;
    }

    /**
     * @param int $index
     * @return array
     */
    protected function getRandomSubset($index)
    {
        list($subset, $targets) = parent::getRandomSubset($index);

        if (is_float($this->featureSubsetRatio)) {
            $featureCount = (int)ceil($this->featureSubsetRatio * $this->featureCount);
        } elseif ($this->featureCount == 'sqrt') {
            $featureCount = (int)ceil(sqrt($this->featureCount));
        } else {
            $featureCount = (int)log($this->featureCount + 1, 2);
        }

        if ($featureCount >= $this->featureCount) {
            $featureCount = $this->featureCount;
        }

        $features = range(0, $this->featureCount - 1);
        shuffle($features);
        $features = array_slice($features, 0, $featureCount, false);
        sort($features);
        $this->classifierColumns[$index] = $features;

        $columns = [];
        foreach ($features as $colIndex) {
            $columns[] = array_column($subset, $colIndex);
        }
        $subset= array_map(null, ...$columns);

        return [$subset, $targets];
    }

    /**
     * @param array $sample
     * @return mixed
     */
    protected function predictSample(array $sample)
    {
        $predictions = [];
        for ($i=0; $i<count($this->classifiers); $i++) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

            $samplePiece = [];
            foreach ($this->classifierColumns[$i] as $colIndex) {
                $samplePiece[] = $sample[$colIndex];
            }
            /* @var $classifier Classifier */
            $predictions[] = $this->classifiers[$i]->predict($samplePiece);
        }

        $counts = array_count_values($predictions);
        arsort($counts);
        reset($counts);
        return key($counts);
    }
}