Вопросы Теги

Perl: вставить символ в хеш массива

Для большинства систем требования к сборке теперь упоминаются в документации python-ldap в разделе «Установка».

Если что-то есть отсутствует для вашей системы (или ваша система отсутствует полностью), пожалуйста, сообщите разработчику! (По состоянию на 2018 год я являюсь сопровождающим, поэтому комментариев здесь должно быть достаточно. Или вы можете отправить запрос на перенос или почту.)

1
задан William 30 March 2019 в 22:56
поделиться

2 ответа

Может быть, вам нужен не массив, а хеш?

Изменить толчок на 

undef $maxmot{$id}{ $HoA{$id}[$pos3] };

Он создает хеш (с неопределенными значениями, поэтому важны только ключи) , В выводе я не вижу более 3 клавиш для каждой последовательности во входных данных вашего связанного вопроса.

0
ответ дан choroba 30 March 2019 в 22:56
поделиться

push() не проблема. После запуска вашего кода становится очевидным, что условное $loscore{$id}[$pos2] == $maxscore{$id} оказывается true чаще, чем вы ожидаете.

Вот несколько вопросов, которые я хотел бы задать в обзоре кода:

  • Почему вы используете length() для массива? Он не возвращает длину массива.
  • Разве for my $base (qw( A C G T)) { if ($HoA{$id}[$pos2] eq $base) {... не является неэффективным способом эквивалентного my $base = $HoA{$id}[$pos2];?
  • , вычисление для каждого $pos2 выполняется $pos2 + 1 раз, то есть один раз для 0, дважды для [ 1114], ... то есть более поздние позиции получают более высокий балл.
  • одно вычисление для $loscore{$id}[$pos2] является суммой @{ $logodds{$base} }, т.е. база в позиции $pos2 + $pos3 игнорируется для вычисления
  • , которое вы пересчитываете $maxscore{$id} во время работы над последовательностями [ 1136] и затем используют изменяющееся значение в условном
  • (мое предположение) мотиве, который должен быть длиной $width баз, но ваш код хранит только одиночные базы в %maxmot

Я делаю обоснованное предположение и предлагаю, чтобы следующий алгоритм был правильным. Я использую 3 последовательности, которые вы дали в предыдущем вопросе. Я также сбрасываю другие 2 хэша, чтобы результаты вычислений стали видны.

Я позволил себе переписать ваш код, чтобы быть более кратким и понятным. Но вы должны быть в состоянии отследить строки в новом коде до исходного кода. 

#!/usr/bin/perl
use strict;
use warnings;

use List::Util 'max';
use Data::Dumper;

my $width = 3;

my %HoA;
my %maxpos;
my %loscore;
my $id = '';
while (<DATA>) {
    if (/^>(.+)/) {
        $id = $1;
    } else {
        $HoA{$id}     = [ split(//) ];
        $maxpos{$id}  = @{ $HoA{$id} } - $width - 1;
        $loscore{$id} = [ (0) x ($maxpos{$id} + 1) ];
    }
}

my %logodds = (
    A => [0.1, 0.2, 0.3],
    C => [0.2, 0.5, 0.2],
    G => [0.3, 0.2, 0.4],
    T => [0.4, 0.1, 0.1],
);

#MAXIMIZATION
my %maxscore;
my %maxmot;

# Calculate the log-odds score at each location
foreach $id (keys %HoA) {
    for my $index (0..$maxpos{$id}) {
        for my $offset (0..$width-1) {
            # look at base in sequence $id at $offset after $index
            my $base = $HoA{$id}[$index + $offset];
            $loscore{$id}[$index] += $logodds{$base}[$offset];
        }
    }
}

# Calculate the maximum log-odds score for each sequence
foreach $id (keys %HoA) {
    $maxscore{$id} = max( @{ $loscore{$id} });
}

# Find the motif that gives the maximum score for each sequence
foreach $id (keys %HoA) {
    for my $index (0..$maxpos{$id}) {
        if ($loscore{$id}[$index] == $maxscore{$id}) {
            # motif of length $width
            my $motif = join('', @{ $HoA{$id} }[$index..$index + $width - 1]);
            $maxmot{$id}->{$motif}++;
        }
    }
}

print Data::Dumper->Dump([\%loscore, \%maxscore, \%maxmot],
                         [qw(*loscore *maxscore *maxmot)]);

exit 0;

__DATA__
>Sequence_1
TCAGAACCAGTTATAAATTTATCATTTCCTTCTCCACTCCT
>Sequence_2
CCCACGCAGCCGCCCTCCTCCCCGGTCACTGACTGGTCCTG
>Sequence_3
TCGACCCTCTGGAACCTATCAGGGACCACAGTCAGCCAGGCAAG

Тестовый прогон: 

$ perl dummy.pl
%loscore = (
             'Sequence_1' => [
                               '1.2',
                               '0.8',
                               '0.6',
                               '0.8',
                               '0.5',
                               '0.8',
                               '1',
                               '0.8',
                               '0.4',
                               '0.5',
                               '0.8',
                               '0.7',
                               '0.5',
                               '0.9',
                               '0.6',
                               '0.4',
                               '0.3',
                               '0.6',
                               '0.8',
                               '0.7',
                               '0.4',
                               '1.2',
                               '0.5',
                               '0.3',
                               '0.6',
                               '0.7',
                               '1.1',
                               '0.8',
                               '0.4',
                               '0.7',
                               '1',
                               '0.5',
                               '1.1',
                               '1',
                               '0.6',
                               '0.7',
                               '0.5',
                               '1.1',
                               '0.8'
                             ],
             'Sequence_2' => [
                               '0.9',
                               '1',
                               '0.6',
                               '1',
                               '0.6',
                               '1.1',
                               '0.8',
                               '0.5',
                               '1',
                               '1.1',
                               '0.6',
                               '1',
                               '0.9',
                               '0.8',
                               '0.5',
                               '1.1',
                               '0.8',
                               '0.5',
                               '1.1',
                               '0.9',
                               '0.9',
                               '1.1',
                               '0.8',
                               '0.6',
                               '0.6',
                               '1.2',
                               '0.6',
                               '0.7',
                               '0.7',
                               '0.9',
                               '0.7',
                               '0.7',
                               '0.7',
                               '1',
                               '0.6',
                               '0.6',
                               '1.1',
                               '0.8',
                               '0.7'
                             ],
             'Sequence_3' => [
                               '1.3',
                               '0.7',
                               '0.7',
                               '0.8',
                               '0.9',
                               '0.8',
                               '0.5',
                               '1',
                               '0.7',
                               '1',
                               '0.8',
                               '0.8',
                               '0.5',
                               '0.8',
                               '0.8',
                               '0.6',
                               '0.7',
                               '0.4',
                               '1.2',
                               '0.8',
                               '0.7',
                               '0.9',
                               '0.8',
                               '0.7',
                               '0.8',
                               '1',
                               '0.6',
                               '0.9',
                               '0.8',
                               '0.4',
                               '0.6',
                               '1.2',
                               '0.8',
                               '0.5',
                               '1',
                               '1',
                               '0.8',
                               '0.7',
                               '0.7',
                               '1.1',
                               '0.7',
                               '0.7'
                             ]
           );
%maxscore = (
              'Sequence_1' => '1.2',
              'Sequence_3' => '1.3',
              'Sequence_2' => '1.2'
            );
%maxmot = (
            'Sequence_3' => {
                              'TCG' => 1
                            },
            'Sequence_2' => {
                              'TCA' => 1
                            },
            'Sequence_1' => {
                              'TCA' => 2
                            }
          );

Это выглядит намного ближе к ожидаемому результату. Но, конечно, я мог быть совершенно не уверен в своих догадках ...

Если я правильно понимаю вычисление logscore, тогда оценка за мотив является постоянной и, следовательно, может быть предварительно рассчитана. Что привело бы к следующему более простому подходу: 

#!/usr/bin/perl
use strict;
use warnings;

use Data::Dumper;

my $width = 3;

my %logodds = (
    A => [0.1, 0.2, 0.3],
    C => [0.2, 0.5, 0.2],
    G => [0.3, 0.2, 0.4],
    T => [0.4, 0.1, 0.1],
);

# calculate log score for each motif combination
my $motif_score = {'' => 0}; # start with a 0-length motif
foreach my $offset (0..$width - 1) {
    my %scores;

    # for all motifs...
    foreach my $prefix (keys %{ $motif_score }) {
        my $base_score = $motif_score->{$prefix};

        # ... add another base to the motif
        for my $base (qw(A G C T)) {
            $scores{"${prefix}${base}"} = $base_score + $logodds{$base}[$offset];
        }
    }

    # store the scores for the new sequences
    $motif_score = \%scores;
}

#print Data::Dumper->Dump([$motif_score], [qw(motif_score)]);

my $id;
my %maxmot;
while (<DATA>) {
    if (/^>(.+)/) {
        $id = $1;
    } else {
        chomp(my $sequence = 
 push() не проблема. После запуска вашего кода становится очевидным, что условное $loscore{$id}[$pos2] == $maxscore{$id} оказывается true чаще, чем вы ожидаете. 
 
 Вот несколько вопросов, которые я хотел бы задать в обзоре кода: 
 
     
  •  Почему вы используете length() для массива? Он не возвращает длину массива. 
    •  
  •  Разве for my $base (qw( A C G T)) { if ($HoA{$id}[$pos2] eq $base) {... не является неэффективным способом эквивалентного my $base = $HoA{$id}[$pos2];? 
    •  
  • , вычисление для каждого $pos2 выполняется $pos2 + 1 раз, то есть один раз для 0, дважды для [ 1114], ... то есть более поздние позиции получают более высокий балл. 
    •  
  •  одно вычисление для $loscore{$id}[$pos2] является суммой @{ $logodds{$base} }, т.е. база в позиции $pos2 + $pos3 игнорируется для вычисления 
    •  
  • , которое вы пересчитываете $maxscore{$id} во время работы над последовательностями [ 1136] и  затем используют изменяющееся значение в условном 
    •  
  •  (мое предположение) мотиве, который должен быть длиной $width баз, но ваш код хранит только одиночные базы в %maxmot 
    •  
 
 Я делаю обоснованное предположение и предлагаю, чтобы следующий алгоритм был правильным. Я использую 3 последовательности, которые вы дали в предыдущем вопросе. Я также сбрасываю другие 2 хэша, чтобы результаты вычислений стали видны. 
 
 Я позволил себе переписать ваш код, чтобы быть более кратким и понятным. Но вы должны быть в состоянии отследить строки в новом коде до исходного кода. 
 [110] 
 Тестовый прогон: 
 [111] 
 Это выглядит намного ближе к ожидаемому результату. Но, конечно, я мог быть совершенно не уверен в своих догадках ... 
 
 
 Если я правильно понимаю вычисление logscore, тогда оценка за мотив является постоянной и, следовательно, может быть предварительно рассчитана. Что привело бы к следующему более простому подходу: 
 [112] 
 Тестовый прогон: 
 
$ perl dummy.pl
%maxmot = (
            'Sequence_2' => 'TCA',
            'Sequence_3' => 'TCG',
            'Sequence_1' => 'TCA'
          );

 
 
 Поскольку логическое число по мотивам является константой, список мотивов сортируется по порядку логскор. также будет постоянной. Учитывая этот список, нам нужно будет только найти первый мотив, который соответствует данной последовательности. Следовательно, мы можем применить к этой задаче высоко оптимизированный механизм регулярных выражений. В зависимости от вашего реального размера проблемы это, вероятно, будет более эффективным решением: 
 
#!/usr/bin/perl
use warnings;
use strict;

use List::Util qw(first pairs);
use Data::Dumper;

my $width = 3;

my %logodds = (
    A => [0.1, 0.2, 0.3],
    C => [0.2, 0.5, 0.2],
    G => [0.3, 0.2, 0.4],
    T => [0.4, 0.1, 0.1],
);
my @bases = keys %logodds;

# calculate log score for each motif combination
my $motif_logscore = {'' => 0}; # start with a 0-length motif
foreach my $offset (0..$width - 1) {
    my %score;

    # for all motifs...
    foreach my $prefix (keys %{ $motif_logscore }) {
        my $base_score = $motif_logscore->{$prefix};

        # ... add another base to the motif
        for my $base (@bases) {
            $score{"${prefix}${base}"} = $base_score + $logodds{$base}[$offset];
        }
    }

    # update hash ref to new motif scores
    $motif_logscore = \%score;
}

#print Data::Dumper->Dump([$motif_logscore], [qw(motif_logscore)]);

my @motifs_sorted =
    # list of [<motif>, <regular expression>] array refs
    map    { [
 push() не проблема. После запуска вашего кода становится очевидным, что условное $loscore{$id}[$pos2] == $maxscore{$id} оказывается true чаще, чем вы ожидаете. 
 
 Вот несколько вопросов, которые я хотел бы задать в обзоре кода: 
 
     
  •  Почему вы используете length() для массива? Он не возвращает длину массива. 
    •  
  •  Разве for my $base (qw( A C G T)) { if ($HoA{$id}[$pos2] eq $base) {... не является неэффективным способом эквивалентного my $base = $HoA{$id}[$pos2];? 
    •  
  • , вычисление для каждого $pos2 выполняется $pos2 + 1 раз, то есть один раз для 0, дважды для [ 1114], ... то есть более поздние позиции получают более высокий балл. 
    •  
  •  одно вычисление для $loscore{$id}[$pos2] является суммой @{ $logodds{$base} }, т.е. база в позиции $pos2 + $pos3 игнорируется для вычисления 
    •  
  • , которое вы пересчитываете $maxscore{$id} во время работы над последовательностями [ 1136] и  затем используют изменяющееся значение в условном 
    •  
  •  (мое предположение) мотиве, который должен быть длиной $width баз, но ваш код хранит только одиночные базы в %maxmot 
    •  
 
 Я делаю обоснованное предположение и предлагаю, чтобы следующий алгоритм был правильным. Я использую 3 последовательности, которые вы дали в предыдущем вопросе. Я также сбрасываю другие 2 хэша, чтобы результаты вычислений стали видны. 
 
 Я позволил себе переписать ваш код, чтобы быть более кратким и понятным. Но вы должны быть в состоянии отследить строки в новом коде до исходного кода. 
 [110] 
 Тестовый прогон: 
 [111] 
 Это выглядит намного ближе к ожидаемому результату. Но, конечно, я мог быть совершенно не уверен в своих догадках ... 
 
 
 Если я правильно понимаю вычисление logscore, тогда оценка за мотив является постоянной и, следовательно, может быть предварительно рассчитана. Что привело бы к следующему более простому подходу: 
 [112] 
 Тестовый прогон: 
 [113] 
 
 Поскольку логическое число по мотивам является константой, список мотивов сортируется по порядку логскор. также будет постоянной. Учитывая этот список, нам нужно будет только найти первый мотив, который соответствует данной последовательности. Следовательно, мы можем применить к этой задаче высоко оптимизированный механизм регулярных выражений. В зависимости от вашего реального размера проблемы это, вероятно, будет более эффективным решением: 
 [114]->[0], qr/
 push() не проблема. После запуска вашего кода становится очевидным, что условное $loscore{$id}[$pos2] == $maxscore{$id} оказывается true чаще, чем вы ожидаете. 
 
 Вот несколько вопросов, которые я хотел бы задать в обзоре кода: 
 
     
  •  Почему вы используете length() для массива? Он не возвращает длину массива. 
    •  
  •  Разве for my $base (qw( A C G T)) { if ($HoA{$id}[$pos2] eq $base) {... не является неэффективным способом эквивалентного my $base = $HoA{$id}[$pos2];? 
    •  
  • , вычисление для каждого $pos2 выполняется $pos2 + 1 раз, то есть один раз для 0, дважды для [ 1114], ... то есть более поздние позиции получают более высокий балл. 
    •  
  •  одно вычисление для $loscore{$id}[$pos2] является суммой @{ $logodds{$base} }, т.е. база в позиции $pos2 + $pos3 игнорируется для вычисления 
    •  
  • , которое вы пересчитываете $maxscore{$id} во время работы над последовательностями [ 1136] и  затем используют изменяющееся значение в условном 
    •  
  •  (мое предположение) мотиве, который должен быть длиной $width баз, но ваш код хранит только одиночные базы в %maxmot 
    •  
 
 Я делаю обоснованное предположение и предлагаю, чтобы следующий алгоритм был правильным. Я использую 3 последовательности, которые вы дали в предыдущем вопросе. Я также сбрасываю другие 2 хэша, чтобы результаты вычислений стали видны. 
 
 Я позволил себе переписать ваш код, чтобы быть более кратким и понятным. Но вы должны быть в состоянии отследить строки в новом коде до исходного кода. 
 [110] 
 Тестовый прогон: 
 [111] 
 Это выглядит намного ближе к ожидаемому результату. Но, конечно, я мог быть совершенно не уверен в своих догадках ... 
 
 
 Если я правильно понимаю вычисление logscore, тогда оценка за мотив является постоянной и, следовательно, может быть предварительно рассчитана. Что привело бы к следующему более простому подходу: 
 [112] 
 Тестовый прогон: 
 [113] 
 
 Поскольку логическое число по мотивам является константой, список мотивов сортируется по порядку логскор. также будет постоянной. Учитывая этот список, нам нужно будет только найти первый мотив, который соответствует данной последовательности. Следовательно, мы можем применить к этой задаче высоко оптимизированный механизм регулярных выражений. В зависимости от вашего реального размера проблемы это, вероятно, будет более эффективным решением: 
 [114]->[0]/] }
    # sort in descending numerical score order
    sort   { $b->[1] cmp $a->[1] }
    # list of [<motif>, <score>] array refs
    pairs %{ $motif_logscore };

#print Data::Dumper->Dump([\@motifs_sorted], [qw(*motifs_sorted)]);

my $id;
my %maxmot;
while (<DATA>) {
    if (/^>(.+)/) {
        $id = $1;
    } else {
        my $sequence = 
 push() не проблема. После запуска вашего кода становится очевидным, что условное $loscore{$id}[$pos2] == $maxscore{$id} оказывается true чаще, чем вы ожидаете. 
 
 Вот несколько вопросов, которые я хотел бы задать в обзоре кода: 
 
     
  •  Почему вы используете length() для массива? Он не возвращает длину массива. 
    •  
  •  Разве for my $base (qw( A C G T)) { if ($HoA{$id}[$pos2] eq $base) {... не является неэффективным способом эквивалентного my $base = $HoA{$id}[$pos2];? 
    •  
  • , вычисление для каждого $pos2 выполняется $pos2 + 1 раз, то есть один раз для 0, дважды для [ 1114], ... то есть более поздние позиции получают более высокий балл. 
    •  
  •  одно вычисление для $loscore{$id}[$pos2] является суммой @{ $logodds{$base} }, т.е. база в позиции $pos2 + $pos3 игнорируется для вычисления 
    •  
  • , которое вы пересчитываете $maxscore{$id} во время работы над последовательностями [ 1136] и  затем используют изменяющееся значение в условном 
    •  
  •  (мое предположение) мотиве, который должен быть длиной $width баз, но ваш код хранит только одиночные базы в %maxmot 
    •  
 
 Я делаю обоснованное предположение и предлагаю, чтобы следующий алгоритм был правильным. Я использую 3 последовательности, которые вы дали в предыдущем вопросе. Я также сбрасываю другие 2 хэша, чтобы результаты вычислений стали видны. 
 
 Я позволил себе переписать ваш код, чтобы быть более кратким и понятным. Но вы должны быть в состоянии отследить строки в новом коде до исходного кода. 
 [110] 
 Тестовый прогон: 
 [111] 
 Это выглядит намного ближе к ожидаемому результату. Но, конечно, я мог быть совершенно не уверен в своих догадках ... 
 
 
 Если я правильно понимаю вычисление logscore, тогда оценка за мотив является постоянной и, следовательно, может быть предварительно рассчитана. Что привело бы к следующему более простому подходу: 
 [112] 
 Тестовый прогон: 
 [113] 
 
 Поскольку логическое число по мотивам является константой, список мотивов сортируется по порядку логскор. также будет постоянной. Учитывая этот список, нам нужно будет только найти первый мотив, который соответствует данной последовательности. Следовательно, мы можем применить к этой задаче высоко оптимизированный механизм регулярных выражений. В зависимости от вашего реального размера проблемы это, вероятно, будет более эффективным решением: 
 [114];
        # find the first pair where the regex matches -> store motif
        $maxmot{$id} = (
            first { ($sequence =~ 
 push() не проблема. После запуска вашего кода становится очевидным, что условное $loscore{$id}[$pos2] == $maxscore{$id} оказывается true чаще, чем вы ожидаете. 
 
 Вот несколько вопросов, которые я хотел бы задать в обзоре кода: 
 
     
  •  Почему вы используете length() для массива? Он не возвращает длину массива. 
    •  
  •  Разве for my $base (qw( A C G T)) { if ($HoA{$id}[$pos2] eq $base) {... не является неэффективным способом эквивалентного my $base = $HoA{$id}[$pos2];? 
    •  
  • , вычисление для каждого $pos2 выполняется $pos2 + 1 раз, то есть один раз для 0, дважды для [ 1114], ... то есть более поздние позиции получают более высокий балл. 
    •  
  •  одно вычисление для $loscore{$id}[$pos2] является суммой @{ $logodds{$base} }, т.е. база в позиции $pos2 + $pos3 игнорируется для вычисления 
    •  
  • , которое вы пересчитываете $maxscore{$id} во время работы над последовательностями [ 1136] и  затем используют изменяющееся значение в условном 
    •  
  •  (мое предположение) мотиве, который должен быть длиной $width баз, но ваш код хранит только одиночные базы в %maxmot 
    •  
 
 Я делаю обоснованное предположение и предлагаю, чтобы следующий алгоритм был правильным. Я использую 3 последовательности, которые вы дали в предыдущем вопросе. Я также сбрасываю другие 2 хэша, чтобы результаты вычислений стали видны. 
 
 Я позволил себе переписать ваш код, чтобы быть более кратким и понятным. Но вы должны быть в состоянии отследить строки в новом коде до исходного кода. 
 [110] 
 Тестовый прогон: 
 [111] 
 Это выглядит намного ближе к ожидаемому результату. Но, конечно, я мог быть совершенно не уверен в своих догадках ... 
 
 
 Если я правильно понимаю вычисление logscore, тогда оценка за мотив является постоянной и, следовательно, может быть предварительно рассчитана. Что привело бы к следующему более простому подходу: 
 [112] 
 Тестовый прогон: 
 [113] 
 
 Поскольку логическое число по мотивам является константой, список мотивов сортируется по порядку логскор. также будет постоянной. Учитывая этот список, нам нужно будет только найти первый мотив, который соответствует данной последовательности. Следовательно, мы можем применить к этой задаче высоко оптимизированный механизм регулярных выражений. В зависимости от вашего реального размера проблемы это, вероятно, будет более эффективным решением: 
 [114]->[1])[0] } @motifs_sorted
        )->[0];
    }
}

print Data::Dumper->Dump([\%maxmot], [qw(*maxmot)]);

exit 0;

__DATA__
>Sequence_1
TCAGAACCAGTTATAAATTTATCATTTCCTTCTCCACTCCT
>Sequence_2
CCCACGCAGCCGCCCTCCTCCCCGGTCACTGACTGGTCCTG
>Sequence_3
TCGACCCTCTGGAACCTATCAGGGACCACAGTCAGCCAGGCAAG

);
        my $max = -1;

        # run a window of length $width over the sequence
        foreach my $index (0..length($sequence) - $width - 1) {

            # extract the motif at $index from sequence
            my $motif = substr($sequence, $index, $width);
            my $score = $motif_score->{$motif};

            # update max score if the motif has a higher score
            if ($score > $max) {
                $max         = $score;
                $maxmot{$id} = $motif;
            }
        }
    }
}

print Data::Dumper->Dump([\%maxmot], [qw(*maxmot)]);

exit 0;

__DATA__
>Sequence_1
TCAGAACCAGTTATAAATTTATCATTTCCTTCTCCACTCCT
>Sequence_2
CCCACGCAGCCGCCCTCCTCCCCGGTCACTGACTGGTCCTG
>Sequence_3
TCGACCCTCTGGAACCTATCAGGGACCACAGTCAGCCAGGCAAG

Тестовый прогон: 

$ perl dummy.pl
%maxmot = (
            'Sequence_2' => 'TCA',
            'Sequence_3' => 'TCG',
            'Sequence_1' => 'TCA'
          );

Поскольку логическое число по мотивам является константой, список мотивов сортируется по порядку логскор. также будет постоянной. Учитывая этот список, нам нужно будет только найти первый мотив, который соответствует данной последовательности. Следовательно, мы можем применить к этой задаче высоко оптимизированный механизм регулярных выражений. В зависимости от вашего реального размера проблемы это, вероятно, будет более эффективным решением: 

#!/usr/bin/perl
use warnings;
use strict;

use List::Util qw(first pairs);
use Data::Dumper;

my $width = 3;

my %logodds = (
    A => [0.1, 0.2, 0.3],
    C => [0.2, 0.5, 0.2],
    G => [0.3, 0.2, 0.4],
    T => [0.4, 0.1, 0.1],
);
my @bases = keys %logodds;

# calculate log score for each motif combination
my $motif_logscore = {'' => 0}; # start with a 0-length motif
foreach my $offset (0..$width - 1) {
    my %score;

    # for all motifs...
    foreach my $prefix (keys %{ $motif_logscore }) {
        my $base_score = $motif_logscore->{$prefix};

        # ... add another base to the motif
        for my $base (@bases) {
            $score{"${prefix}${base}"} = $base_score + $logodds{$base}[$offset];
        }
    }

    # update hash ref to new motif scores
    $motif_logscore = \%score;
}

#print Data::Dumper->Dump([$motif_logscore], [qw(motif_logscore)]);

my @motifs_sorted =
    # list of [<motif>, <regular expression>] array refs
    map    { [
 push() не проблема. После запуска вашего кода становится очевидным, что условное $loscore{$id}[$pos2] == $maxscore{$id} оказывается true чаще, чем вы ожидаете. 
 
 Вот несколько вопросов, которые я хотел бы задать в обзоре кода: 
 
     
  •  Почему вы используете length() для массива? Он не возвращает длину массива. 
    •  
  •  Разве for my $base (qw( A C G T)) { if ($HoA{$id}[$pos2] eq $base) {... не является неэффективным способом эквивалентного my $base = $HoA{$id}[$pos2];? 
    •  
  • , вычисление для каждого $pos2 выполняется $pos2 + 1 раз, то есть один раз для 0, дважды для [ 1114], ... то есть более поздние позиции получают более высокий балл. 
    •  
  •  одно вычисление для $loscore{$id}[$pos2] является суммой @{ $logodds{$base} }, т.е. база в позиции $pos2 + $pos3 игнорируется для вычисления 
    •  
  • , которое вы пересчитываете $maxscore{$id} во время работы над последовательностями [ 1136] и  затем используют изменяющееся значение в условном 
    •  
  •  (мое предположение) мотиве, который должен быть длиной $width баз, но ваш код хранит только одиночные базы в %maxmot 
    •  
 
 Я делаю обоснованное предположение и предлагаю, чтобы следующий алгоритм был правильным. Я использую 3 последовательности, которые вы дали в предыдущем вопросе. Я также сбрасываю другие 2 хэша, чтобы результаты вычислений стали видны. 
 
 Я позволил себе переписать ваш код, чтобы быть более кратким и понятным. Но вы должны быть в состоянии отследить строки в новом коде до исходного кода. 
 [110] 
 Тестовый прогон: 
 [111] 
 Это выглядит намного ближе к ожидаемому результату. Но, конечно, я мог быть совершенно не уверен в своих догадках ... 
 
 
 Если я правильно понимаю вычисление logscore, тогда оценка за мотив является постоянной и, следовательно, может быть предварительно рассчитана. Что привело бы к следующему более простому подходу: 
 [112] 
 Тестовый прогон: 
 [113] 
 
 Поскольку логическое число по мотивам является константой, список мотивов сортируется по порядку логскор. также будет постоянной. Учитывая этот список, нам нужно будет только найти первый мотив, который соответствует данной последовательности. Следовательно, мы можем применить к этой задаче высоко оптимизированный механизм регулярных выражений. В зависимости от вашего реального размера проблемы это, вероятно, будет более эффективным решением: 
 [114]->[0], qr/
 push() не проблема. После запуска вашего кода становится очевидным, что условное $loscore{$id}[$pos2] == $maxscore{$id} оказывается true чаще, чем вы ожидаете. 
 
 Вот несколько вопросов, которые я хотел бы задать в обзоре кода: 
 
     
  •  Почему вы используете length() для массива? Он не возвращает длину массива. 
    •  
  •  Разве for my $base (qw( A C G T)) { if ($HoA{$id}[$pos2] eq $base) {... не является неэффективным способом эквивалентного my $base = $HoA{$id}[$pos2];? 
    •  
  • , вычисление для каждого $pos2 выполняется $pos2 + 1 раз, то есть один раз для 0, дважды для [ 1114], ... то есть более поздние позиции получают более высокий балл. 
    •  
  •  одно вычисление для $loscore{$id}[$pos2] является суммой @{ $logodds{$base} }, т.е. база в позиции $pos2 + $pos3 игнорируется для вычисления 
    •  
  • , которое вы пересчитываете $maxscore{$id} во время работы над последовательностями [ 1136] и  затем используют изменяющееся значение в условном 
    •  
  •  (мое предположение) мотиве, который должен быть длиной $width баз, но ваш код хранит только одиночные базы в %maxmot 
    •  
 
 Я делаю обоснованное предположение и предлагаю, чтобы следующий алгоритм был правильным. Я использую 3 последовательности, которые вы дали в предыдущем вопросе. Я также сбрасываю другие 2 хэша, чтобы результаты вычислений стали видны. 
 
 Я позволил себе переписать ваш код, чтобы быть более кратким и понятным. Но вы должны быть в состоянии отследить строки в новом коде до исходного кода. 
 [110] 
 Тестовый прогон: 
 [111] 
 Это выглядит намного ближе к ожидаемому результату. Но, конечно, я мог быть совершенно не уверен в своих догадках ... 
 
 
 Если я правильно понимаю вычисление logscore, тогда оценка за мотив является постоянной и, следовательно, может быть предварительно рассчитана. Что привело бы к следующему более простому подходу: 
 [112] 
 Тестовый прогон: 
 [113] 
 
 Поскольку логическое число по мотивам является константой, список мотивов сортируется по порядку логскор. также будет постоянной. Учитывая этот список, нам нужно будет только найти первый мотив, который соответствует данной последовательности. Следовательно, мы можем применить к этой задаче высоко оптимизированный механизм регулярных выражений. В зависимости от вашего реального размера проблемы это, вероятно, будет более эффективным решением: 
 [114]->[0]/] }
    # sort in descending numerical score order
    sort   { $b->[1] cmp $a->[1] }
    # list of [<motif>, <score>] array refs
    pairs %{ $motif_logscore };

#print Data::Dumper->Dump([\@motifs_sorted], [qw(*motifs_sorted)]);

my $id;
my %maxmot;
while (<DATA>) {
    if (/^>(.+)/) {
        $id = $1;
    } else {
        my $sequence = 
 push() не проблема. После запуска вашего кода становится очевидным, что условное $loscore{$id}[$pos2] == $maxscore{$id} оказывается true чаще, чем вы ожидаете. 
 
 Вот несколько вопросов, которые я хотел бы задать в обзоре кода: 
 
     
  •  Почему вы используете length() для массива? Он не возвращает длину массива. 
    •  
  •  Разве for my $base (qw( A C G T)) { if ($HoA{$id}[$pos2] eq $base) {... не является неэффективным способом эквивалентного my $base = $HoA{$id}[$pos2];? 
    •  
  • , вычисление для каждого $pos2 выполняется $pos2 + 1 раз, то есть один раз для 0, дважды для [ 1114], ... то есть более поздние позиции получают более высокий балл. 
    •  
  •  одно вычисление для $loscore{$id}[$pos2] является суммой @{ $logodds{$base} }, т.е. база в позиции $pos2 + $pos3 игнорируется для вычисления 
    •  
  • , которое вы пересчитываете $maxscore{$id} во время работы над последовательностями [ 1136] и  затем используют изменяющееся значение в условном 
    •  
  •  (мое предположение) мотиве, который должен быть длиной $width баз, но ваш код хранит только одиночные базы в %maxmot 
    •  
 
 Я делаю обоснованное предположение и предлагаю, чтобы следующий алгоритм был правильным. Я использую 3 последовательности, которые вы дали в предыдущем вопросе. Я также сбрасываю другие 2 хэша, чтобы результаты вычислений стали видны. 
 
 Я позволил себе переписать ваш код, чтобы быть более кратким и понятным. Но вы должны быть в состоянии отследить строки в новом коде до исходного кода. 
 [110] 
 Тестовый прогон: 
 [111] 
 Это выглядит намного ближе к ожидаемому результату. Но, конечно, я мог быть совершенно не уверен в своих догадках ... 
 
 
 Если я правильно понимаю вычисление logscore, тогда оценка за мотив является постоянной и, следовательно, может быть предварительно рассчитана. Что привело бы к следующему более простому подходу: 
 [112] 
 Тестовый прогон: 
 [113] 
 
 Поскольку логическое число по мотивам является константой, список мотивов сортируется по порядку логскор. также будет постоянной. Учитывая этот список, нам нужно будет только найти первый мотив, который соответствует данной последовательности. Следовательно, мы можем применить к этой задаче высоко оптимизированный механизм регулярных выражений. В зависимости от вашего реального размера проблемы это, вероятно, будет более эффективным решением: 
 [114];
        # find the first pair where the regex matches -> store motif
        $maxmot{$id} = (
            first { ($sequence =~ 
 push() не проблема. После запуска вашего кода становится очевидным, что условное $loscore{$id}[$pos2] == $maxscore{$id} оказывается true чаще, чем вы ожидаете. 
 
 Вот несколько вопросов, которые я хотел бы задать в обзоре кода: 
 
     
  •  Почему вы используете length() для массива? Он не возвращает длину массива. 
    •  
  •  Разве for my $base (qw( A C G T)) { if ($HoA{$id}[$pos2] eq $base) {... не является неэффективным способом эквивалентного my $base = $HoA{$id}[$pos2];? 
    •  
  • , вычисление для каждого $pos2 выполняется $pos2 + 1 раз, то есть один раз для 0, дважды для [ 1114], ... то есть более поздние позиции получают более высокий балл. 
    •  
  •  одно вычисление для $loscore{$id}[$pos2] является суммой @{ $logodds{$base} }, т.е. база в позиции $pos2 + $pos3 игнорируется для вычисления 
    •  
  • , которое вы пересчитываете $maxscore{$id} во время работы над последовательностями [ 1136] и  затем используют изменяющееся значение в условном 
    •  
  •  (мое предположение) мотиве, который должен быть длиной $width баз, но ваш код хранит только одиночные базы в %maxmot 
    •  
 
 Я делаю обоснованное предположение и предлагаю, чтобы следующий алгоритм был правильным. Я использую 3 последовательности, которые вы дали в предыдущем вопросе. Я также сбрасываю другие 2 хэша, чтобы результаты вычислений стали видны. 
 
 Я позволил себе переписать ваш код, чтобы быть более кратким и понятным. Но вы должны быть в состоянии отследить строки в новом коде до исходного кода. 
 [110] 
 Тестовый прогон: 
 [111] 
 Это выглядит намного ближе к ожидаемому результату. Но, конечно, я мог быть совершенно не уверен в своих догадках ... 
 
 
 Если я правильно понимаю вычисление logscore, тогда оценка за мотив является постоянной и, следовательно, может быть предварительно рассчитана. Что привело бы к следующему более простому подходу: 
 [112] 
 Тестовый прогон: 
 [113] 
 
 Поскольку логическое число по мотивам является константой, список мотивов сортируется по порядку логскор. также будет постоянной. Учитывая этот список, нам нужно будет только найти первый мотив, который соответствует данной последовательности. Следовательно, мы можем применить к этой задаче высоко оптимизированный механизм регулярных выражений. В зависимости от вашего реального размера проблемы это, вероятно, будет более эффективным решением: 
 [114]->[1])[0] } @motifs_sorted
        )->[0];
    }
}

print Data::Dumper->Dump([\%maxmot], [qw(*maxmot)]);

exit 0;

__DATA__
>Sequence_1
TCAGAACCAGTTATAAATTTATCATTTCCTTCTCCACTCCT
>Sequence_2
CCCACGCAGCCGCCCTCCTCCCCGGTCACTGACTGGTCCTG
>Sequence_3
TCGACCCTCTGGAACCTATCAGGGACCACAGTCAGCCAGGCAAG
0
ответ дан Stefan Becker 30 March 2019 в 22:56
поделиться
Другие вопросы по тегам:

Похожие вопросы: