Phpml\Classification\KNearestNeighbors

Complexity

Total Complexity

8

Size/Duplication

Total Lines	96
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	2
A	serialize()	0	9	1
A	unserialize()	0	8	1
A	predictSample()	0	15	2
A	kNeighborsDistances()	0	12	2

<?php

declare(strict_types=1);

namespace Phpml\Classification;

use Phpml\Helper\Predictable;
use Phpml\Helper\Trainable;
use Phpml\Math\Distance;
use Phpml\Math\Distance\Euclidean;

class KNearestNeighbors implements Classifier, \Serializable
{
    use Trainable, Predictable;

    /**
     * @var int
     */
    private $k;

    /**
     * @var Distance
     */
    private $distanceMetric;

    /**
     * @param int           $k
     * @param Distance|null $distanceMetric (if null then Euclidean distance as default)
     */
    public function __construct(int $k = 3, Distance $distanceMetric = null)
    {
        if (null === $distanceMetric) {
            $distanceMetric = new Euclidean();
        }

        $this->k = $k;
        $this->samples = [];
        $this->targets = [];
        $this->distanceMetric = $distanceMetric;
    }

    /**
     * @return string The serialized object
     */
    public function serialize()
    {
        return serialize([
            'k' => $this->k,
            'distanceMetric' => $this->distanceMetric,
            'samples' => $this->samples,
            'targets' => $this->targets,
        ]);
    }

    /**
     * @param string $data The serialized object
     */
    public function unserialize($data)
    {
        $data = unserialize($data);
        $this->k = $data['k'];
        $this->distanceMetric = $data['distanceMetric'];
        $this->samples = $data['samples'];
        $this->targets = $data['targets'];
    }

    /**
     * @param array $sample
     *
     * @return mixed
     */
    protected function predictSample(array $sample)
    {
        $distances = $this->kNeighborsDistances($sample);

        $predictions = array_combine(array_values($this->targets), array_fill(0, count($this->targets), 0));

        foreach ($distances as $index => $distance) {
            ++$predictions[$this->targets[$index]];
        }

        arsort($predictions);
        reset($predictions);

        return key($predictions);
    }

    /**
     * @param array $sample
     *
     * @return array
     *
     * @throws \Phpml\Exception\InvalidArgumentException
     */
    private function kNeighborsDistances(array $sample)
    {
        $distances = [];

        foreach ($this->samples as $index => $neighbor) {
            $distances[$index] = $this->distanceMetric->distance($sample, $neighbor);
        }

        asort($distances);

        return array_slice($distances, 0, $this->k, true);
    }
}