DecisionTreeRegressor::split() - Code Metrics - Inspection of "Implement DecisionTreeRegressor (#375)" - php-ai/php-ml - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — master ( 8544cf...91812f )

by Arkadiusz

created 2019-05-12 18:04 UTC

DecisionTreeRegressor::split() A

↳ Parent: DecisionTreeRegressor

Complexity

Conditions	5
Paths	6

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	31
rs	9.1128
c	0
b	0
f	0
cc	5
nc	6
nop	2

<?php

declare(strict_types=1);

namespace Phpml\Regression;

use Phpml\Exception\InvalidOperationException;
use Phpml\Math\Statistic\Mean;
use Phpml\Math\Statistic\Variance;
use Phpml\Tree\CART;
use Phpml\Tree\Node\AverageNode;
use Phpml\Tree\Node\BinaryNode;
use Phpml\Tree\Node\DecisionNode;

final class DecisionTreeRegressor extends CART implements Regression
{
    /**
     * @var int|null
     */
    protected $maxFeatures;

    /**
     * @var float
     */
    protected $tolerance;

    /**
     * @var array
     */
    protected $columns = [];

    public function train(array $samples, array $targets): void
    {
        $features = count($samples[0]);

        $this->columns = range(0, $features - 1);
        $this->maxFeatures = $this->maxFeatures ?? (int) round(sqrt($features));

        $this->grow($samples, $targets);

        $this->columns = [];
    }

    public function predict(array $samples)
    {
        if ($this->bare()) {
            throw new InvalidOperationException('Regressor must be trained first');
        }

        $predictions = [];

        foreach ($samples as $sample) {
            $node = $this->search($sample);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();

            $predictions[] = $node instanceof AverageNode
                ? $node->outcome()
                : null;
        }

        return $predictions;
    }

    protected function split(array $samples, array $targets): DecisionNode
    {
        $bestVariance = INF;
        $bestColumn = $bestValue = null;
        $bestGroups = [];

        shuffle($this->columns);

        foreach (array_slice($this->columns, 0, $this->maxFeatures) as $column) {
            $values = array_unique(array_column($samples, $column));

            foreach ($values as $value) {
                $groups = $this->partition($column, $value, $samples, $targets);

                $variance = $this->splitImpurity($groups);

                if ($variance < $bestVariance) {
                    $bestColumn = $column;
                    $bestValue = $value;
                    $bestGroups = $groups;
                    $bestVariance = $variance;
                }

                if ($variance <= $this->tolerance) {
                    break 2;
                }
            }
        }

        return new DecisionNode($bestColumn, $bestValue, $bestGroups, $bestVariance);
    }

    protected function terminate(array $targets): BinaryNode
    {
        return new AverageNode(Mean::arithmetic($targets), Variance::population($targets), count($targets));
    }

    protected function splitImpurity(array $groups): float
    {
        $samplesCount = (int) array_sum(array_map(static function (array $group) {
            return count($group[0]);
        }, $groups));

        $impurity = 0.;

        foreach ($groups as $group) {
            $k = count($group[1]);

            if ($k < 2) {
                continue 1;
            }

            $variance = Variance::population($group[1]);

            $impurity += ($k / $samplesCount) * $variance;
        }

        return $impurity;
    }

