Algorithm-LibLinear

 view release on metacpan or  search on metacpan

lib/Algorithm/LibLinear.pm  view on Meta::CPAN

    my $training_parameter = Algorithm::LibLinear::TrainingParameter->new(
        $solvers{$solver},
        $epsilon,
        $cost,
        \@weight_labels,
        \@weights,
        $loss_sensitivity,
        $nu,
        $regularize_bias,
    );
    bless +{
      bias => $bias,
      training_parameter => $training_parameter,
    } => $class;
}

sub bias { $_[0]->{bias} }

sub cost { $_[0]->training_parameter->cost }

sub cross_validation {

lib/Algorithm/LibLinear/DataSet.pm  view on Meta::CPAN

use Smart::Args::TypeTiny;
use Types::Standard qw/ArrayRef ClassName FileHandle InstanceOf Num Str/;

my $InstanceOfPackage = InstanceOf[__PACKAGE__];

sub new {
    args
        my $class => ClassName,
        my $data_set => ArrayRef[FeatureWithLabel];

    bless +{ data_set => $data_set } => $class;
}

sub load {
    args
        my $class => ClassName,
        my $fh => +{ isa => FileHandle, optional => 1, },
        my $filename => +{ isa => Str, optional => 1, },
        my $string => +{ isa => Str, optional => 1, };

    if (none { defined } ($fh, $filename, $string)) {

lib/Algorithm/LibLinear/FeatureScaling.pm  view on Meta::CPAN

        my $min_max_values => +{
            isa => ArrayRef[ArrayRef[Num]],
            optional => 1,
        },
        my $upper_bound => +{ isa => Num, default => 1.0, };

    unless ($data_set or $min_max_values) {
        Carp::croak('Neither "data_set" nor "min_max_values" is specified.');
    }

    my $self = bless +{
        lower_bound => $lower_bound,
        upper_bound => $upper_bound,
    } => $class;

    $self->{min_max_values} = $min_max_values
        // $self->compute_min_max_values(data_set => $data_set);

    return $self;
}

lib/Algorithm/LibLinear/Model.pm  view on Meta::CPAN

use Smart::Args::TypeTiny;
use Types::Standard qw/ClassName InstanceOf Int Str/;

my $InstanceOfPackage = InstanceOf[__PACKAGE__];

sub new {
    args
        my $class => ClassName,
        my $raw_model => InstanceOf['Algorithm::LibLinear::Model::Raw'];

    bless +{ raw_model => $raw_model, } => $class;
}

sub load {
    args
        my $class => ClassName,
        my $filename => Str;

    my $raw_model = Algorithm::LibLinear::Model::Raw->load($filename);
    $class->new(raw_model => $raw_model);
}