You are bitten by autovivification:

while ( $eventscores->[$i]->[0] == $rider_id ){
[download]

If $i at this time points beyond the end of the array, an arrayref will spring into existence, as you dereference the hitherto unexisting element.

Solution: Don't do that. A common strategy is to protect the dereferencing:

while ( $eventscores->[$i] and $eventscores->[$i]->[0] == $rider_id ){
[download]

Depending on the rest of your outer loop, other solutions may be cleaner though.

This is an autovivication trap. Perl autovivifies (creates) missing elements of refrences for hash and array refs, so every time you get $eventscores->[$i]->[2] you'll at least get something, either your desired variable or undef. So if you overrun your array before you run out of data $rider_id will get set to undef and then the inner loop will become infinite because the autovivified undef's will of course be equal to undef.

While perl will handle most bounds checking for you this is one situation you have to do it yourself.

for my $i ($i .. $#{$eventscores} ) {
[download]

for my $eventscore (@$eventscores} ) {
        $rider_id = $eventscore->[0];
        while ( $eventscore->[0] == $rider_id ){
            push (@scores, $eventscore->[2] );
            $i++;
        }
#...more code.. unrelated to loop
}
[download]

Update: Completely bogus code - doesn't do what the OP's code intended!

There are a number of rules for constructing loops safely in any language that all apply here. Another rule is:

Don't modify any of the control variables from within a loop, whether it be the iterator or the start and stop limits or the compiler or interpreter is apt to stumble and behave unpredictably".

It takes experience to know more such rules but they relate to loop construction technique more than anything else. Three of the lines of code look functionally to be exactly the three parts of a 3-arg for loop, so better just write that, e.g.:

for my $i ( 0 .. $#$eventscores ) { # forces readonly 
    for ( my $j = $i;
          $eventscores->[$j][0] == $eventscores->[$i][0];
          $j++ ){ 
        push (@scores, $eventscores->[$j][2] );
    }
    # more code unrelated to loop
}
[download]

for my $i ( 0 .. $#$eventscores ) { # forces readonly 
    for ( my $j = $i;
          $j <= $#$eventscores;
          $j++ ){ 
        if ( $eventscores->[$j][0] == $eventscores->[$i][0] ) {
            push (@scores, $eventscores->[$j][2] );
        }
    }
    # more code unrelated to loop
}
[download]

Hopefully these nodes will help you as they did me.

Maybe there is a reason for this, but this looks like you should use a different data structure. If I understand it right your AoA looks somewhat like this:

$eventscores = [
 [riderid, actionid, score],
 [riderid, actionid, score],
 [riderid, actionid, score],
 ...
];
[download]

$eventscores = {
  riderid => {
   actionid => score
   actionid => score
   ...
  },
  ...
};
[download]

foreach my $rider (keys %$eventscores) {
 my @scores = values %{$eventscores->{$rider}};
 # or, if you need the scores in order
 my @scores = map {$eventscores->{$rider}{$_}} sort keys %{$eventscore
+s->{$rider}};

 # do something with $rider and @scores
}
[download]

select riderid, AVG(score) 
  from eventscores
 group by riderid
 order by riderid
[download]

If you don't know SQL yet, learn it. It'll make many things much easier.