    /**
     * @param int|float $value
     */
    private function partition(int $column, $value, array $samples, array $targets): array
    {
        $leftSamples = $leftTargets = $rightSamples = $rightTargets = [];
        foreach ($samples as $index => $sample) {
            if ($sample[$column] < $value) {
                $leftSamples[] = $sample;
                $leftTargets[] = $targets[$index];
            } else {
                $rightSamples[] = $sample;
                $rightTargets[] = $targets[$index];
            }
        }

        return [
            [$leftSamples, $leftTargets],
            [$rightSamples, $rightTargets],
        ];
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Phpml\Regression;
6
7			use Phpml\Exception\InvalidOperationException;
8			use Phpml\Math\Statistic\Mean;
9			use Phpml\Math\Statistic\Variance;
10			use Phpml\Tree\CART;
11			use Phpml\Tree\Node\AverageNode;
12			use Phpml\Tree\Node\BinaryNode;
13			use Phpml\Tree\Node\DecisionNode;
14
15			final class DecisionTreeRegressor extends CART implements Regression
16			{
17			/**
18			* @var int\|null
19			*/
20			protected $maxFeatures;
21
22			/**
23			* @var float
24			*/
25			protected $tolerance;
26
27			/**
28			* @var array
29			*/
30			protected $columns = [];
31
32			public function train(array $samples, array $targets): void
33			{
34			$features = count($samples[0]);
35
36			$this->columns = range(0, $features - 1);
37			$this->maxFeatures = $this->maxFeatures ?? (int) round(sqrt($features));
38
39			$this->grow($samples, $targets);
40
41			$this->columns = [];
42			}
43
44			public function predict(array $samples)
45			{
46			if ($this->bare()) {
47			throw new InvalidOperationException('Regressor must be trained first');
48			}
49
50			$predictions = [];
51
52			foreach ($samples as $sample) {
53			$node = $this->search($sample);
			0 ignored issues – show Bug introduced 2019-05-12 18:03 UTC by Report Bug Copy Issue Report Are you sure the assignment to `$node` is correct as `$this->search($sample)` (which targets `Phpml\Tree\CART::search()`) seems to always return null. This check looks for function or method calls that always return null and whose return value is assigned to a variable. class A { function getObject() { return null; } } $a = new A(); $object = $a->getObject(); The method `getObject()` can return nothing but null, so it makes no sense to assign that value to a variable. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
54
55			$predictions[] = $node instanceof AverageNode
56			? $node->outcome()
57			: null;
58			}
59
60			return $predictions;
61			}
62
63			protected function split(array $samples, array $targets): DecisionNode
64			{
65			$bestVariance = INF;
66			$bestColumn = $bestValue = null;
67			$bestGroups = [];
68
69			shuffle($this->columns);
70
71			foreach (array_slice($this->columns, 0, $this->maxFeatures) as $column) {
72			$values = array_unique(array_column($samples, $column));
73
74			foreach ($values as $value) {
75			$groups = $this->partition($column, $value, $samples, $targets);
76
77			$variance = $this->splitImpurity($groups);
78
79			if ($variance < $bestVariance) {
80			$bestColumn = $column;
81			$bestValue = $value;
82			$bestGroups = $groups;
83			$bestVariance = $variance;
84			}
85
86			if ($variance <= $this->tolerance) {
87			break 2;
88			}
89			}
90			}
91
92			return new DecisionNode($bestColumn, $bestValue, $bestGroups, $bestVariance);
93			}
94
95			protected function terminate(array $targets): BinaryNode
96			{
97			return new AverageNode(Mean::arithmetic($targets), Variance::population($targets), count($targets));
98			}
99
100			protected function splitImpurity(array $groups): float
101			{
102			$samplesCount = (int) array_sum(array_map(static function (array $group) {
103			return count($group[0]);
104			}, $groups));
105
106			$impurity = 0.;
107
108			foreach ($groups as $group) {
109			$k = count($group[1]);
110
111			if ($k < 2) {
112			continue 1;
113			}
114
115			$variance = Variance::population($group[1]);
116
117			$impurity += ($k / $samplesCount) * $variance;
118			}
119
120			return $impurity;
121			}
122
123			/**
124			* @param int\|float $value
125			*/
126			private function partition(int $column, $value, array $samples, array $targets): array
127			{
128			$leftSamples = $leftTargets = $rightSamples = $rightTargets = [];
129			foreach ($samples as $index => $sample) {
130			if ($sample[$column] < $value) {
131			$leftSamples[] = $sample;
132			$leftTargets[] = $targets[$index];
133			} else {
134			$rightSamples[] = $sample;
135			$rightTargets[] = $targets[$index];
136			}
137			}
138
139			return [
140			[$leftSamples, $leftTargets],
141			[$rightSamples, $rightTargets],
142			];
143			}
144			}
145

php-ai / php-ml

Push — master ( 8544cf...91812f )

DecisionTreeRegressor::split() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like