Phpml\DimensionReduction\KernelPCA

Complexity

Total Complexity

25

Size/Duplication

Total Lines	258
Duplicated Lines	10.85 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	2
A	fit()	0	19	2
A	calculateKernelMatrix()	0	17	4
A	centerMatrix()	0	18	1
C	getKernel()	28	57	10
A	getDistancePairs()	0	10	2
A	projectSample()	0	14	1
A	transform()	0	17	3

<?php

declare(strict_types=1);

namespace Phpml\DimensionReduction;

use Phpml\Math\Distance\Euclidean;
use Phpml\Math\Distance\Manhattan;
use Phpml\Math\Matrix;

class KernelPCA extends PCA
{
    const KERNEL_RBF = 1;
    const KERNEL_SIGMOID = 2;
    const KERNEL_LAPLACIAN = 3;

    /**
     * Selected kernel function
     *
     * @var int
     */
    protected $kernel;

    /**
     * Gamma value used by the kernel
     *
     * @var float
     */
    protected $gamma;

    /**
     * Original dataset used to fit KernelPCA
     *
     * @var array
     */
    protected $data;

    /**
     *
     * @param int $kernel
     * @param float $totalVariance
     * @param int $numFeatures
     * @param float $gamma
     *
     * @throws \Exception
     */
    public function __construct(int $kernel = self::KERNEL_RBF, $totalVariance = null, $numFeatures = null, $gamma = null)
    {
        if (! in_array($kernel, [self::KERNEL_RBF, self::KERNEL_SIGMOID, self::KERNEL_LAPLACIAN])) {
            throw new \Exception("KernelPCA can be initialized with the following kernels only: RBF, Sigmoid and Laplacian");
        }

        parent::__construct($totalVariance, $numFeatures);

        $this->kernel = $kernel;
        $this->gamma = $gamma;
    }

    /**
     * Takes a data and returns a lower dimensional version
     * of this data while preserving $totalVariance or $numFeatures. <br>
     * $data is an n-by-m matrix and returned array is
     * n-by-k matrix where k <= m
     *
     * @param array $data
     *
     * @return array
     */
    public function fit(array $data)
    {
        $numRows = count($data);
        $numCols = count($data[0]);

        if ($this->gamma === null) {
            $this->gamma = 1.0 / $numRows;
        }

        $this->data = $this->normalize($data, $numCols);
        $matrix = $this->calculateKernelMatrix($this->data, $numRows);
        $matrix = $this->centerMatrix($matrix, $numRows);

        list($this->eigValues, $this->eigVectors) = $this->eigenDecomposition($matrix, $numRows);

        $this->fit = true;

        return Matrix::transposeArray($this->eigVectors);
    }

    /**
     * Calculates similarity matrix by use of selected kernel function<br>
     * An n-by-m matrix is given and an n-by-n matrix is returned
     *
     * @param array $data
     * @param int $numRows
     *
     * @return array
     */
    protected function calculateKernelMatrix(array $data, int $numRows)
    {
        $kernelFunc = $this->getKernel();

        $matrix = [];
        for ($i=0; $i < $numRows; $i++) {
            for ($k=0; $k < $numRows; $k++) {
                if ($i <= $k) {
                    $matrix[$i][$k] = $kernelFunc($data[$i], $data[$k]);
                } else {
                    $matrix[$i][$k] = $matrix[$k][$i];
                }
            }
        }

        return $matrix;
    }

    /**
     * Kernel matrix is centered in its original space by using the following
     * conversion:
     *
     * K′ = K− N . K −  K.N + N.K.N where N is n-by-n matrix filled with 1/n
     *
     * @param array $matrix
     * @param int $n
     */
    protected function centerMatrix(array $matrix, int $n)
    {
        $N = array_fill(0, $n, array_fill(0, $n, 1.0/$n));
        $N = new Matrix($N, false);
        $K = new Matrix($matrix, false);

        // K.N (This term is repeated so we cache it once)
        $K_N = $K->multiply($N);
        // N.K
        $N_K = $N->multiply($K);
        // N.K.N
        $N_K_N = $N->multiply($K_N);

        return $K->subtract($N_K)
                 ->subtract($K_N)
                 ->add($N_K_N)
                 ->toArray();
    }

    /**
     * Returns the callable kernel function
     *
     * @return \Closure
     */
    protected function getKernel()
    {
        /**
         * Each kernel function operates in two modes:
         * 1) k(x, y) mode: x and y is given
         * 2) k(x) mode: only x is given
         */
        switch ($this->kernel) {
            case self::KERNEL_RBF:

This code seems to be duplicated across your project.

                // k(x,y)=exp(-γ.|x-y|) where |..| is Euclidean distance
                $dist = new Euclidean();
                return function ($x, $y = null) use ($dist) {
                    if ($y === null) {
                        foreach ($x as $i => $element) {
                            $x[$i] = exp(-$this->gamma * $element);
                        }

                        return $x;
                    }

                    return exp(-$this->gamma *    $dist->distance($x, $y));
                };

            case self::KERNEL_SIGMOID:
                // k(x,y)=tanh(γ.xT.y+c0) where c0=0
                return function ($x, $y = null) {
                    if ($y === null) {
                        foreach ($x as $i => $element) {
                            $x[$i] = tanh($this->gamma * $element);
                        }

                        return $x;
                    }

                    $x = new Matrix($x);
                    $y = new Matrix($y);
                    $res = $x->multiply($y->transpose());

                    return tanh($this->gamma * $res->toScalar());
                };

            case self::KERNEL_LAPLACIAN:

This code seems to be duplicated across your project.

                // k(x,y)=exp(-γ.|x-y|) where |..| is Manhattan distance
                $dist = new Manhattan();
                return function ($x, $y = null) use ($dist) {
                    if ($y === null) {
                        foreach ($x as $i => $element) {
                            $x[$i] = exp(-$this->gamma * $element);
                        }

                        return $x;
                    }

                    return exp(-$this->gamma * $dist->distance($x, $y));
                };
        }
    }

    /**
     * @param array $sample
     *
     * @return array
     */
    protected function getDistancePairs(array $sample)
    {
        $kernel = $this->getKernel();
        $pairs = [];
        foreach ($this->data as $row) {
            $pairs[] = $kernel($row, $sample);
        }

        return $pairs;
    }

    /**
     * @param array $pairs
     *
     * @return array
     */
    protected function projectSample(array $pairs)
    {
        // Normalize eigenvectors by eig = eigVectors / eigValues
        $func = function ($eigVal, $eigVect) {
            $m = new Matrix($eigVect, false);
            $a = $m->divideByScalar(sqrt($eigVal))->toArray();

            return $a[0];
        };
        $eig = array_map($func, $this->eigValues, $this->eigVectors);

        // return k.dot(eig)
        return Matrix::dot($pairs, $eig);
    }

    /**
     * Transforms the given sample to a lower dimensional vector by using
     * the variables obtained during the last run of <code>fit</code>.
     *
     * @param array $sample
     *
     * @return array
     */
    public function transform(array $sample)
    {
        if (!$this->fit) {
            throw new \Exception("KernelPCA has not been fitted with respect to original dataset, please run KernelPCA::fit() first");
        }

        if (is_array($sample[0])) {
            throw new \Exception("KernelPCA::transform() accepts only one-dimensional arrays");
        }

        $sample = $this->normalize([$sample], count($sample));
        $sample = $sample[0];

        $pairs = $this->getDistancePairs($sample);

        return $this->projectSample($pairs);
    }
}