320 lines
9.8 KiB
PHP
320 lines
9.8 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace Phpml\Classification\Linear;
|
|
|
|
use Phpml\Classification\DecisionTree;
|
|
use Phpml\Classification\WeightedClassifier;
|
|
use Phpml\Exception\InvalidArgumentException;
|
|
use Phpml\Helper\OneVsRest;
|
|
use Phpml\Helper\Predictable;
|
|
use Phpml\Math\Comparison;
|
|
|
|
class DecisionStump extends WeightedClassifier
|
|
{
|
|
use Predictable;
|
|
use OneVsRest;
|
|
|
|
public const AUTO_SELECT = -1;
|
|
|
|
/**
|
|
* @var int
|
|
*/
|
|
protected $givenColumnIndex;
|
|
|
|
/**
|
|
* @var array
|
|
*/
|
|
protected $binaryLabels = [];
|
|
|
|
/**
|
|
* Lowest error rate obtained while training/optimizing the model
|
|
*
|
|
* @var float
|
|
*/
|
|
protected $trainingErrorRate;
|
|
|
|
/**
|
|
* @var int
|
|
*/
|
|
protected $column;
|
|
|
|
/**
|
|
* @var mixed
|
|
*/
|
|
protected $value;
|
|
|
|
/**
|
|
* @var string
|
|
*/
|
|
protected $operator;
|
|
|
|
/**
|
|
* @var array
|
|
*/
|
|
protected $columnTypes = [];
|
|
|
|
/**
|
|
* @var int
|
|
*/
|
|
protected $featureCount;
|
|
|
|
/**
|
|
* @var float
|
|
*/
|
|
protected $numSplitCount = 100.0;
|
|
|
|
/**
|
|
* Distribution of samples in the leaves
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $prob = [];
|
|
|
|
/**
|
|
* A DecisionStump classifier is a one-level deep DecisionTree. It is generally
|
|
* used with ensemble algorithms as in the weak classifier role. <br>
|
|
*
|
|
* If columnIndex is given, then the stump tries to produce a decision node
|
|
* on this column, otherwise in cases given the value of -1, the stump itself
|
|
* decides which column to take for the decision (Default DecisionTree behaviour)
|
|
*/
|
|
public function __construct(int $columnIndex = self::AUTO_SELECT)
|
|
{
|
|
$this->givenColumnIndex = $columnIndex;
|
|
}
|
|
|
|
public function __toString(): string
|
|
{
|
|
return "IF {$this->column} {$this->operator} {$this->value} ".
|
|
'THEN '.$this->binaryLabels[0].' '.
|
|
'ELSE '.$this->binaryLabels[1];
|
|
}
|
|
|
|
/**
|
|
* While finding best split point for a numerical valued column,
|
|
* DecisionStump looks for equally distanced values between minimum and maximum
|
|
* values in the column. Given <i>$count</i> value determines how many split
|
|
* points to be probed. The more split counts, the better performance but
|
|
* worse processing time (Default value is 10.0)
|
|
*/
|
|
public function setNumericalSplitCount(float $count): void
|
|
{
|
|
$this->numSplitCount = $count;
|
|
}
|
|
|
|
/**
|
|
* @throws InvalidArgumentException
|
|
*/
|
|
protected function trainBinary(array $samples, array $targets, array $labels): void
|
|
{
|
|
$this->binaryLabels = $labels;
|
|
$this->featureCount = count($samples[0]);
|
|
|
|
// If a column index is given, it should be among the existing columns
|
|
if ($this->givenColumnIndex > count($samples[0]) - 1) {
|
|
$this->givenColumnIndex = self::AUTO_SELECT;
|
|
}
|
|
|
|
// Check the size of the weights given.
|
|
// If none given, then assign 1 as a weight to each sample
|
|
if (count($this->weights) === 0) {
|
|
$this->weights = array_fill(0, count($samples), 1);
|
|
} else {
|
|
$numWeights = count($this->weights);
|
|
if ($numWeights !== count($samples)) {
|
|
throw new InvalidArgumentException('Number of sample weights does not match with number of samples');
|
|
}
|
|
}
|
|
|
|
// Determine type of each column as either "continuous" or "nominal"
|
|
$this->columnTypes = DecisionTree::getColumnTypes($samples);
|
|
|
|
// Try to find the best split in the columns of the dataset
|
|
// by calculating error rate for each split point in each column
|
|
$columns = range(0, count($samples[0]) - 1);
|
|
if ($this->givenColumnIndex !== self::AUTO_SELECT) {
|
|
$columns = [$this->givenColumnIndex];
|
|
}
|
|
|
|
$bestSplit = [
|
|
'value' => 0,
|
|
'operator' => '',
|
|
'prob' => [],
|
|
'column' => 0,
|
|
'trainingErrorRate' => 1.0,
|
|
];
|
|
foreach ($columns as $col) {
|
|
if ($this->columnTypes[$col] == DecisionTree::CONTINUOUS) {
|
|
$split = $this->getBestNumericalSplit($samples, $targets, $col);
|
|
} else {
|
|
$split = $this->getBestNominalSplit($samples, $targets, $col);
|
|
}
|
|
|
|
if ($split['trainingErrorRate'] < $bestSplit['trainingErrorRate']) {
|
|
$bestSplit = $split;
|
|
}
|
|
}
|
|
|
|
// Assign determined best values to the stump
|
|
foreach ($bestSplit as $name => $value) {
|
|
$this->{$name} = $value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determines best split point for the given column
|
|
*/
|
|
protected function getBestNumericalSplit(array $samples, array $targets, int $col): array
|
|
{
|
|
$values = array_column($samples, $col);
|
|
// Trying all possible points may be accomplished in two general ways:
|
|
// 1- Try all values in the $samples array ($values)
|
|
// 2- Artificially split the range of values into several parts and try them
|
|
// We choose the second one because it is faster in larger datasets
|
|
$minValue = min($values);
|
|
$maxValue = max($values);
|
|
$stepSize = ($maxValue - $minValue) / $this->numSplitCount;
|
|
|
|
$split = [];
|
|
|
|
foreach (['<=', '>'] as $operator) {
|
|
// Before trying all possible split points, let's first try
|
|
// the average value for the cut point
|
|
$threshold = array_sum($values) / (float) count($values);
|
|
[$errorRate, $prob] = $this->calculateErrorRate($targets, $threshold, $operator, $values);
|
|
if (!isset($split['trainingErrorRate']) || $errorRate < $split['trainingErrorRate']) {
|
|
$split = [
|
|
'value' => $threshold,
|
|
'operator' => $operator,
|
|
'prob' => $prob,
|
|
'column' => $col,
|
|
'trainingErrorRate' => $errorRate,
|
|
];
|
|
}
|
|
|
|
// Try other possible points one by one
|
|
for ($step = $minValue; $step <= $maxValue; $step += $stepSize) {
|
|
$threshold = (float) $step;
|
|
[$errorRate, $prob] = $this->calculateErrorRate($targets, $threshold, $operator, $values);
|
|
if ($errorRate < $split['trainingErrorRate']) {
|
|
$split = [
|
|
'value' => $threshold,
|
|
'operator' => $operator,
|
|
'prob' => $prob,
|
|
'column' => $col,
|
|
'trainingErrorRate' => $errorRate,
|
|
];
|
|
}
|
|
}// for
|
|
}
|
|
|
|
return $split;
|
|
}
|
|
|
|
protected function getBestNominalSplit(array $samples, array $targets, int $col): array
|
|
{
|
|
$values = array_column($samples, $col);
|
|
$valueCounts = array_count_values($values);
|
|
$distinctVals = array_keys($valueCounts);
|
|
|
|
$split = [];
|
|
|
|
foreach (['=', '!='] as $operator) {
|
|
foreach ($distinctVals as $val) {
|
|
[$errorRate, $prob] = $this->calculateErrorRate($targets, $val, $operator, $values);
|
|
if (!isset($split['trainingErrorRate']) || $split['trainingErrorRate'] < $errorRate) {
|
|
$split = [
|
|
'value' => $val,
|
|
'operator' => $operator,
|
|
'prob' => $prob,
|
|
'column' => $col,
|
|
'trainingErrorRate' => $errorRate,
|
|
];
|
|
}
|
|
}
|
|
}
|
|
|
|
return $split;
|
|
}
|
|
|
|
/**
|
|
* Calculates the ratio of wrong predictions based on the new threshold
|
|
* value given as the parameter
|
|
*/
|
|
protected function calculateErrorRate(array $targets, float $threshold, string $operator, array $values): array
|
|
{
|
|
$wrong = 0.0;
|
|
$prob = [];
|
|
$leftLabel = $this->binaryLabels[0];
|
|
$rightLabel = $this->binaryLabels[1];
|
|
|
|
foreach ($values as $index => $value) {
|
|
if (Comparison::compare($value, $threshold, $operator)) {
|
|
$predicted = $leftLabel;
|
|
} else {
|
|
$predicted = $rightLabel;
|
|
}
|
|
|
|
$target = $targets[$index];
|
|
if ((string) $predicted != (string) $targets[$index]) {
|
|
$wrong += $this->weights[$index];
|
|
}
|
|
|
|
if (!isset($prob[$predicted][$target])) {
|
|
$prob[$predicted][$target] = 0;
|
|
}
|
|
|
|
++$prob[$predicted][$target];
|
|
}
|
|
|
|
// Calculate probabilities: Proportion of labels in each leaf
|
|
$dist = array_combine($this->binaryLabels, array_fill(0, 2, 0.0));
|
|
foreach ($prob as $leaf => $counts) {
|
|
$leafTotal = (float) array_sum($prob[$leaf]);
|
|
foreach ($counts as $label => $count) {
|
|
if ((string) $leaf == (string) $label) {
|
|
$dist[$leaf] = $count / $leafTotal;
|
|
}
|
|
}
|
|
}
|
|
|
|
return [$wrong / (float) array_sum($this->weights), $dist];
|
|
}
|
|
|
|
/**
|
|
* Returns the probability of the sample of belonging to the given label
|
|
*
|
|
* Probability of a sample is calculated as the proportion of the label
|
|
* within the labels of the training samples in the decision node
|
|
*
|
|
* @param mixed $label
|
|
*/
|
|
protected function predictProbability(array $sample, $label): float
|
|
{
|
|
$predicted = $this->predictSampleBinary($sample);
|
|
if ((string) $predicted == (string) $label) {
|
|
return $this->prob[$label];
|
|
}
|
|
|
|
return 0.0;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
protected function predictSampleBinary(array $sample)
|
|
{
|
|
if (Comparison::compare($sample[$this->column], $this->value, $this->operator)) {
|
|
return $this->binaryLabels[0];
|
|
}
|
|
|
|
return $this->binaryLabels[1];
|
|
}
|
|
|
|
protected function resetBinary(): void
|
|
{
|
|
}
|
|
}
|