работающие с AoA, хранящимися в хэше. PDL против отсутствия PDL

Во-первых, PDL мало чем поможет, если массивы не большие. Таким образом, вместо того, чтобы использовать хэш, проиндексированный от 0 до 10000, каждый из которых (в основном) с семью скалярными элементами, можете ли вы вместо этого создать семь векторов PDL по 10001 элемент каждый и работать с теми, которые используют векторные операции?

Во-вторых, выражение $hash{$_} вычисляется каждый раз, когда вы называете его, поэтому его следует вынести за скобки. Например, в вашем стандартном коде Perl вы должны сделать это:

my $vec = $hash{$_};
foreach my $i (0 .. 2){
    $error += (($vec->[0][$i]-$vec->[2][$i])*$vec->[1])**2;
}

PDL оптимизирован для работы с массивами. Вы используете хеш для своих данных, но, поскольку ключи являются числами, их можно переформулировать в терминах объектов массива PDL для большого выигрыша в производительности. Следующая полностью PDL-версия примера кода работает примерно в 36 раз быстрее, чем исходный без кода PDL (и в 300 раз быстрее, чем исходный с кодом PDL).

все PDL

use strict;
use warnings;
use PDL;
use Time::HiRes qw(time);

my $t1 = time;
my %hash;
my $error = 0;

my $pdl0 = zeros(3,10001);  # create a [3,10001] pdl
$pdl0 .= pdl[0.000, 1.000, 2.0000];

my $pdl1 = zeros(1,10001);  # create a [1,10001] pdl
$pdl1 .= pdl[10.0];

my $pdl2 = zeros(3,10001);  # create a [3,10001] pdl
$pdl2 .= pdl[1.5,9.5,5.5];

my $e = ($pdl0 - $pdl2)*$pdl1;
$error = sum($e*$e);

my $t2 = time;

printf ( "total time: %10.4f error: %10.4f\n", $t2-$t1, $error);

Подробнее об использовании PDL для вычислений см. в книге по PDL. . домашняя страница PDL также является хорошей отправной точкой для изучения всего, что связано с PDL.

Я рефакторил ваш код несколько раз, сначала вынося как можно больше сложностей за пределы цикла. Во-вторых, я удалил слой или около того абстракции. Это значительно упростило выражение и сократило время выполнения в моей системе примерно на 60%, сохранив при этом тот же результат.

use Modern::Perl;
use Time::HiRes qw(time);

my $t1 = time;
my $error = 0;

my @foo = ( 0.000, 1.000, 2.0000 );
my $bar = 10.0;
my @baz = ( 1.5, 9.5, 5.5 );

foreach ( 0 .. 10000 ) {
    $error += ( ( $foo[$_] - $baz[$_] ) * $bar )**2 for 0 .. 2
}

my $t2 = time;

printf ( "total time: %10.4f error: %10.4f\n", $t2-$t1,$error);

Это просто старый добрый Perl; нет ПДЛ. Надеюсь, это поможет вашему проекту.

Кстати, при расчете времени, необходимого для выполнения участка кода, я предпочитаю модуль Benchmark с его функциями timethis(), timethese() и cmpthese(). Вы получаете больше информации из него.

Основываясь на предложении Nemo, вот сценарий PDL, который обеспечивает скромный прирост скорости. Я все еще зеленый PDL, так что, вероятно, есть лучший способ. Я также разделил добавление значений в хеш на циклы для ссылок/весов и наблюдений, чтобы сделать OP более похожим на то, что происходит в большей программе, см. «Описание» выше.

use strict;
use warnings;
use PDL;
use PDL::NiceSlice;
use Time::HiRes qw(time);

my $t1 = time;
my %hash;
my $nvals=10000;

#construct hash of references and weights
foreach (0 .. $nvals){
  $hash{$_} = [
                 [0.000, 1.000, 2.0000],
                 [10.0, 10.0, 10.0],
               ];
}

#record observations
foreach (0 .. $nvals){
  $hash{$_}[2] = [1.5,9.5,5.5]; 
}

my $tset = time;

my @ref;
my @obs;
my @w;

foreach (0 .. $nvals){
  my $mat = $hash{$_};
  push @ref, @{$mat->[0]};
  push @w,   @{$mat->[1]};
  push @obs, @{$mat->[2]};
}

my $ref = pdl[@ref];
my $obs = pdl[@obs];
my $w   = pdl[@w];

my $diff = (($ref-$obs)*$w)**2;
my $error = sum($diff);

my $t2 = time;

printf ( "$nvals time setup: %10.4f crunch: %10.4f total: %10.4f error: %10.4f\n", $tset-$t1,$t2-$tset, $t2-$t1,$error);