lib/Peta/NN/Inference.pm

filter: Statementstmt 98.5% 348 / 353 Branchbran 87.3% 166 / 190 Conditioncond 56.5% 91 / 161 MC/DCmcdc 25.3% 21 / 83 Subroutinesub 100% 46 / 46 Podpod 100% 25 / 25 totaltotal 81.2% 697 / 858 CC 178 SCAR 37.0
CC
178
Cov
86%
_validate
118.5
_stored_length
30.7
_activate
11.3
CRAP 40.4
« blib/lib/Peta/NN/Parallel.pm ↑ Summary blib/lib/Peta/NN/Chain.pm »
1 package Peta::NN::Inference;
2 # ABSTRACT: load a trained model and get answers from it
3  
4 # The inference leg: load a trained model and get answers from it. Nothing of
5 # the training leg is needed; this module, Peta::NN::Codec and a model file
6 # are all that ships.
7 #
8 # A model is plain data: what kind it is, how it reads a string (window,
9 # side, radius, vocabulary, parameters), its labels, and the layers with
10 # their weights. Model files hold exactly that, in Storable's portable
11 # format, with each weight array packed.
12 #
13 # A model takes a string and, if it was trained with them, parameters:
14 # opaque values it has learned to react to, without knowing what they mean.
15 # "Äpfel" with "dative" gives "Äpfeln" because the training pairs said so. A
16 # model does not judge its input either; given nonsense it answers something.
17 #
18 # The arithmetic runs on PDL when this perl has it and in plain Perl loops
19 # when not; the answers are the same. PETA_NN_ENGINE=plain forces the loops.
20  
21 28 ▶use v5.36;
Subroutine BEGIN: called CC=1 SCAR=0.0
22 28 ▶use feature 'refaliasing';
Subroutine BEGIN: called CC=1 SCAR=0.0
23 28 ▶no warnings 'experimental::refaliasing';
Subroutine BEGIN: called CC=1 SCAR=0.0
24  
25 28 ▶use Storable ();
Subroutine BEGIN: called CC=1 SCAR=0.0
26  
27 28 ▶use Peta::NN::Codec qw(window apply_edit apply_edit2);
Subroutine BEGIN: called CC=1 SCAR=0.0
28  
29 28 our $VERSION = '0.2610090';
30  
31 28 our $FORMAT = 'Peta::NN model';
32  
33 # The layout of a model file. It goes up when files of the old layout can no
34 # longer be read; such a file is refused by number, not by a puzzling detail.
35 # 1 one optional task, weights packed as named by `pack`
36 # 2 any number of parameters, `bits`, a description of the model
37 28 our $LAYOUT = 2;
38  
39 # PDL exports dozens of functions; they go into a package of their own.
40 27 ▶my $ENGINE = ($ENV{PETA_NN_ENGINE} // '') ne 'plain'
Subroutine BEGIN: called CC=1 SCAR=0.0
Branch: 1 branch
BranchTrueFalseTotal
($ENV{'PETA_NN_ENGINE'} // '') ne 'plain' && eval 'package Peta::NN::Inference::PDL; use PDL::LiteF; 1' ? : 27 1 28
Condition80%4/5
($ENV{"PETA_NN_ENGINE"} // "") ne "plain" and eval "package Peta::NN::Inference::PDL; use PDL::LiteF; 1"
!ll&&!rl&&r
1027
$ENV{"PETA_NN_ENGINE"} // ""
l!l
127
MC/DC0%0/2
($ENV{"PETA_NN_ENGINE"} // "") ne "plain" and eval "package Peta::NN::Inference::PDL; use PDL::LiteF; 1"
$ENV{"PETA_NN_ENGINE"} eval "package Peta::NN::Inference::PDL; use PDL::LiteF; 1"
Truth table0%0/3
A and B
A= $ENV{"PETA_NN_ENGINE"}B= eval "package Peta::NN::Inference::PDL; use PDL::LiteF; 1"
ABresult
0X0
100
111
41 && eval "package Peta::NN::Inference::PDL; use PDL::LiteF; 1" ? 'pdl' : 'plain';
42  
43 28 my $SATURATED = 20; # beyond this exp() adds nothing in a double
44 28 my $CHUNK = 256; # windows per forward pass
45 28 my $FLOOR = 1e-12; # the least probability a pooled label is given, so one zero cannot veto
46  
47 3 ▶sub engine { return $ENGINE }
Subroutine engine: called CC=1 SCAR=0.0
Pod documented
48  
49 # --- how a model reads a string ----------------------------------------------
50 # Used here to answer and by the training leg to build its training data, so
51 # that both see a string the same way. $config is anything with the keys
52 # side, window, radius and vocab; @tokens are the parameters' tokens.
53  
54 # The window of the whole-string kinds: the first characters, the last, or
55 # the first followed by the last.
56 366100 ▶sub end_window ($config, $chars, @tokens) {
Subroutine end_window: called CC=3 SCAR=11.0
Pod documented
57 366100 my ($side, $size, $vocab) = @$config{qw(side window vocab)};
58 return [
59 @tokens,
60 34655 ▶ ($side ne 'right' ? @{ window($chars, 0, $size, $vocab) } : ()),
Branch: 1 branch
BranchTrueFalseTotal
$side ne 'left' ? : 346659 19441 366100
61 366100 ▶ ($side ne 'left' ? @{ window($chars, @$chars - $size, $size, $vocab) } : ()),
Branch: 1 branch
BranchTrueFalseTotal
$side ne 'right' ? : 34655 331445 366100
62 ];
63 }
64  
65 # The window around one character, for rewrite.
66 45017 ▶sub char_window ($config, $chars, $pos, @tokens) {
Subroutine char_window: called CC=1 SCAR=0.0
Pod documented
67 45017 my $radius = $config->{radius};
68 45017 return [ @tokens, @{ window($chars, $pos - $radius, 2 * $radius + 1, $config->{vocab}) } ];
69 }
70  
71 # The tokens of a call's parameters. $params is the model's list of tables,
72 # one per parameter position, each from value to token. The number of
73 # parameters must be the model's; a value the model was never trained with
74 # is refused.
75 231767 ▶sub param_tokens ($params, @values) {
Subroutine param_tokens: called CC=6 SCAR=18.4
Pod documented
76 231767 ▶ my @tables = @{ $params // [] };
Condition50%1/2
$params // []
l!l
2317670
MC/DC0%0/1
$params // []
$params
Truth table50%1/2
A
A= $params
Aresult
11
00
77 231767 ▶ die sprintf "this model takes %d parameter%s, not %d\n", scalar @tables, @tables == 1 ? '' : 's', scalar @values
Branch: 2 branches
BranchTrueFalseTotal
if @values != @tables 3 231764 231767
@tables == 1 ? : 3 0 3
78 if @values != @tables;
79 return map {
80 231764 ▶ my $value = $values[$_] // die "parameter @{[ $_ + 1 ]} is undefined\n";
Condition50%1/2
$values[$_] // die("parameter @{[$_ + 1];} is undefined\n")
l!l
474350
MC/DC0%0/1
$values[$_] // die("parameter @{[$_ + 1];} is undefined\n")
$values[$_]
Truth table50%1/2
A
A= $values[$_]
Aresult
11
00
81 47435 ▶ $tables[$_]{$value} // die "parameter @{[ $_ + 1 ]} has no value '$value' in this model (it has: @{[ sort keys %{ $tables[$_] } ]})\n"
Condition100%2/2
$tables[$_]{$value} // die("parameter @{[$_ + 1];} has no value '${value}' in this model (it has: @{[sort(keys %{$tables[$_];})];})\n")
l!l
474305
MC/DC100%1/1
$tables[$_]{$value} // die("parameter @{[$_ + 1];} has no value '${value}' in this model (it has: @{[sort(keys %{$tables[$_];})];})\n")
$tables[$_]{$value}
Truth table100%2/2
A
A= $tables[$_]{$value}
Aresult
11
00
82 } 0 .. $#tables;
83 }
84  
85 # --- weights as stored ---------------------------------------------------------
86 # A weight array is, in memory, a list of numbers. In a file it is a string
87 # packed as 32- or 64-bit floats, or { int8 => string, scale => number }:
88 # signed bytes that give the weights when multiplied by the scale.
89  
90 28 my %FLOAT_PACK = (32 => 'f<', 64 => 'd<');
91  
92 160 ▶sub pack_weights ($weights, $bits) {
Subroutine pack_weights: called CC=7 SCAR=19.5
Pod documented
93 160 ▶ return pack "$FLOAT_PACK{$bits}*", @$weights if $FLOAT_PACK{$bits};
Branch: 1 branch
BranchTrueFalseTotal
if $FLOAT_PACK{$bits} 115 45 160
94 45 ▶ die "weights can be stored with 8, 32 or 64 bits, not '$bits'\n" if $bits != 8;
Branch: 1 branch
BranchTrueFalseTotal
if $bits != 8 0 45 45
95 45 my $largest = 0;
96 45 ▶ for my $w (@$weights) { $largest = abs $w if abs $w > $largest }
Branch: 1 branch
BranchTrueFalseTotal
if abs $w > $largest 200 6201 6401
97 45 ▶ my $scale = $largest ? $largest / 127 : 1;
Branch: 1 branch
BranchTrueFalseTotal
$largest ? : 45 0 45
98 45 ▶ return { scale => $scale, int8 => pack 'c*', map { my $q = $_ / $scale; int($q + ($q < 0 ? -0.5 : 0.5)) } @$weights };
Branch: 1 branch
BranchTrueFalseTotal
$q < 0 ? : 3019 3382 6401
99 }
100  
101 4004 ▶sub _unpack_weights ($stored, $bits) {
Subroutine _unpack_weights: called CC=3 SCAR=11.0
102 4004 ▶ return $stored if ref $stored eq 'ARRAY';
Branch: 1 branch
BranchTrueFalseTotal
if ref $stored eq "ARRAY" 3779 225 4004
103 225 ▶ return [ map { $_ * $stored->{scale} } unpack 'c*', $stored->{int8} ] if ref $stored eq 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
if ref $stored eq "HASH" 75 150 225
104 150 return [ unpack "$FLOAT_PACK{$bits}*", $stored ];
105 }
106  
107 # How many numbers a stored weight array holds, or nothing if it is not one.
108 4019 ▶sub _stored_length ($stored, $bits) {
Subroutine _stored_length: called CC=18 SCAR=34.3
109 4019 ▶ return scalar @$stored if ref $stored eq 'ARRAY';
Branch: 1 branch
BranchTrueFalseTotal
if ref $stored eq "ARRAY" 3779 240 4019
110 240 ▶ if (ref $stored eq 'HASH') {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $stored eq "HASH") 75 165 240
111 75 ▶ return if ($bits // 0) != 8 || ref $stored->{int8} || !defined $stored->{int8};
Branch: 1 branch
BranchTrueFalseTotal
if ($bits // 0) != 8 or ref $stored->{"int8"} or not defined $stored->{"int8"} 0 75 75
Condition37%3/8
($bits // 0) != 8 or ref $stored->{"int8"} or not defined $stored->{"int8"}
l!l&&r!l&&!r
0075
($bits // 0) != 8 or ref $stored->{"int8"}
l!l&&r!l&&!r
0075
$bits // 0
l!l
750
MC/DC0%0/3
($bits // 0) != 8 or ref $stored->{"int8"} or not defined $stored->{"int8"}
$bits ref $stored->{"int8"} not defined $stored->{"int8"}
Truth table0%0/4
A or B or not(C)
A= $bitsB= ref $stored->{"int8"}C= not defined $stored->{"int8"}
ABCresult
1XX1
01X1
0011
0000
112 75 ▶ return if !defined $stored->{scale} || ref $stored->{scale} || $stored->{scale} !~ /\A[0-9.eE+-]+\z/ || $stored->{scale} <= 0;
Branch: 1 branch
BranchTrueFalseTotal
if not defined $stored->{"scale"} or ref $stored->{"scale"} or not $stored->{"scale"} =~ /\A[0-9.eE+-]+\z/u or $stored->{"scale"} <= 0 0 75 75
Condition33%3/9
not defined $stored->{"scale"} or ref $stored->{"scale"} or not $stored->{"scale"} =~ /\A[0-9.eE+-]+\z/u or $stored->{"scale"} <= 0
l!l&&r!l&&!r
0075
not defined $stored->{"scale"} or ref $stored->{"scale"} or not $stored->{"scale"} =~ /\A[0-9.eE+-]+\z/u
l!l&&r!l&&!r
0075
not defined $stored->{"scale"} or ref $stored->{"scale"}
l!l&&r!l&&!r
0075
MC/DC0%0/4
not defined $stored->{"scale"} or ref $stored->{"scale"} or not $stored->{"scale"} =~ /\A[0-9.eE+-]+\z/u or $stored->{"scale"} <= 0
not defined $stored->{"scale"} ref $stored->{"scale"} not $stored->{"scale"} =~ /\A[0-9.eE+-]+\z/u $stored->{"scale"} <= 0
Truth table20%1/5
not(A) or B or not(C) or D
A= not defined $stored->{"scale"}B= ref $stored->{"scale"}C= not $stored->{"scale"} =~ /\A[0-9.eE+-]+\z/uD= $stored->{"scale"} <= 0
ABCDresult
1XXX1
01XX1
001X1
00011
00000
113 75 return length $stored->{int8};
114 }
115 165 ▶ my $bytes = !defined $bits ? undef : $bits == 32 ? 4 : $bits == 64 ? 8 : undef;
Branch: 3 branches
BranchTrueFalseTotal
!defined($bits) ? : 0 165 165
$bits == 32 ? : 154 11 165
$bits == 64 ? : 10 1 11
116 165 ▶ return if ref $stored || !defined $stored || !$bytes || length($stored) % $bytes;
Branch: 1 branch
BranchTrueFalseTotal
if ref $stored or not defined $stored or not $bytes or length($stored) % $bytes 2 163 165
Condition66%6/9
ref $stored or not defined $stored or not $bytes or length($stored) % $bytes
l!l&&r!l&&!r
11163
ref $stored or not defined $stored or not $bytes
l!l&&r!l&&!r
01164
ref $stored or not defined $stored
l!l&&r!l&&!r
00165
MC/DC50%2/4
ref $stored or not defined $stored or not $bytes or length($stored) % $bytes
ref $stored not defined $stored not $bytes length($stored) % $bytes
Truth table60%3/5
A or not(B) or not(C) or D
A= ref $storedB= not defined $storedC= not $bytesD= length($stored) % $bytes
ABCDresult
1XXX1
01XX1
001X1
00011
00000
117 163 return length($stored) / $bytes;
118 }
119  
120 # --- reading and checking a model ---------------------------------------------
121  
122 28 my %KIND = map { $_ => 1 } qw(class edit rewrite);
123 28 my %SIDE = map { $_ => 1 } qw(left right both);
124 28 my %ACTIVATION = map { $_ => 1 } qw(relu tanh sigmoid);
125 28 my %BITS = map { $_ => 1 } qw(8 32 64);
126  
127 # Read a Storable file as plain data. Flags 0: nothing in the file is blessed
128 # into a class or tied, so reading it runs no code of anyone's choosing.
129 61 ▶sub read_file ($file, $format) {
Subroutine read_file: called CC=6 SCAR=18.7
Pod documented
130 61 my $data = eval { Storable::retrieve($file, 0) };
131 61 ▶ die "$file cannot be read as a $format file: " . ($@ =~ s/ at \S+ line \d+.*//sr || "$!") . "\n" if !defined $data;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $data 3 58 61
Condition33%1/3
$@ =~ s/ at \S+ line \d+.*//rsu || "$!"
l!l&&r!l&&!r
300
MC/DC0%0/2
$@ =~ s/ at \S+ line \d+.*//rsu || "$!"
$@ =~ s/ at \S+ line \d+.*//rsu "$!"
Truth table33%1/3
A || B
A= $@ =~ s/ at \S+ line \d+.*//rsuB= "$!"
ABresult
1X1
011
000
132 58 ▶ die "$file is not a $format file\n" if ref $data ne 'HASH' || ($data->{format} // '') ne $format;
Branch: 1 branch
BranchTrueFalseTotal
if ref $data ne "HASH" or ($data->{"format"} // "") ne $format 6 52 58
Condition60%3/5
ref $data ne "HASH" or ($data->{"format"} // "") ne $format
l!l&&r!l&&!r
0652
$data->{"format"} // ""
l!l
580
MC/DC0%0/2
ref $data ne "HASH" or ($data->{"format"} // "") ne $format
ref $data ne "HASH" $data->{"format"}
Truth table33%1/3
A or B
A= ref $data ne "HASH"B= $data->{"format"}
ABresult
1X1
011
000
133 52 return $data;
134 }
135  
136 20415 ▶sub _is_count ($value) { return defined $value && !ref $value && $value =~ /\A[1-9][0-9]*\z/ }
Subroutine _is_count: called CC=3 SCAR=13.1
Condition50%3/6
defined $value && !ref($value) && $value =~ /\A[1-9][0-9]*\z/u
!ll&&!rl&&r
0120414
defined $value and not ref $value
!ll&&!rl&&r
0020415
MC/DC33%1/3
defined $value && !ref($value) && $value =~ /\A[1-9][0-9]*\z/u
defined $value not ref $value $value =~ /\A[1-9][0-9]*\z/u
Truth table50%2/4
A and not(B) && C
A= defined $valueB= not ref $valueC= $value =~ /\A[1-9][0-9]*\z/u
ABCresult
0XX0
10X0
1100
1111
137  
138 # Die unless $data is a model this module can answer from: every field of the
139 # right type, and every layer of the size its neighbours need. A model that
140 # passes cannot index outside its weights or its labels.
141 817 ▶sub _validate ($data) {
Subroutine _validate: called CC=65 SCAR=47.7
142 817 ▶ my $bad = sub ($what) { die "malformed model: $what\n" };
Subroutine __ANON__: called CC=1 SCAR=0.0
143  
144 # Data built in this process carries no layout; a file always does.
145 $bad->(sprintf 'it is in layout %s, and this version reads layout %d; export it again', $data->{layout} // 1, $LAYOUT)
146 817 ▶ if defined $data->{format} && ($data->{layout} // 1) ne $LAYOUT;
Branch: 1 branch
BranchTrueFalseTotal
if defined $data->{"format"} and ($data->{"layout"} // 1) ne $Peta::NN::Inference::LAYOUT 1 816 817
Condition85%6/7
defined $data->{"format"} and ($data->{"layout"} // 1) ne $Peta::NN::Inference::LAYOUT
!ll&&!rl&&r
755611
$data->{"layout"} // 1
l!l
611
$data->{"layout"} // 1
l!l
01
MC/DC100%2/2
defined $data->{"format"} and ($data->{"layout"} // 1) ne $Peta::NN::Inference::LAYOUT
defined $data->{"format"} $data->{"layout"}
Truth table100%3/3
A and B
A= defined $data->{"format"}B= $data->{"layout"}
ABresult
0X0
100
111
147  
148 816 ▶ $bad->('unknown kind') if !$KIND{ $data->{kind} // '' };
Branch: 1 branch
BranchTrueFalseTotal
unless $KIND{$data->{"kind"} // ""} 1 815 816
Condition50%1/2
$data->{"kind"} // ""
l!l
8160
MC/DC0%0/1
$data->{"kind"} // ""
$data->{"kind"}
Truth table50%1/2
A
A= $data->{"kind"}
Aresult
11
00
149 815 ▶ $bad->('unknown side') if !$SIDE{ $data->{side} // '' };
Branch: 1 branch
BranchTrueFalseTotal
unless $SIDE{$data->{"side"} // ""} 1 814 815
Condition50%1/2
$data->{"side"} // ""
l!l
8150
MC/DC0%0/1
$data->{"side"} // ""
$data->{"side"}
Truth table50%1/2
A
A= $data->{"side"}
Aresult
11
00
150 814 ▶ $bad->('window is not a positive whole number') if !_is_count($data->{window});
Branch: 1 branch
BranchTrueFalseTotal
unless _is_count($data->{"window"}) 1 813 814
151 813 ▶ $bad->('radius is not a positive whole number') if !_is_count($data->{radius});
Branch: 1 branch
BranchTrueFalseTotal
unless _is_count($data->{"radius"}) 0 813 813
152  
153 813 my ($vocab, $labels, $params, $layers) = @$data{qw(vocab labels params layers)};
154 813 ▶ $bad->('no vocabulary') if ref $vocab ne 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
if ref $vocab ne "HASH" 0 813 813
155 813 ▶ $bad->('no labels') if ref $labels ne 'ARRAY' || !@$labels || grep { !defined || ref } @$labels;
Branch: 1 branch
BranchTrueFalseTotal
if ref $labels ne "ARRAY" or not @$labels or grep {not defined $_ or ref $_;} @$labels 1 812 813
Condition55%5/9
ref $labels ne "ARRAY" or not @$labels or grep {not defined $_ or ref $_;} @$labels
l!l&&r!l&&!r
10812
ref $labels ne "ARRAY" or not @$labels
l!l&&r!l&&!r
01812
!defined($_) || ref $_
l!l&&r!l&&!r
007950
MC/DC33%1/3
ref $labels ne "ARRAY" or not @$labels or grep {not defined $_ or ref $_;} @$labels
ref $labels ne "ARRAY" not @$labels grep {not defined $_ or ref $_;} @$labels
MC/DC0%0/2
!defined($_) || ref $_
!defined($_) ref $_
Truth table50%2/4
A or not(B) or C
A= ref $labels ne "ARRAY"B= not @$labelsC= grep {not defined $_ or ref $_;} @$labels
ABCresult
1XX1
01X1
0011
0000
Truth table33%1/3
not(A) || B
A= !defined($_)B= ref $_
ABresult
1X1
011
000
156 $bad->('parameters are not a list of tables')
157 812 ▶ if defined $params && (ref $params ne 'ARRAY' || grep { ref ne 'HASH' || !%$_ } @$params);
Branch: 1 branch
BranchTrueFalseTotal
if defined $params and ref $params ne "ARRAY" || grep({ref $_ ne "HASH" or not %$_;} @$params) 1 811 812
Condition66%6/9
defined $params and ref $params ne "ARRAY" || grep({ref $_ ne "HASH" or not %$_;} @$params)
!ll&&!rl&&r
08111
ref $params ne "ARRAY" or grep {ref $_ ne "HASH" or not %$_;} @$params
l!l&&r!l&&!r
01811
ref $_ ne 'HASH' || !%$_
l!l&&r!l&&!r
1060
MC/DC33%1/3
defined $params and ref $params ne "ARRAY" || grep({ref $_ ne "HASH" or not %$_;} @$params)
defined $params ref $params ne "ARRAY" grep {ref $_ ne "HASH" or not %$_;} @$params
MC/DC50%1/2
ref $_ ne 'HASH' || !%$_
ref $_ ne 'HASH' !%$_
Truth table50%2/4
A and B or C
A= defined $paramsB= ref $params ne "ARRAY"C= grep {ref $_ ne "HASH" or not %$_;} @$params
ABCresult
0XX0
1000
11X1
1011
Truth table66%2/3
A || not(B)
A= ref $_ ne 'HASH'B= !%$_
ABresult
1X1
011
000
158 # The parameters' names, if the model has them: one each, no name twice.
159 811 ▶ if (defined(my $given = $data->{given})) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined(my $given = $data->{"given"})) 30 781 811
160 30 my %seen;
161 $bad->('the names of the parameters are not one plain name for each parameter')
162 30 ▶ if ref $given ne 'ARRAY' || @$given != @{ $params // [] } || grep { !defined || ref || !length || $seen{$_}++ } @$given;
Branch: 1 branch
BranchTrueFalseTotal
if ref $given ne "ARRAY" or @$given != @{$params // [];} or grep {not defined $_ or ref $_ or not length $_ or $seen{$_}++;} @$given 0 30 30
Condition35%6/17
ref $given ne "ARRAY" or @$given != @{$params // [];} or grep {not defined $_ or ref $_ or not length $_ or $seen{$_}++;} @$given
l!l&&r!l&&!r
0030
ref $given ne "ARRAY" or @$given != @{$params // [];}
l!l&&r!l&&!r
0030
$params // []
l!l
300
!defined($_) || ref $_ || !length($_) || $seen{$_}++
l!l&&r!l&&!r
0033
not defined $_ or ref $_ or not length $_
l!l&&r!l&&!r
0033
not defined $_ or ref $_
l!l&&r!l&&!r
0033
MC/DC0%0/3
ref $given ne "ARRAY" or @$given != @{$params // [];} or grep {not defined $_ or ref $_ or not length $_ or $seen{$_}++;} @$given
ref $given ne "ARRAY" @$given != @{$params // [];} grep {not defined $_ or ref $_ or not length $_ or $seen{$_}++;} @$given
MC/DC0%0/1
$params // []
$params
MC/DC0%0/4
!defined($_) || ref $_ || !length($_) || $seen{$_}++
not defined $_ ref $_ not length $_ $seen{$_}++
Truth table25%1/4
A or B or C
A= ref $given ne "ARRAY"B= @$given != @{$params // [];}C= grep {not defined $_ or ref $_ or not length $_ or $seen{$_}++;} @$given
ABCresult
1XX1
01X1
0011
0000
Truth table50%1/2
A
A= $params
Aresult
11
00
Truth table20%1/5
not(A) or B or not(C) || D
A= not defined $_B= ref $_C= not length $_D= $seen{$_}++
ABCDresult
1XXX1
01XX1
001X1
00011
00000
163 }
164 811 ▶ $bad->('no layers') if ref $layers ne 'ARRAY' || !@$layers;
Branch: 1 branch
BranchTrueFalseTotal
if ref $layers ne "ARRAY" or not @$layers 1 810 811
Condition66%2/3
ref $layers ne "ARRAY" or not @$layers
l!l&&r!l&&!r
01810
MC/DC50%1/2
ref $layers ne "ARRAY" or not @$layers
ref $layers ne "ARRAY" not @$layers
Truth table66%2/3
A or not(B)
A= ref $layers ne "ARRAY"B= not @$layers
ABresult
1X1
011
000
165 810 ▶ $bad->('the description of the model is not a table') if defined $data->{meta} && ref $data->{meta} ne 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
if defined $data->{"meta"} and ref $data->{"meta"} ne "HASH" 0 810 810
Condition66%2/3
defined $data->{"meta"} and ref $data->{"meta"} ne "HASH"
!ll&&!rl&&r
769410
MC/DC0%0/2
defined $data->{"meta"} and ref $data->{"meta"} ne "HASH"
defined $data->{"meta"} ref $data->{"meta"} ne "HASH"
Truth table66%2/3
A and B
A= defined $data->{"meta"}B= ref $data->{"meta"} ne "HASH"
ABresult
0X0
100
111
166  
167 # Token indices: 0 and 1 are reserved; the characters and the parameter
168 # values follow, no index twice and none beyond the table.
169 810 ▶ my @index = (values %$vocab, map { values %$_ } @{ $params // [] });
Condition50%1/2
$params // []
l!l
8100
MC/DC0%0/1
$params // []
$params
Truth table50%1/2
A
A= $params
Aresult
11
00
170 810 my %seen;
171 $bad->('a token index is not a whole number of 2 or more, or is used twice')
172 810 ▶ if grep { !_is_count($_) || $_ < 2 || $seen{$_}++ } @index;
Branch: 1 branch
BranchTrueFalseTotal
if grep {not _is_count($_) or $_ < 2 or $seen{$_}++;} @index 1 809 810
Condition50%3/6
!_is_count($_) || $_ < 2 || $seen{$_}++
l!l&&r!l&&!r
0117982
not _is_count($_) or $_ < 2
l!l&&r!l&&!r
0017983
MC/DC33%1/3
!_is_count($_) || $_ < 2 || $seen{$_}++
not _is_count($_) $_ < 2 $seen{$_}++
Truth table50%2/4
not(A) or B || C
A= not _is_count($_)B= $_ < 2C= $seen{$_}++
ABCresult
1XX1
01X1
0011
0000
173 809 my $rows = 2 + @index;
174 809 ▶ $bad->('token indices leave gaps') if grep { $_ >= $rows } @index;
Branch: 1 branch
BranchTrueFalseTotal
if grep {$_ >= $rows;} @index 1 808 809
175  
176 # An edit's label must be an edit: "cut:add", or for both ends "cut:add|cut:add".
177 808 ▶ if ($data->{kind} eq 'edit') {
Branch: 1 branch
BranchTrueFalseTotal
if ($data->{"kind"} eq "edit") 741 67 808
178 741 ▶ my $form = $data->{side} eq 'both' ? qr/\A[0-9]+:[^|]*\|[0-9]+:.*\z/s : qr/\A[0-9]+:.*\z/s;
Branch: 1 branch
BranchTrueFalseTotal
$data->{'side'} eq 'both' ? : 4 737 741
179 741 ▶ $bad->('an edit label is not an edit') if grep { $_ !~ $form } @$labels;
Branch: 1 branch
BranchTrueFalseTotal
if grep {not $_ =~ /$form/u;} @$labels 1 740 741
180 }
181  
182 807 my $bits = $data->{bits};
183 807 ▶ $bad->('unknown weight size') if defined $bits && !$BITS{$bits};
Branch: 1 branch
BranchTrueFalseTotal
if defined $bits and not $BITS{$bits} 1 806 807
Condition100%3/3
defined $bits and not $BITS{$bits}
!ll&&!rl&&r
755511
MC/DC100%2/2
defined $bits and not $BITS{$bits}
defined $bits not $BITS{$bits}
Truth table100%3/3
A and not(B)
A= defined $bitsB= not $BITS{$bits}
ABresult
0X0
100
111
184  
185 # Follow the sizes through the layers. $width is what a layer hands on.
186 806 ▶ my $tokens = @{ $params // [] }
Branch: 2 branches
BranchTrueFalseTotal
$data->{'kind'} eq 'rewrite' ? : 6 800 806
$data->{'side'} eq 'both' ? : 18 782 800
Condition50%1/2
$params // []
l!l
8060
MC/DC0%0/1
$params // []
$params
Truth table50%1/2
A
A= $params
Aresult
11
00
187 806 + ($data->{kind} eq 'rewrite' ? 2 * $data->{radius} + 1 : ($data->{side} eq 'both' ? 2 : 1) * $data->{window});
188 806 my $width;
189 806 for my $n (0 .. $#$layers) {
190 3217 my $layer = $layers->[$n];
191 3217 ▶ $bad->("layer $n is not a layer") if ref $layer ne 'HASH' || ref $layer->{weights} ne 'ARRAY';
Branch: 1 branch
BranchTrueFalseTotal
if ref $layer ne "HASH" or ref $layer->{"weights"} ne "ARRAY" 0 3217 3217
Condition33%1/3
ref $layer ne "HASH" or ref $layer->{"weights"} ne "ARRAY"
l!l&&r!l&&!r
003217
MC/DC0%0/2
ref $layer ne "HASH" or ref $layer->{"weights"} ne "ARRAY"
ref $layer ne "HASH" ref $layer->{"weights"} ne "ARRAY"
Truth table33%1/3
A or B
A= ref $layer ne "HASH"B= ref $layer->{"weights"} ne "ARRAY"
ABresult
1X1
011
000
192 3217 ▶ my $type = $layer->{type} // '';
Condition50%1/2
$layer->{"type"} // ""
l!l
32170
MC/DC0%0/1
$layer->{"type"} // ""
$layer->{"type"}
Truth table50%1/2
A
A= $layer->{"type"}
Aresult
11
00
193 4019 ▶ my @length = map { _stored_length($_, $bits) // $bad->("layer $n has weights that are not stored as the file says") }
Condition66%2/3
_stored_length($_, $bits) // &$bad("layer $n has weights that are not stored as the file says")
l!l&&r!l&&!r
401720
MC/DC0%0/2
_stored_length($_, $bits) // &$bad("layer $n has weights that are not stored as the file says")
_stored_length($_, $bits) &$bad("layer $n has weights that are not stored as the file says")
Truth table33%1/3
A // B
A= _stored_length($_, $bits)B= &$bad("layer $n has weights that are not stored as the file says")
ABresult
1X1
011
000
194 3217 @{ $layer->{weights} };
195  
196 3215 ▶ if ($type eq 'embed') {
Branch: 3 branches
BranchTrueFalseTotal
if ($type eq 'embed') { } 805 2410 3215
elsif ($type eq 'dense') { } 1606 804 2410
elsif ($ACTIVATION{$type}) { } 803 1 804
197 805 ▶ $bad->('an embedding that is not the first layer') if $n != 0;
Branch: 1 branch
BranchTrueFalseTotal
if $n != 0 0 805 805
198 805 ▶ $bad->('embedding dimension is not a positive whole number') if !_is_count($layer->{dim});
Branch: 1 branch
BranchTrueFalseTotal
unless _is_count($layer->{"dim"}) 0 805 805
199 805 ▶ $bad->('the embedding table does not have one row per token') if @length != 1 || $length[0] != $rows * $layer->{dim};
Branch: 1 branch
BranchTrueFalseTotal
if @length != 1 or $length[0] != $rows * $layer->{"dim"} 1 804 805
Condition66%2/3
@length != 1 or $length[0] != $rows * $layer->{"dim"}
l!l&&r!l&&!r
01804
MC/DC50%1/2
@length != 1 or $length[0] != $rows * $layer->{"dim"}
@length != 1 $length[0] != $rows * $layer->{"dim"}
Truth table66%2/3
A or B
A= @length != 1B= $length[0] != $rows * $layer->{"dim"}
ABresult
1X1
011
000
200 804 $width = $tokens * $layer->{dim};
201 }
202 elsif ($type eq 'dense') {
203 1606 ▶ $bad->('a dense layer with nothing before it') if !defined $width;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $width 0 1606 1606
204 1606 ▶ $bad->("dense layer $n does not fit the layer before it")
Branch: 1 branch
BranchTrueFalseTotal
if @length != 2 or not $length[1] or $length[0] != $width * $length[1] 1 1605 1606
Condition50%3/6
@length != 2 or not $length[1] or $length[0] != $width * $length[1]
l!l&&r!l&&!r
011605
@length != 2 or not $length[1]
l!l&&r!l&&!r
001606
MC/DC33%1/3
@length != 2 or not $length[1] or $length[0] != $width * $length[1]
@length != 2 not $length[1] $length[0] != $width * $length[1]
Truth table50%2/4
A or not(B) or C
A= @length != 2B= not $length[1]C= $length[0] != $width * $length[1]
ABCresult
1XX1
01X1
0011
0000
205 if @length != 2 || !$length[1] || $length[0] != $width * $length[1];
206 1605 $width = $length[1];
207 }
208 elsif ($ACTIVATION{$type}) {
209 803 ▶ $bad->("activation $n has weights, or nothing before it") if @length || !defined $width;
Branch: 1 branch
BranchTrueFalseTotal
if @length or not defined $width 0 803 803
Condition33%1/3
@length or not defined $width
l!l&&r!l&&!r
00803
MC/DC0%0/2
@length or not defined $width
@length not defined $width
Truth table33%1/3
A or not(B)
A= @lengthB= not defined $width
ABresult
1X1
011
000
210 }
211 1 else { $bad->("layer $n is of unknown type") }
212 }
213 801 ▶ $bad->('the last layer does not have one output per label') if ($width // -1) != @$labels;
Branch: 1 branch
BranchTrueFalseTotal
if ($width // -1) != @$labels 1 800 801
Condition50%1/2
$width // -1
l!l
8010
MC/DC0%0/1
$width // -1
$width
Truth table50%1/2
A
A= $width
Aresult
11
00
214 800 return;
215 }
216  
217 # --- a model -----------------------------------------------------------------
218  
219 # From model data, which is checked first. Weight arrays may be lists, or
220 # stored as `bits` says. A weight that is not a finite number is refused: it
221 # would poison every answer.
222 817 ▶sub new ($class, $data) {
Subroutine new: called CC=7 SCAR=19.5
Pod documented
223 817 ▶ die "a model is a table of fields\n" if ref $data ne 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
if ref $data ne "HASH" 0 817 817
224 817 _validate($data);
225 800 my $self = bless { %$data }, $class;
226 800 $self->{as_stored} = $data;
227 $self->{layers} = [
228 map {
229 3204 my $layer = { %$_ };
230 3204 $layer->{weights} = [ map { _unpack_weights($_, $data->{bits}) } @{ $layer->{weights} } ];
231 3204 $layer
232 800 } @{ $data->{layers} }
233 ];
234 800 for my $weights (map { @{ $_->{weights} } } @{ $self->{layers} }) {
235 3995 ▶ die "malformed model: a weight is not a finite number\n" if grep { $_ != $_ || abs($_) == 9**9**9 } @$weights;
Branch: 1 branch
BranchTrueFalseTotal
if grep {$_ != $_ or abs $_ == "Inf";} @$weights 3 3992 3995
Condition100%3/3
$_ != $_ || abs $_ == 9**9**9
l!l&&r!l&&!r
21309685
MC/DC100%2/2
$_ != $_ || abs $_ == 9**9**9
$_ != $_ abs $_ == 9**9**9
Truth table100%3/3
A || B
A= $_ != $_B= abs $_ == 9**9**9
ABresult
1X1
011
000
236 }
237 797 ▶ if ($ENGINE eq 'pdl') {
Branch: 1 branch
BranchTrueFalseTotal
if ($ENGINE eq "pdl") 788 9 797
238 788 for my $layer (grep { $_->{type} eq 'dense' } @{ $self->{layers} }) {
239 1578 my ($W, $b) = @{ $layer->{weights} };
240 # (in, out) as stored, transposed once: a batch (in, rows) times it is (out, rows).
241 1578 $layer->{Wt} = PDL->pdl(PDL::double(), $W)->reshape(@$W / @$b, scalar @$b)->transpose->copy;
242 1578 $layer->{bias} = PDL->pdl(PDL::double(), $b);
243 }
244 }
245 797 return $self;
246 }
247  
248 # From a model file (by convention *.model). The file is read as plain data
249 # and checked in full before anything is computed from it.
250 44 ▶sub load ($class, $file) {
Subroutine load: called CC=2 SCAR=6.9
Pod documented
251 44 my $model = eval { $class->new(read_file($file, $FORMAT)) };
252 44 ▶ die $@ =~ s/\Amalformed model:/$file is a malformed model:/r if !$model;
Branch: 1 branch
BranchTrueFalseTotal
unless $model 24 20 44
253 20 return $model;
254 }
255  
256 16 ▶sub kind ($self) { return $self->{kind} }
Subroutine kind: called CC=1 SCAR=0.0
Pod documented
257  
258 # The model data this object was made from, weights as they were stored.
259 5 ▶sub data ($self) { return $self->{as_stored} }
Subroutine data: called CC=1 SCAR=0.0
Pod documented
260 2 ▶sub labels ($self) { return @{ $self->{labels} } }
Subroutine labels: called CC=1 SCAR=0.0
Pod documented
261  
262 # The values the model knows for each of its parameters: one sorted list per
263 # parameter position. A model without parameters has none.
264 15 ▶sub parameters ($self) {
Subroutine parameters: called CC=2 SCAR=7.1
Pod documented
265 15 ▶ return map { [ sort keys %$_ ] } @{ $self->{params} // [] };
Condition50%1/2
$self->{"params"} // []
l!l
150
MC/DC0%0/1
$self->{"params"} // []
$self->{"params"}
Truth table50%1/2
A
A= $self->{"params"}
Aresult
11
00
266 }
267  
268 # The names of the parameters, in their order; none for a model without
269 # parameters, or for one whose parameters were not given names.
270 14 ▶sub given ($self) { return @{ $self->{given} // [] } }
Subroutine given: called CC=2 SCAR=6.9
Pod documented
Condition100%2/2
$self->{"given"} // []
l!l
113
MC/DC100%1/1
$self->{"given"} // []
$self->{"given"}
Truth table100%2/2
A
A= $self->{"given"}
Aresult
11
00
271  
272 # What a caller gave after the string, as the parameters' values in their
273 # order. A model whose parameters have names takes them by name
274 # (gender => 'neuter'); one whose parameters have none, in their order.
275 5524 ▶sub values_from ($self, @given) {
Subroutine values_from: called CC=4 SCAR=14.5
Pod documented
276 5524 ▶ my $names = $self->{given} or return @given;
Branch: 1 branch
BranchTrueFalseTotal
my $names = $self->{"given"} or return @given 4 5520 5524
277 4 ▶ die sprintf "this model takes %s, by name\n", join ', ', map { "$_ => ..." } @$names if @given != 2 * @$names;
Branch: 1 branch
BranchTrueFalseTotal
if @given != 2 * @$names 0 4 4
278 4 my %named = @given;
279 4 ▶ return map { delete $named{$_} // die sprintf "this model takes %s; '%s' is missing\n", join(', ', @$names), $_ } @$names;
Condition50%1/2
delete $named{$_} // die(sprintf("this model takes %s; '%s' is missing\n", join(", ", @$names), $_))
l!l
50
MC/DC0%0/1
delete $named{$_} // die(sprintf("this model takes %s; '%s' is missing\n", join(", ", @$names), $_))
delete $named{$_}
Truth table50%1/2
A
A= delete $named{$_}
Aresult
11
00
280 }
281  
282 36 ▶sub n_params ($self) {
Subroutine n_params: called CC=2 SCAR=6.9
Pod documented
283 36 my $n = 0;
284 36 $n += @$_ for map { @{ $_->{weights} } } @{ $self->{layers} };
285 36 return $n;
286 }
287  
288 # What there is to know about the model, for a human: what the file says of
289 # itself (name, description, source, when it was made, the fidelity it was
290 # measured at) and what follows from its contents.
291 14 ▶sub info ($self) {
Subroutine info: called CC=7 SCAR=19.7
Pod documented
292 my @shape = map {
293 56 my $type = $_->{type};
294 56 ▶ $type eq 'embed' ? "embed $_->{dim}" : $type eq 'dense' ? 'dense ' . @{ $_->{weights}[1] } : $type
Branch: 2 branches
BranchTrueFalseTotal
$type eq 'embed' ? : 14 42 56
$type eq 'dense' ? : 28 14 42
295 14 } @{ $self->{layers} };
296 return {
297 14 ▶ %{ $self->{meta} // {} },
Branch: 3 branches
BranchTrueFalseTotal
$self->{'kind'} eq 'rewrite' ? : 0 14 14
$self->{'side'} eq 'both' ? : 0 14 14
$self->{'side'} eq 'left' ? : 0 14 14
Condition100%2/2
$self->{"meta"} // {}
l!l
86
MC/DC100%1/1
$self->{"meta"} // {}
$self->{"meta"}
Truth table100%2/2
A
A= $self->{"meta"}
Aresult
11
00
298 format => $self->{format},
299 version => $self->{version},
300 bits => $self->{bits},
301 kind => $self->{kind},
302 reads => $self->{kind} eq 'rewrite' ? "$self->{radius} characters either side of each character"
303 : $self->{side} eq 'both' ? "the first and the last $self->{window} characters"
304 : "the " . ($self->{side} eq 'left' ? 'first' : 'last') . " $self->{window} characters",
305 layers => join(', ', @shape),
306 weights => $self->n_params,
307 14 labels => scalar @{ $self->{labels} },
308 14 characters => scalar keys %{ $self->{vocab} },
309 parameters => [ $self->parameters ],
310 given => [ $self->given ],
311 };
312 }
313  
314 # The table rows of every token of every window, one window after another.
315 8861 ▶sub _embedded ($layer, $windows) {
Subroutine _embedded: called CC=1 SCAR=0.0
316 8861 my ($table, $dim) = ($layer->{weights}[0], $layer->{dim});
317 8861 return [ map { my $at = $_ * $dim; @$table[ $at .. $at + $dim - 1 ] } map { @$_ } @$windows ];
318 }
319  
320 # Y = X W^T + b for rows of $n_in numbers. The arrays are aliased to lexical
321 # ones so that the loops are plain array code, which is what a JIT compiles.
322 196 ▶sub _affine ($X, $W, $b, $n_in) {
Subroutine _affine: called CC=4 SCAR=13.9
323 196 \my @x = $X;
324 196 \my @W = $W;
325 196 \my @b = $b;
326 196 my $n_out = @b;
327 196 my $rows = @x / $n_in;
328 196 my @y = (0.0) x ($rows * $n_out);
329 196 for my $s (0 .. $rows - 1) {
330 14980 my $x_at = $s * $n_in;
331 14980 my $y_at = $s * $n_out;
332 14980 for my $j (0 .. $n_out - 1) {
333 262261 my $sum = $b[$j];
334 262261 my $w_at = $j * $n_in;
335 262261 for my $i (0 .. $n_in - 1) {
336 3929612 $sum += $W[ $w_at + $i ] * $x[ $x_at + $i ];
337 }
338 262261 $y[ $y_at + $j ] = $sum;
339 }
340 }
341 196 return \@y;
342 }
343  
344 # In place.
345 98 ▶sub _activate ($type, $X) {
Subroutine _activate: called CC=11 SCAR=24.3
346 98 \my @x = $X;
347 98 ▶ if ($type eq 'relu') {
Branch: 2 branches
BranchTrueFalseTotal
if ($type eq 'relu') { } 26 72 98
elsif ($type eq 'tanh') { } 26 46 72
348 26 ▶ for my $i (0 .. $#x) { $x[$i] = 0.0 if $x[$i] < 0 }
Branch: 1 branch
BranchTrueFalseTotal
if $x[$i] < 0 5661 12843 18504
349 }
350 elsif ($type eq 'tanh') {
351 26 for my $i (0 .. $#x) {
352 9252 my $v = $x[$i];
353 9252 ▶ if ($v > $SATURATED) { $x[$i] = 1.0 }
Branch: 2 branches
BranchTrueFalseTotal
if ($v > $SATURATED) { } 0 9252 9252
elsif ($v < -$SATURATED) { } 0 9252 9252
354 0 elsif ($v < -$SATURATED) { $x[$i] = -1.0 }
355 9252 else { my $e = exp(2 * $v); $x[$i] = ($e - 1) / ($e + 1) }
356 }
357 }
358 else {
359 46 for my $i (0 .. $#x) {
360 95168 my $v = $x[$i];
361 95168 ▶ $x[$i] = $v > $SATURATED ? 1.0 : $v < -$SATURATED ? 0.0 : 1 / (1 + exp(-$v));
Branch: 2 branches
BranchTrueFalseTotal
$v > $SATURATED ? : 833 94335 95168
$v < -$SATURATED ? : 1962 92373 94335
362 }
363 }
364 98 return;
365 }
366  
367 # The network's outputs for a list of windows, as one flat list of rows.
368 98 ▶sub _outputs_plain ($self, $windows) {
Subroutine _outputs_plain: called CC=4 SCAR=13.9
369 98 my ($x, $cols);
370 98 for my $layer (@{ $self->{layers} }) {
371 392 my $type = $layer->{type};
372 392 ▶ if ($type eq 'embed') {
Branch: 2 branches
BranchTrueFalseTotal
if ($type eq 'embed') { } 98 294 392
elsif ($type eq 'dense') { } 196 98 294
373 98 $x = _embedded($layer, $windows);
374 98 $cols = @$x / @$windows;
375 }
376 elsif ($type eq 'dense') {
377 196 $x = _affine($x, @{ $layer->{weights} }, $cols);
378 196 $cols = @{ $layer->{weights}[1] };
379 }
380 98 else { _activate($type, $x) }
381 }
382 98 return $x;
383 }
384  
385 8763 ▶sub _outputs_pdl ($self, $windows) {
Subroutine _outputs_pdl: called CC=6 SCAR=18.0
386 8763 my $x;
387 8763 for my $layer (@{ $self->{layers} }) {
388 36254 my $type = $layer->{type};
389 36254 ▶ if ($type eq 'embed') {
Branch: 4 branches
BranchTrueFalseTotal
if ($type eq 'embed') { } 8763 27491 36254
elsif ($type eq 'dense') { } 18127 9364 27491
elsif ($type eq 'relu') { } 8488 876 9364
elsif ($type eq 'tanh') { } 876 0 876
390 8763 my $flat = _embedded($layer, $windows);
391 8763 $x = PDL->pdl(PDL::double(), $flat)->reshape(@$flat / @$windows, scalar @$windows);
392 }
393 18127 elsif ($type eq 'dense') { $x = ($x x $layer->{Wt}) + $layer->{bias} }
394 8488 elsif ($type eq 'relu') { $x = $x * ($x > 0) }
395 876 elsif ($type eq 'tanh') { $x = PDL::tanh($x) }
396 0 else { $x = 1 / (1 + exp(-$x)) }
397 }
398 8763 return [ $x->list ];
399 }
400  
401 # For each window the probability of every label, in the labels' order.
402 8824 ▶sub _probabilities ($self, $windows) {
Subroutine _probabilities: called CC=9 SCAR=22.0
403 8824 my $cols = @{ $self->{labels} };
404 8824 my @rows;
405 8824 ▶ for (my $start = 0; $start < @$windows; $start += $CHUNK) {
Branch: 1 branch
BranchTrueFalseTotal
if ($start < @$windows) 8861 8824 17685
406 8861 my $end = $start + $CHUNK - 1;
407 8861 ▶ $end = $#$windows if $end > $#$windows;
Branch: 1 branch
BranchTrueFalseTotal
if $end > $windows->$#* 8820 41 8861
408 8861 my @chunk = @$windows[ $start .. $end ];
409 8861 ▶ my $out = $ENGINE eq 'pdl' ? $self->_outputs_pdl(\@chunk) : $self->_outputs_plain(\@chunk);
Branch: 1 branch
BranchTrueFalseTotal
$ENGINE eq 'pdl' ? : 8763 98 8861
410 8861 for my $row (0 .. $#chunk) {
411 170445 my @z = @$out[ $row * $cols .. ($row + 1) * $cols - 1 ];
412 170445 my $top = $z[0];
413 170445 ▶ for my $v (@z) { $top = $v if $v > $top }
Branch: 1 branch
BranchTrueFalseTotal
if $v > $top 333822 1467791 1801613
414 170445 my $sum = 0;
415 170445 $sum += ($_ = exp($_ - $top)) for @z; # the largest first becomes 1: nothing overflows
416 170445 $_ /= $sum for @z;
417 170445 push @rows, \@z;
418 }
419 }
420 8824 return \@rows;
421 }
422  
423 165806 ▶sub _best ($probabilities) {
Subroutine _best: called CC=3 SCAR=11.0
424 165806 my $best = 0;
425 165806 ▶ for my $i (1 .. $#$probabilities) { $best = $i if $probabilities->[$i] > $probabilities->[$best] }
Branch: 1 branch
BranchTrueFalseTotal
if $probabilities->[$i] > $probabilities->[$best] 331138 1284928 1616066
426 165806 return $best;
427 }
428  
429 # A decided edit, carried out. An edit that cannot apply to this string
430 # leaves it as it is.
431 138929 ▶sub _edited ($self, $text, $label) {
Subroutine _edited: called CC=6 SCAR=18.2
432 138929 my $side = $self->{side};
433 138929 ▶ return apply_edit2($text, $label) // $text if $side eq 'both';
Branch: 1 branch
BranchTrueFalseTotal
if $side eq "both" 807 138122 138929
Condition33%1/3
apply_edit2($text, $label) // $text
l!l&&r!l&&!r
80700
MC/DC0%0/2
apply_edit2($text, $label) // $text
apply_edit2($text, $label) $text
Truth table33%1/3
A // B
A= apply_edit2($text, $label)B= $text
ABresult
1X1
011
000
434 138122 ▶ return apply_edit($text, $label) // $text if $side eq 'right';
Branch: 1 branch
BranchTrueFalseTotal
if $side eq "right" 137753 369 138122
Condition100%3/3
apply_edit($text, $label) // $text
l!l&&r!l&&!r
1371416084
MC/DC100%2/2
apply_edit($text, $label) // $text
apply_edit($text, $label) $text
Truth table100%3/3
A // B
A= apply_edit($text, $label)B= $text
ABresult
1X1
011
000
435 369 my $result = apply_edit(scalar reverse($text), $label); # at the front: the same on the reversed string
436 369 ▶ return defined $result ? scalar reverse $result : $text;
Branch: 1 branch
BranchTrueFalseTotal
defined $result ? : 369 0 369
437 }
438  
439 # The windows of many strings and, for rewrite, how many belong to each.
440 8754 ▶sub _windows ($self, $texts, @values) {
Subroutine _windows: called CC=2 SCAR=6.9
441 8754 my @tokens = param_tokens($self->{params}, @values);
442 8748 my @chars = map { [ split // ] } @$texts;
443 8748 ▶ return [ map { end_window($self, $_, @tokens) } @chars ] if $self->{kind} ne 'rewrite';
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"kind"} ne "rewrite" 8443 305 8748
444 305 return ([ map { my $c = $_; map { char_window($self, $c, $_, @tokens) } 0 .. $#$c } @chars ], [ map { scalar @$_ } @chars ]);
445 }
446  
447 # The probability of every label, in the labels' order, for each of many
448 # windows.
449 14 ▶sub probabilities ($self, $windows) { return $self->_probabilities($windows) }
Subroutine probabilities: called CC=1 SCAR=0.0
Pod documented
450  
451 # [index of the best label, its probability] for each of many windows: the
452 # model's decisions for input that is already tokens, which is what a fused
453 # model hands its parts.
454 62 ▶sub decisions ($self, $windows) {
Subroutine decisions: called CC=1 SCAR=0.0
Pod documented
455 62 return [ map { my $best = _best($_); [ $best, $_->[$best] ] } @{ $self->_probabilities($windows) } ];
456 }
457  
458 # [answer, confidence] for each of many strings, all their decisions in one
459 # pass. For a rewrite the confidence is that of its least certain character.
460 7971 ▶sub answers ($self, $texts, @values) {
Subroutine answers: called CC=6 SCAR=17.9
Pod documented
461 7971 my ($windows, $lengths) = $self->_windows($texts, @values);
462 7965 my $rows = $self->_probabilities($windows);
463 7965 my $labels = $self->{labels};
464  
465 7965 ▶ if ($self->{kind} eq 'rewrite') {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"kind"} eq "rewrite") 303 7662 7965
466 303 my @answers;
467 303 for my $length (@$lengths) {
468 1396 my ($result, $confidence) = ('', 1);
469 1396 for my $p (splice @$rows, 0, $length) {
470 10845 my $best = _best($p);
471 10845 $result .= $labels->[$best];
472 10845 ▶ $confidence = $p->[$best] if $p->[$best] < $confidence;
Branch: 1 branch
BranchTrueFalseTotal
if $p->[$best] < $confidence 3151 7694 10845
473 }
474 1396 push @answers, [ $result, $confidence ];
475 }
476 303 return \@answers;
477 }
478  
479 7662 my $edit = $self->{kind} eq 'edit';
480 return [
481 map {
482 7662 my $best = _best($rows->[$_]);
483 144965 ▶ [ $edit ? $self->_edited($texts->[$_], $labels->[$best]) : $labels->[$best], $rows->[$_][$best] ]
Branch: 1 branch
BranchTrueFalseTotal
$edit ? : 138913 6052 144965
484 } 0 .. $#$texts
485 ];
486 }
487  
488 # The model's answer for a string, with its parameters if the model has any;
489 # in list context also its confidence.
490 5497 ▶sub predict ($self, $text, @given) {
Subroutine predict: called CC=2 SCAR=6.9
Pod documented
491 5497 my ($answer) = @{ $self->answers([$text], $self->values_from(@given)) };
492 5492 ▶ return wantarray ? @$answer : $answer->[0];
Branch: 1 branch
BranchTrueFalseTotal
wantarray ? : 2203 3289 5492
493 }
494  
495 # The answers for many strings at once, in their order, all with the same
496 # parameters.
497 17 ▶sub predict_all ($self, $texts, @given) {
Subroutine predict_all: called CC=1 SCAR=0.0
Pod documented
498 17 return map { $_->[0] } @{ $self->answers($texts, $self->values_from(@given)) };
499 }
500  
501 # Everything the model considers for a string, not only its best answer: a
502 # list of [answer, probability], most probable first, the probabilities
503 # adding up to 1. A model that is not sure shows it here. For an edit model
504 # the answers are the resulting strings (two edits giving the same string
505 # are one answer). For a rewrite it is one such list per character.
506 7 ▶sub distribution ($self, $text, @given) {
Subroutine distribution: called CC=2 SCAR=7.0
Pod documented
507 7 my ($windows) = $self->_windows([$text], $self->values_from(@given));
508 7 my $rows = $self->_probabilities($windows);
509 7 my $labels = $self->{labels};
510 21 ▶ my $sorted = sub ($p) {
Subroutine __ANON__: called CC=4 SCAR=14.0
511 21 my %share;
512 21 for my $i (0 .. $#$labels) {
513 412 ▶ my $answer = $self->{kind} eq 'edit' ? $self->_edited($text, $labels->[$i]) : $labels->[$i];
Branch: 1 branch
BranchTrueFalseTotal
$self->{'kind'} eq 'edit' ? : 16 396 412
514 412 $share{$answer} += $p->[$i];
515 }
516 21 ▶ return [ map { [ $_, $share{$_} ] } sort { $share{$b} <=> $share{$a} || $a cmp $b } keys %share ];
Condition33%1/3
$share{$b} <=> $share{$a} || $a cmp $b
l!l&&r!l&&!r
137700
MC/DC0%0/2
$share{$b} <=> $share{$a} || $a cmp $b
$share{$b} <=> $share{$a} $a cmp $b
Truth table33%1/3
A || B
A= $share{$b} <=> $share{$a}B= $a cmp $b
ABresult
1X1
011
000
517 7 };
518 7 ▶ return $self->{kind} eq 'rewrite' ? [ map { $sorted->($_) } @$rows ] : $sorted->($rows->[0]);
Branch: 1 branch
BranchTrueFalseTotal
$self->{'kind'} eq 'rewrite' ? : 2 5 7
519 }
520  
521 # One distribution for several strings together, for a class model: what
522 # label fits ALL of them, taking each string as independent evidence (the
523 # product of the probabilities, renormalised). A long text sharpens it; one
524 # short ambiguous word leaves it flat. Returned as distribution() does.
525 3 ▶sub pooled ($self, $texts, @given) { return $self->pooled_for($texts, $self->values_from(@given)) }
Subroutine pooled: called CC=1 SCAR=0.0
Pod documented
526  
527 # The same with the parameters' values in their order, as answers() takes them.
528 777 ▶sub pooled_for ($self, $texts, @values) {
Subroutine pooled_for: called CC=2 SCAR=6.9
Pod documented
529 777 ▶ die "pooling is for class models\n" if $self->{kind} ne 'class';
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"kind"} ne "class" 1 776 777
530 776 my ($windows) = $self->_windows($texts, @values);
531 776 return $self->pool($self->_probabilities($windows));
532 }
533  
534 # The same from the probabilities themselves: one list per string, as
535 # probabilities() gives them.
536 1545 ▶sub pool ($self, $rows) {
Subroutine pool: called CC=8 SCAR=20.8
Pod documented
537 1545 my $labels = $self->{labels};
538 1545 my @log = (0) x @$labels;
539 1545 for my $p (@$rows) {
540 4618 ▶ $log[$_] += log($p->[$_] > $FLOOR ? $p->[$_] : $FLOOR) for 0 .. $#log;
Branch: 1 branch
BranchTrueFalseTotal
$p->[$_] > $FLOOR ? : 18267 1062 19329
541 }
542 1545 my $top = $log[0];
543 1545 ▶ for my $v (@log) { $top = $v if $v > $top }
Branch: 1 branch
BranchTrueFalseTotal
if $v > $top 841 5978 6819
544 1545 my @share = map { exp($_ - $top) } @log;
545 1545 my $sum = 0;
546 1545 $sum += $_ for @share;
547 1545 ▶ return [ sort { $b->[1] <=> $a->[1] || $a->[0] cmp $b->[0] } map { [ $labels->[$_], $share[$_] / $sum ] } 0 .. $#share ];
Condition66%2/3
$Peta::NN::Inference::b->[1] <=> $Peta::NN::Inference::a->[1] || $Peta::NN::Inference::a->[0] cmp $Peta::NN::Inference::b->[0]
l!l&&r!l&&!r
961940
MC/DC0%0/2
$Peta::NN::Inference::b->[1] <=> $Peta::NN::Inference::a->[1] || $Peta::NN::Inference::a->[0] cmp $Peta::NN::Inference::b->[0]
$Peta::NN::Inference::b->[1] <=> $Peta::NN::Inference::a->[1] $Peta::NN::Inference::a->[0] cmp $Peta::NN::Inference::b->[0]
Truth table66%2/3
A || B
A= $Peta::NN::Inference::b->[1] <=> $Peta::NN::Inference::a->[1]B= $Peta::NN::Inference::a->[0] cmp $Peta::NN::Inference::b->[0]
ABresult
1X1
011
000
548 }
549  
550 28 1;
551  
552 __END__
« blib/lib/Peta/NN/Parallel.pm ↑ Summary blib/lib/Peta/NN/Chain.pm »