180 lines
4 KiB
PHP
180 lines
4 KiB
PHP
<?php
|
|
|
|
namespace Rubix\ML\Tests\Classifiers;
|
|
|
|
use Rubix\ML\Learner;
|
|
use Rubix\ML\DataType;
|
|
use Rubix\ML\Estimator;
|
|
use Rubix\ML\EstimatorType;
|
|
use Rubix\ML\Classifiers\SVC;
|
|
use Rubix\ML\Kernels\SVM\RBF;
|
|
use Rubix\ML\Datasets\Labeled;
|
|
use Rubix\ML\Datasets\Unlabeled;
|
|
use Rubix\ML\Datasets\Generators\Blob;
|
|
use Rubix\ML\Transformers\ZScaleStandardizer;
|
|
use Rubix\ML\Datasets\Generators\Agglomerate;
|
|
use Rubix\ML\CrossValidation\Metrics\Accuracy;
|
|
use Rubix\ML\Exceptions\InvalidArgumentException;
|
|
use Rubix\ML\Exceptions\RuntimeException;
|
|
use PHPUnit\Framework\TestCase;
|
|
|
|
/**
|
|
* @group Classifiers
|
|
* @requires extension svm
|
|
* @covers \Rubix\ML\Classifiers\SVC
|
|
*/
|
|
class SVCTest extends TestCase
|
|
{
|
|
/**
|
|
* The number of samples in the training set.
|
|
*
|
|
* @var int
|
|
*/
|
|
protected const TRAIN_SIZE = 200;
|
|
|
|
/**
|
|
* The number of samples in the validation set.
|
|
*
|
|
* @var int
|
|
*/
|
|
protected const TEST_SIZE = 20;
|
|
|
|
/**
|
|
* The minimum validation score required to pass the test.
|
|
*
|
|
* @var float
|
|
*/
|
|
protected const MIN_SCORE = 0.9;
|
|
|
|
/**
|
|
* Constant used to see the random number generator.
|
|
*
|
|
* @var int
|
|
*/
|
|
protected const RANDOM_SEED = 0;
|
|
|
|
/**
|
|
* @var \Rubix\ML\Datasets\Generators\Agglomerate
|
|
*/
|
|
protected $generator;
|
|
|
|
/**
|
|
* @var \Rubix\ML\Classifiers\SVC
|
|
*/
|
|
protected $estimator;
|
|
|
|
/**
|
|
* @var \Rubix\ML\CrossValidation\Metrics\Accuracy
|
|
*/
|
|
protected $metric;
|
|
|
|
/**
|
|
* @before
|
|
*/
|
|
protected function setUp() : void
|
|
{
|
|
$this->generator = new Agglomerate([
|
|
'male' => new Blob([69.2, 195.7, 40.0], [1.0, 3.0, 0.3]),
|
|
'female' => new Blob([63.7, 168.5, 38.1], [0.8, 2.5, 0.4]),
|
|
], [0.45, 0.55]);
|
|
|
|
$this->estimator = new SVC(1.0, new RBF(), true, 1e-3);
|
|
|
|
$this->metric = new Accuracy();
|
|
|
|
srand(self::RANDOM_SEED);
|
|
}
|
|
|
|
/**
|
|
* @test
|
|
*/
|
|
public function build() : void
|
|
{
|
|
$this->assertInstanceOf(SVC::class, $this->estimator);
|
|
$this->assertInstanceOf(Learner::class, $this->estimator);
|
|
$this->assertInstanceOf(Estimator::class, $this->estimator);
|
|
}
|
|
|
|
/**
|
|
* @test
|
|
*/
|
|
public function type() : void
|
|
{
|
|
$this->assertEquals(EstimatorType::classifier(), $this->estimator->type());
|
|
}
|
|
|
|
/**
|
|
* @test
|
|
*/
|
|
public function compatibility() : void
|
|
{
|
|
$expected = [
|
|
DataType::continuous(),
|
|
];
|
|
|
|
$this->assertEquals($expected, $this->estimator->compatibility());
|
|
}
|
|
|
|
/**
|
|
* @test
|
|
*/
|
|
public function params() : void
|
|
{
|
|
$expected = [
|
|
'c' => 1.0,
|
|
'kernel' => new RBF(),
|
|
'shrinking' => true,
|
|
'tolerance' => 1e-3,
|
|
'cache_size' => 100.0,
|
|
];
|
|
|
|
$this->assertEquals($expected, $this->estimator->params());
|
|
}
|
|
|
|
/**
|
|
* @test
|
|
*/
|
|
public function trainPredict() : void
|
|
{
|
|
$dataset = $this->generator->generate(self::TRAIN_SIZE + self::TEST_SIZE);
|
|
|
|
$dataset->apply(new ZScaleStandardizer());
|
|
|
|
$testing = $dataset->randomize()->take(self::TEST_SIZE);
|
|
|
|
$this->estimator->train($dataset);
|
|
|
|
$this->assertTrue($this->estimator->trained());
|
|
|
|
$predictions = $this->estimator->predict($testing);
|
|
|
|
$score = $this->metric->score($predictions, $testing->labels());
|
|
|
|
$this->assertGreaterThanOrEqual(self::MIN_SCORE, $score);
|
|
}
|
|
|
|
/**
|
|
* @test
|
|
*/
|
|
public function trainIncompatible() : void
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
|
|
$this->estimator->train(Labeled::quick([['bad']]));
|
|
}
|
|
|
|
/**
|
|
* @test
|
|
*/
|
|
public function predictUntrained() : void
|
|
{
|
|
$this->expectException(RuntimeException::class);
|
|
|
|
$this->estimator->predict(Unlabeled::quick([[1.5]]));
|
|
}
|
|
|
|
protected function assertPreConditions() : void
|
|
{
|
|
$this->assertFalse($this->estimator->trained());
|
|
}
|
|
}
|