AI-ML

 view release on metacpan or  search on metacpan

Build.PL  view on Meta::CPAN

my %fallback_build_requires = (
  "ExtUtils::MakeMaker" => 0,
  "File::Spec" => 0,
  "Module::Build" => "0.28",
  "Test2::V0" => "0.000060",
  "Test::More" => 0
);


unless ( eval { Module::Build->VERSION(0.4004) } ) {
  delete $module_build_args{test_requires};
  $module_build_args{build_requires} = \%fallback_build_requires;
}

my $build = MyBuilder->new(%module_build_args);


$build->create_build_script;

lib/AI/ML/Expr.pm  view on Meta::CPAN

    $m = sigmoid($m);

=cut

sub sigmoid {
    my ($self) = @_;

    return bless { package => __PACKAGE__, type => 'sigmoid', args => [$self] } => __PACKAGE__
}

sub eval_sigmoid {
    my $tree = shift;
    if (blessed($tree) && $tree->isa("Math::Lapack::Matrix")) {
      return _bless _sigmoid($tree->matrix_id);
    }

    die "Sigmoid for non matrix: " . ref($tree);
}

=head2 relu

lib/AI/ML/Expr.pm  view on Meta::CPAN

    $m = $m->relu();
    $m = relu($m);

=cut

sub relu {
    my ($self) = @_;
    return bless { package => __PACKAGE__, type => 'relu', args => [$self] } => __PACKAGE__;
}

sub eval_relu {
    my $tree = shift;
    if (ref($tree) eq "Math::Lapack::Matrix") {
        return _bless _relu($tree->matrix_id);
    }
    die "ReLU for non matrix";
}

=head2 d_relu

Allows apply the function d_relu to every element of the matrix.

lib/AI/ML/Expr.pm  view on Meta::CPAN

    $m = $m->d_relu();
    $m = d_relu($m);

=cut

sub d_relu {
    my ($self) = @_;
    return bless { package => __PACKAGE__, type => 'd_relu', args => [$self] } => __PACKAGE__;
}

sub eval_d_relu {
    my $tree = shift;
    if (ref($tree) eq "Math::Lapack::Matrix") {
        return _bless _d_relu($tree->matrix_id);
    }
    die "ReLU for non matrix";
}

=head2 lrelu

Allows apply the function lrelu to every element of the matrix.

lib/AI/ML/Expr.pm  view on Meta::CPAN

    $th::Lapack::Matrixref(1)m = lrelu($m, 0.0001);
    $m = m->lrelu(0.1);

=cut

sub lrelu {
    my ($self, $v) = @_;
    return bless { package => __PACKAGE__, type => 'lrelu', args => [$self, $v] } => __PACKAGE__;
}

sub eval_lrelu {
    my ($tree, $v) = @_;
    if (ref($tree) eq "Math::Lapack::Matrix") {
        return _bless _lrelu($tree->matrix_id, $v);
    }
    die "lReLU for non matrix";
}

=head2 d_lrelu

Allows apply the function d_lrelu to every element of the matrix.

lib/AI/ML/Expr.pm  view on Meta::CPAN

    $th::Lapack::Matrixref(1)m = lrelu($m, 0.0001);
    $m = m->lrelu(0.1);

=cut

sub d_lrelu {
    my ($self, $v) = @_;
    return bless { package => __PACKAGE__, type => 'd_lrelu', args => [$self, $v] } => __PACKAGE__;
}

sub eval_d_lrelu {
    my ($tree, $v) = @_;
    if (ref($tree) eq "Math::Lapack::Matrix") {
        return _bless _d_lrelu($tree->matrix_id, $v);
    }
    die "lReLU for non matrix";
}


=head2 softmax
Allows apply the function softmax to every element of the matrix.

    $m = softmax($m);
    $m = $m->softmax();
=cut

sub softmax {
    my ($self) = @_;
    return bless { package => __PACKAGE__, type => 'softmax', args => [$self] } => __PACKAGE__; 
}

