Вопросы Теги

Как часто Вы переоцениваете и обновляете свою среду разработки и dev. инструменты? [закрытый]

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
5
задан Bill the Lizard 5 August 2012 в 23:40
поделиться

6 ответов

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

1
ответ дан 18 December 2019 в 13:19
поделиться

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

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

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

- Adam

4
ответ дан 18 December 2019 в 13:19
поделиться

Для меня обновления событийно-ориентированы, не управляемый таймером. Я держу ухо к основанию для новых инструментов (библиотеки, IDE, инструменты CASE, и т.д.) и оцениваю их, поскольку они обнаруживаются на моем радаре.

Работая с технологиями Microsoft, я перемещаюсь в новейшую версию, если нет никакого неопровержимого довода, сдерживающего меня. С OSS я использую то, что я знаю, если нет что-то принуждения, подталкивающего меня.

3
ответ дан 18 December 2019 в 13:19
поделиться

На работе мы обновляем инструмент, когда наша версия достигает конца времени жизни поддержки. Мы обновляем до следующей более старой версии.

Дома, я обновляю, как только я могу найти копию новой вещи бесплатной (т.е. некоторые соглашения, куда посещение 3 вебкастов отправит Вам копию vs2008 выпуска станд., групп пользователей, и т.д.).

2
ответ дан 18 December 2019 в 13:19
поделиться

IDE. Я склонен придерживаться одного, я знаю, будет расти и поддерживать мой язык. В моей dev среде это - энергия. Это активно разрабатывается и имеет много много сценариев (своего рода как плагины), а также документация для DIY. Также склонность IDE занимает время, и становление хорошим в ней, с помощью нее эффективно занимает больше времени.

Управление версиями. Я пытаюсь остаться чуть ниже новейшего. Преимущества новых возможностей важны. Например, Подверсия 1.4, только поддерживаемое элементарное слияние. Подверсия 1.5 перестроила их систему слияния и добавила новые опции.

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

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

Надеюсь, что мои 0,02$ были полезны.

3
ответ дан 18 December 2019 в 13:19
поделиться

IDEs - Это может быть сложно, но я прошел через несколько различных продвижений за эти годы. Иногда нахождение в проекте или определенная функция может спровоцировать обновление. Например, кто-то реализовал возможность с помощью LINQ, так что то, что было проектом ASP.Net 2.0, превратилось в проект 3.5 за одну ночь. Иногда это просто то, что используется в настоящее время. Дело в том, что изменение может повлиять на целую команду, так что это не то изменение, которое нужно сделать легкомысленно.

Инструменты отслеживания ошибок - Это также относится к той стране централизованных вещей, которыми нужно тщательно управлять. Так как это инструмент контроля качества, я надеюсь, что у них есть свои собственные политики того, как часто искать обновления и когда их устанавливать, так как иногда новые возможности могут быть очень клёвыми. Эквивалентом команды разработчиков будет то, когда обновлять вики.

Контроль версий - они управляются индивидуально, так как большинство из нас использует Tortoise SVN, так что у каждого из нас есть локальная копия клиента. Так что обновления делаются, когда кто-то хочет это сделать. Лично мне нравится быть в курсе всех событий.

OS - Хотя частью этого можно управлять на уровне отдела, существует достаточно различных частей для обновления, которые иногда я запускаю обновление самостоятельно. Я не уверен, когда мы перейдем на Windows 7, так как я знаю, что мы не собираемся на Vista, и я думаю, что в какой-то момент мы выйдем из XP, так как я работаю на XP уже около 5 лет, как до этого я работал на Windows 2000 Professional в течение нескольких лет, а до этого на NT 4.0.

PC - Существует политика, согласно которой каждые 3 года мы получаем новые машины, как мне кажется. Когда я начинал там, где нахожусь сейчас, я был на коробке P4, так что апгрейд до двухъядерной коробки был очень хорошим, так же как и хороший прирост оперативной памяти с 2 ГБ до 4 ГБ.

1
ответ дан 18 December 2019 в 13:19
поделиться
Другие вопросы по тегам:

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