Phpml\FeatureExtraction\TokenCountVectorizer

Complexity

Total Complexity

19

Size/Duplication

Total Lines	155
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	transform()	0	10	2
A	getVocabulary()	0	4	1
A	transformSample()	0	16	3
A	getTokenIndex()	0	8	2
A	updateFrequency()	0	8	2
A	checkDocumentFrequency()	0	11	3
A	unsetBeyondMinimum()	0	8	2
A	getBeyondMinimumIndexes()	0	11	3

<?php

declare (strict_types = 1);

namespace Phpml\FeatureExtraction;

use Phpml\Tokenization\Tokenizer;

class TokenCountVectorizer implements Vectorizer
{
    /**
     * @var Tokenizer
     */
    private $tokenizer;

    /**
     * @var float
     */
    private $minDF;

    /**
     * @var array
     */
    private $vocabulary;

    /**
     * @var array
     */
    private $frequencies;

    /**
     * @param Tokenizer $tokenizer
     * @param float     $minDF
     */
    public function __construct(Tokenizer $tokenizer, float $minDF = 0)
    {
        $this->tokenizer = $tokenizer;
        $this->minDF = $minDF;

It seems like $minDF can also be of type integer. However, the property $minDF is declared as type double. Maybe add an additional type check?

        $this->vocabulary = [];
        $this->frequencies = [];
    }

    /**
     * @param array $samples
     *
     * @return array
     */
    public function transform(array $samples): array
    {
        foreach ($samples as $index => $sample) {
            $samples[$index] = $this->transformSample($sample);
        }

        $samples = $this->checkDocumentFrequency($samples);

        return $samples;
    }

    /**
     * @return array
     */
    public function getVocabulary()
    {
        return array_flip($this->vocabulary);
    }

    /**
     * @param string $sample
     *
     * @return array
     */
    private function transformSample(string $sample)
    {
        $counts = [];
        $tokens = $this->tokenizer->tokenize($sample);
        foreach ($tokens as $token) {
            $index = $this->getTokenIndex($token);
            $this->updateFrequency($token);
            if (!isset($counts[$index])) {
                $counts[$index] = 0;
            }

            ++$counts[$index];
        }

        return $counts;
    }

    /**
     * @param string $token
     *
     * @return mixed
     */
    private function getTokenIndex(string $token)
    {
        if (!isset($this->vocabulary[$token])) {
            $this->vocabulary[$token] = count($this->vocabulary);
        }

        return $this->vocabulary[$token];
    }

    /**
     * @param string $token
     */
    private function updateFrequency(string $token)
    {
        if (!isset($this->frequencies[$token])) {
            $this->frequencies[$token] = 0;
        }

        ++$this->frequencies[$token];
    }

    /**
     * @param array $samples
     * 
     * @return array
     */
    private function checkDocumentFrequency(array $samples)
    {
        if ($this->minDF > 0) {
            $beyondMinimum = $this->getBeyondMinimumIndexes(count($samples));
            foreach ($samples as $index => $sample) {
                $samples[$index] = $this->unsetBeyondMinimum($sample, $beyondMinimum);
            }
        }

        return $samples;
    }

    /**
     * @param array $sample
     * @param array $beyondMinimum
     *
     * @return array
     */
    private function unsetBeyondMinimum(array $sample, array $beyondMinimum)
    {
        foreach ($beyondMinimum as $index) {
            unset($sample[$index]);
        }

        return $sample;
    }

    /**
     * @param int $samplesCount
     *
     * @return array
     */
    private function getBeyondMinimumIndexes(int $samplesCount)
    {
        $indexes = [];
        foreach ($this->frequencies as $token => $frequency) {
            if (($frequency / $samplesCount) < $this->minDF) {
                $indexes[] = $this->getTokenIndex($token);
            }
        }

        return $indexes;
    }
}