sub eval_softmax {
    my $tree = shift;
    if (ref($tree) eq "Math::Lapack::Matrix") {
        my $s = $tree->max();
        my $e_x = exp( $tree - $s );
        my $div = sum( $e_x, 1 );
        return $e_x / $div;
        #use Data::Dumper;
        #print STDERR Dumper $matrix;
#        return _bless _softmax($tree->matrix_id);
    }

lib/AI/ML/Expr.pm  view on Meta::CPAN

    $m = d_softmax($m);
    $m = $m->d_softmax();
=cut

sub d_softmax {
    my ($self) = @_;
    return bless { package => __PACKAGE__, type => 'd_softmax', args => [$self] } => __PACKAGE__; 
}

sub eval_d_softmax {
    my $tree = shift;
    if (ref($tree) eq "Math::Lapack::Matrix") {
        return _bless _d_softmax($tree->matrix_id);
    }
    die "d_softmax for non matrix";
}

=head2 tanh
Allows apply the function tanh to every element of the matrix.

    $m = tanh($m);
    $m = $m->tanh();

=cut
sub tanh {
    my ($self) = @_;
    return bless { package => __PACKAGE__, type => 'tanh', args => [$self] } => __PACKAGE__;
}

sub eval_tanh {
    my $tree = shift;
    if( ref($tree) eq "Math::Lapack::Matrix"){
        return _bless _tanh($tree->matrix_id);
    }
    die "tanh for non matrix";
}

=head2 d_tanh
Allows apply the function d_tanh to every element of the matrix.

    $m = d_tanh($m);
    $m = $m->d_tanh();

=cut
sub d_tanh {
    my ($self) = @_;
    return bless { package => __PACKAGE__, type => 'd_tanh', args => [$self] } => __PACKAGE__;
}

sub eval_d_tanh {
    my $tree = shift;
    if( ref($tree) eq "Math::Lapack::Matrix"){
        return _bless _d_tanh($tree->matrix_id);
    }
    die "d_tanh for non matrix";
}

 
=head2 d_sigmoid

lib/AI/ML/Expr.pm  view on Meta::CPAN

    $m = $m->d_sigmoid();
    $m = d_sigmoid($m);

=cut

sub d_sigmoid {
    my ($self) = @_;
    return bless { package => __PACKAGE__, type => 'd_sigmoid', args => [$self] } => __PACKAGE__;
} 

sub eval_d_sigmoid {
    my $tree = shift;
    if( ref($tree) eq "Math::Lapack::Matrix"){
        return _bless _d_sigmoid($tree->matrix_id);
    }
    return "d_sigmoid for non matrix";
}

=head2 sigmoid_cost
Allows get the value of the cost of sigmoid function.

lib/AI/ML/NeuralNetwork.pm  view on Meta::CPAN

		$aux = $var->{"dz$i"};
        #$aux->save_csv("/tmp/DZ$i.csv");

		$var->{"dw$i"} = (1 / $m) * ( $var->{"dz$i"} x T($var->{"A$j"}) );
		$var->{"db$i"} = (1 / $m) * sum( $var->{"dz$i"} , 0 );
		$var->{"da$j"} = T($self->{"l$i"}{w}) x $var->{"dz$i"};

        $self->{"l$i"}{w} = $self->{"l$i"}{w} - ( $alpha * $var->{"dw$i"} );
		$self->{"l$i"}{b} = $self->{"l$i"}{b} - ( $alpha * $var->{"db$i"} );

        $self->{"l$i"}{b}->get_element(0,0); #force eval
        $self->{"l$i"}{w}->get_element(0,0);

        if($iter == 100){
            $aux = $var->{"dw$i"};
            #$aux->save_csv("/tmp/DW$i.csv");
            $aux = $var->{"db$i"};
            #$aux->save_csv("/tmp/DB$i.csv");
            $aux = $var->{"da$j"};
            #$aux->save_csv("/tmp/da$j.m");

t/00-report-prereqs.t  view on Meta::CPAN

            v (?:[0-9]+) (?: (?:\.[0-9]+)+ (?:_[0-9]+)? )?
            |
            (?:[0-9]+)? (?:\.[0-9]+){2,} (?:_[0-9]+)?
        )
    )/x;

# hide optional CPAN::Meta modules from prereq scanner
# and check if they are available
my $cpan_meta = "CPAN::Meta";
my $cpan_meta_pre = "CPAN::Meta::Prereqs";
my $HAS_CPAN_META = eval "require $cpan_meta; $cpan_meta->VERSION('2.120900')" && eval "require $cpan_meta_pre"; ## no critic

# Verify requirements?
my $DO_VERIFY_PREREQS = 1;

sub _max {
    my $max = shift;
    $max = ( $_ > $max ) ? $_ : $max for @_;
    return $max;
}

t/00-report-prereqs.t  view on Meta::CPAN

# Merge all prereqs (either with ::Prereqs or a hashref)
my $full_prereqs = _merge_prereqs(
    ( $HAS_CPAN_META ? $cpan_meta_pre->new : {} ),
    $static_prereqs
);

# Add dynamic prereqs to the included modules list (if we can)
my ($source) = grep { -f } 'MYMETA.json', 'MYMETA.yml';
my $cpan_meta_error;
if ( $source && $HAS_CPAN_META
    && (my $meta = eval { CPAN::Meta->load_file($source) } )
) {
    $full_prereqs = _merge_prereqs($full_prereqs, $meta->prereqs);
}
else {
    $cpan_meta_error = $@;    # capture error from CPAN::Meta->load_file($source)
    $source = 'static metadata';
}

my @full_reports;
my @dep_errors;

xt/author/00-compile.t  view on Meta::CPAN

            $^X, @switches, '-e', "require q[$lib]"))
        if $ENV{PERL_COMPILE_TEST_DEBUG};

    my $pid = open3($stdin, '>&STDERR', $stderr, $^X, @switches, '-e', "require q[$lib]");
    binmode $stderr, ':crlf' if $^O eq 'MSWin32';
    my @_warnings = <$stderr>;
    waitpid($pid, 0);
    is($?, 0, "$lib loaded ok");

    shift @_warnings if @_warnings and $_warnings[0] =~ /^Using .*\bblib/
        and not eval { +require blib; blib->VERSION('1.01') };

    if (@_warnings)
    {
        warn @_warnings;
        push @warnings, @_warnings;
    }
}