Voice recognition with AVR Опции

[Johan Krava]

Anybody has experience with voice recognition? I am looking for some code library and examples for AVR. All ideas are welcome. Thanks.

[Rst7]

Ну что, вычисление мощностей с нормированием - это плюс 3200 тактов. Там, конечно, можно с бубном поплясать, но особо меньше не будет.

Итого пока 5200 тактов. На очереди - сравнение.

[Огурцов]

Ну что, вычисление мощностей с нормированием - это плюс 3200 тактов.

Не понимаю, как вы считаете. Если даже преположить, что после, например, ДПФ будет два слова на выборку вместо одного, то мощность - это два умножения и сложение, т.е. где-то 5 тактов без пересылок для 8 бит, ну или 50 для 16 бит. Нормаирование - одно сравнение и одно умножение. Пусть еще столько же. Как удалось увличить эту цифру в 30 раз ?

Так что, слабо?

На слабо меня не взять. А вот перспективной идеей - можно.


Так что там, есть уже какие наработки ? Или выложить слабо (с) ?

[Rst7]

Не понимаю, как вы считаете. Если даже преположить, что после, например, ДПФ будет два слова на выборку вместо одного, то мощность - это два умножения и сложение, т.е. где-то 5 тактов без пересылок для 8 бит, ну или 50 для 16 бит. Нормаирование - одно сравнение и одно умножение. Пусть еще столько же. Как удалось увличить эту цифру в 30 раз ?

Я не считаю. Это результат замера. А вот как Вам удалось получить "30 раз" я не знаю. Даже Ваша прикидка дает (50+50)*15=1500, и еще там одно деление 32 на 32, это 500 тактов, грубо говоря, и еще 15 квадратных корней, у меня получилось 56*15=840.

Итого, 3340, даже больше, чем мой код

Другое дело, там прилично накладных расходов в связи с тем, что данные для каждой частоты расположены на выходе ДПХ не очень удачно для простой обработки. Но это, я думаю, можно будет устранить. Однако, больших чудес ждать не приходится. Ну и с другой стороны, эта часть кода имеет сложность O(n), так что если вдруг будем увеличивать количество точек, общий вес этой части уменьшится.

На слабо меня не взять. А вот перспективной идеей - можно.

Зачем Вам идеи? Вы же все знаете и все умеете?

Так что там, есть уже какие наработки ? Или выложить слабо (с) ?

Уже готовитесь спереть? Пока выложить могу только эти две функции. Они Вам нужны?

[Огурцов]

8x

Код

:           C = A * A + B * B;
+00000069:   0288        MULS    R24,R24          Multiply signed
+0000006A:   0190        MOVW    R18,R0           Copy register pair
+0000006B:   2411        CLR     R1               Clear Register
+0000006C:   01C9        MOVW    R24,R18          Copy register pair
13:       }
+0000006D:   0F82        ADD     R24,R18          Add without carry
+0000006E:   1F93        ADC     R25,R19          Add with carry

Я насчитал 7

16x

Код

          C = A * A + B * B;
+00000069:   2744        CLR     R20              Clear Register
+0000006A:   FD37        SBRC    R19,7            Skip if bit in register cleared
+0000006B:   9540        COM     R20              One's complement
+0000006C:   2F54        MOV     R21,R20          Copy register
+0000006D:   01CA        MOVW    R24,R20          Copy register pair
+0000006E:   01B9        MOVW    R22,R18          Copy register pair
+0000006F:   940E0085    CALL    0x00000085       Call subroutine
+00000071:   017B        MOVW    R14,R22          Copy register pair
+00000072:   018C        MOVW    R16,R24          Copy register pair
+00000073:   019E        MOVW    R18,R28          Copy register pair
+00000074:   2744        CLR     R20              Clear Register
+00000075:   FD37        SBRC    R19,7            Skip if bit in register cleared
+00000076:   9540        COM     R20              One's complement
+00000077:   2F54        MOV     R21,R20          Copy register
+00000078:   01CA        MOVW    R24,R20          Copy register pair
+00000079:   01B9        MOVW    R22,R18          Copy register pair
+0000007A:   940E0085    CALL    0x00000085       Call subroutine
+0000007C:   01DC        MOVW    R26,R24          Copy register pair
+0000007D:   01CB        MOVW    R24,R22          Copy register pair
+0000007E:   0EE8        ADD     R14,R24          Add without carry
+0000007F:   1EF9        ADC     R15,R25          Add with carry
+00000080:   1F0A        ADC     R16,R26          Add with carry
+00000081:   1F1B        ADC     R17,R27          Add with carry
13:       }
+00000082:   01C7        MOVW    R24,R14          Copy register pair

+00000083:   940C00A4    JMP     0x000000A4       Jump

+00000085:   9F62        MUL     R22,R18          Multiply unsigned
+00000086:   01D0        MOVW    R26,R0           Copy register pair
+00000087:   9F73        MUL     R23,R19          Multiply unsigned
+00000088:   01F0        MOVW    R30,R0           Copy register pair
+00000089:   9F82        MUL     R24,R18          Multiply unsigned
+0000008A:   0DE0        ADD     R30,R0           Add without carry
+0000008B:   1DF1        ADC     R31,R1           Add with carry
+0000008C:   9F64        MUL     R22,R20          Multiply unsigned
+0000008D:   0DE0        ADD     R30,R0           Add without carry
+0000008E:   1DF1        ADC     R31,R1           Add with carry
+0000008F:   9F92        MUL     R25,R18          Multiply unsigned
+00000090:   0DF0        ADD     R31,R0           Add without carry
+00000091:   9F83        MUL     R24,R19          Multiply unsigned
+00000092:   0DF0        ADD     R31,R0           Add without carry
+00000093:   9F74        MUL     R23,R20          Multiply unsigned
+00000094:   0DF0        ADD     R31,R0           Add without carry
+00000095:   9F65        MUL     R22,R21          Multiply unsigned
+00000096:   0DF0        ADD     R31,R0           Add without carry
+00000097:   2799        CLR     R25              Clear Register
+00000098:   9F72        MUL     R23,R18          Multiply unsigned
+00000099:   0DB0        ADD     R27,R0           Add without carry
+0000009A:   1DE1        ADC     R30,R1           Add with carry
+0000009B:   1FF9        ADC     R31,R25          Add with carry
+0000009C:   9F63        MUL     R22,R19          Multiply unsigned
+0000009D:   0DB0        ADD     R27,R0           Add without carry
+0000009E:   1DE1        ADC     R30,R1           Add with carry
+0000009F:   1FF9        ADC     R31,R25          Add with carry
+000000A0:   01BD        MOVW    R22,R26          Copy register pair
+000000A1:   01CF        MOVW    R24,R30          Copy register pair
+000000A2:   2411        CLR     R1               Clear Register
+000000A3:   9508        RET                      Subroutine return

Где-то 108.

и еще там одно деление 32 на 32, это 500 тактов

Да деление, но оно одно на весь результат. Сколько там, на 8 отсчетов, 16 или 32 - сколько берем, еще не определились. Если брать много, то несколько фонем может объединиться, если брать мало, число "фонем" может возрасти, т.к. вроде бы спектр некоторых фонем динамический, и фонема получится состоящая как бы из нескольких частей. Несмотря на свое определение.

и еще 15 квадратных корней, у меня получилось 56*15=840.

А зачем корни ? Какая разница, сравнивать значение или его корень ? И даже с корнем - тоже один корень на выборку.

Уже готовитесь спереть?

Нет, пока думаю, скачивать файл или не скачивать )

Пока выложить могу только эти две функции. Они Вам нужны?

Я ж не один здесь. Надеюсь. Не подойдет мне, может кому другому подойдет.

Сообщение отредактировал Огурцов - Oct 23 2008, 19:27

[defunct]

8x

Код

:           C = A * A + B * B;
+00000069:   0288        MULS    R24,R24          Multiply signed
...

Я насчитал 7

Чипуха какая-то. Очевидно что для двух * должно быть две команды MUL.
Подозреваю такая же чипуха у вас и в 16x. Теперь понятно откуда у вас берется порядок на 16x.

[Огурцов]

Чипуха какая-то. Очевидно что для двух * должно быть две команды MUL.

Действительно, косячище. Это мы с другом оптимизатором наоптимизили.

Код

+00000069:   8199        LDD     R25,Y+1          Load indirect with displacement
+0000006A:   8189        LDD     R24,Y+1          Load indirect with displacement
+0000006B:   0298        MULS    R25,R24          Multiply signed
+0000006C:   0190        MOVW    R18,R0           Copy register pair
+0000006D:   2411        CLR     R1               Clear Register
+0000006E:   819A        LDD     R25,Y+2          Load indirect with displacement
+0000006F:   818A        LDD     R24,Y+2          Load indirect with displacement
+00000070:   0298        MULS    R25,R24          Multiply signed
+00000071:   01C0        MOVW    R24,R0           Copy register pair
+00000072:   2411        CLR     R1               Clear Register
+00000073:   0F28        ADD     R18,R24          Add without carry
+00000074:   1F39        ADC     R19,R25          Add with carry
+00000075:   833C        STD     Y+4,R19          Store indirect with displacement
+00000076:   832B        STD     Y+3,R18          Store indirect with displacement

21, из них 12 на загрузку/выгрузку. Итого 9 вместо 7.

Подозреваю такая же чипуха у вас и в 16x.

Для 16x несколько лучше, в процентном оношении - стало 151, из них 16 на загрузку/выгрузку.


С другой стороны вот это

Код

LDD     R25,Y+1          Load indirect with displacement
LDD     R24,Y+1

можно будет заменить на

Код

LDD     R25,Y+1          Load indirect with displacement
MOV     R24,R25

И вообще, с оптимизацие того же ДПФ оптимизатор скорее всего не справится...

Сообщение отредактировал Огурцов - Oct 23 2008, 20:20

[defunct]

Для 16x несколько лучше, в процентном оношении - стало 151, из них 16 на загрузку/выгрузку.

Моя цифра - 38 (32-х битный результат):

Код

.def  AL = R24
.def  AH = R25

.def  z_reg = R2

.def u32_b0 = R18
.def u32_b1 = R19
.def u32_b2 = R20
.def u32_b3 = R21

; --> ax 16 bit operand
; <-- 32 bit result u32_xx
.MACRO sqr_ax
    mul  ah, ah
    movw u32_b3: u32_b2, r1:r0

    mul  al, al
    movw u32_b1: u32_b0, r1:r0

    mul  ah, al

    add  u32_b1, r0  
    adc  u32_b2, r1
    adc  u32_b3, z_reg

    add  u32_b1, r0
    adc  u32_b2, r1
    adc  u32_b3, z_reg
.endmacro

.cseg
    ldi  AL, Low(RAMEND)
    out  SPL, AL
    ldi  AL, High(RAMEND)
    out  SPH, AL

    clr  z_reg


; начинаем счет таков отсюда
;-----> C = A * A + B * B   (a=1234, b=567, c should be 1844245)
    ldi  al, Low(1234)
    ldi  ah, High(1234)
    sqr_ax              ; A * A

    movw r5:r4, u32_b1:u32_b0
    movw r7:r6, u32_b3:u32_b2

    ldi  al, Low(567)
    ldi  ah, High(567)
    sqr_ax              ; B * B

    add  u32_b0, r4
    adc  u32_b1, r5
    adc  u32_b2, r6
    adc  u32_b3, r7     ; A * A + B * B

Результат в u32_xx (b3 - MSB, b0 - LSB).

[=GM=]

Моя цифра - 44 (32-х битный результат)

Вроде бы надо перемножать знаковые 16-битные числа, разве нет?

[defunct]

Вроде бы надо перемножать знаковые 16-битные числа, разве нет?

Уже немного оптимизировал, из 44-х тактов осталось 38.
знаковые/беззнаковые не суть важно. (при возведении в квадрат всегда получаем положительное число, поэтому отрицательные операнды можно предварительно преобразовать в положительные, рез-тат не изменится, а по тактам такое преобразование - чепуха, никак не > 100).

[=GM=]

Уже немного оптимизировал, из 44-х тактов осталось 38.
знаковые/беззнаковые не суть важно. (при возведении в квадрат всегда получаем положительное число, поэтому отрицательные операнды можно предварительно преобразовать в положительные, рез-тат не изменится, а по тактам такое преобразование - чепуха, никак не > 100).

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

Кстати, спасибо, вы дали ответ на мой вопрос, насколько в данном случае авр уступает дсп по скорости (боюсь, какбы друит не набежал(:-)) - примерно в 38+38 = 76 раз по тактам, а если учесть знаковую конверсию, то вгрубе будет 100.

[defunct]

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

Почему два? Положительных составляющих типа не бывает? ;>

Возможно оптимальнее будет использовать комбинацию MUL для младших байтов и MULS для старших.

Для младших надо сделать операцию NEG. иначе такое умножение ни к чему хорошему не приведет.

учесть знаковую конверсию, то вгрубе будет 100.

Если преобразовывать сразу при расчете, то это сведется к доп. 3-м тактам в худшем случае (к двум в лучшем) на каждую составлющую:

Код

  brpl __store
  com  RxH
  neg  RxL
__store:

в среднем +5 тактов к 38-ми

[=GM=]

Почему два? Положительных составляющих типа не бывает?

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

Загрузку считать надо обязательно, поскольку множители не константы. (Подправил цифры, почему-то считал, что movw выполняется за два такта.)

Вот мой вариант перемножения (a1,a0)*(a1,a0)+(b1,b0)*(b1,b0)->(c3,c2,c1,c0), сделанный на базе ваших макросов, просто отказался от регистров промежуточного хранения r7-r4

Код

    ld    a1,y+
    ld    a0,y+
    ld    b1,y+
    ld    b0,y+

    mul    a1,a1
    movw    c2,r0
    mul    a0,a0
    movw    c0,r0
    mul    a1,a0
    add    c1,r0
    adc    c2,r1
    adc    c3,r2
    add    c1,r0
    adc    c2,r1
    adc    c3,r2

    mul    b1,b1
    add    c2,r0
    adc    c3,r1
    mul    b0,b0
    add    c0,r0
    adc    c1,r1
    adc    c2,r2
    adc    c3,r2
    mul    b1,b0
    add    c1,r0
    adc    c2,r1
    adc    c3,r2
    add    c1,r0
    adc    c2,r1
    adc    c3,r2

Итого 32 такта на вычисления, всего, с загрузкой множителей из рамы, получилось 40 тактов. Ещё можно сэкономить регистры b1, b0, если делать загрузку второго множителя в регистры (a1,a0) непосредственно перед вычислением (b1,b0)*(b1,b0). (Третий раз корректирую, спасибо rst7)

Если преобразовывать сразу при расчете, то это сведется к доп. 3-м тактам в худшем случае (к двум в лучшем) на каждую составлющую:

Код

  brpl __store
  com  RxH
  neg  RxL
__store:

Хм, загрузка множителя не даёт флагов, надо делать тестирование, а это доптакты. Вы привели неполный код для конверсии. В среднем у вас будет будет 6 тактов, т.е. для вашего кода в среднем будет 38+6=44 на вычисления плюс 8 на загрузку, всего 52.

[defunct]

Два, потому что есть действительная и мнимая составляющая спектра.

И они обе отрицательные всегда?

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

AVR-студией, код приведен. Загрузка операндов там есть, правда не из RAM а из флеш, но по скорости одинаково.

Хм, загрузка множителя не даёт флагов, надо делать тестирование, а это доптакты. Вы привели неполный код для конверсии. В среднем у вас будет будет 6 тактов, т.е. для вашего кода в среднем будет 40+6=46 на вычисления плюс 8 на загрузку, всего 54.

Нет не будет там 6 тактов в среднем, в среднем будет 5, как я и написал, из расчета что одна из составляющих уже положительная.
Вчитайтесь в то что я написал. Преобразовывать сразу при расчете. - расчитали спектральную составляющую и перед сохранением (пока еще флаги известны) сделали модуль. Вы же предполагаете что модуль будет считаться после загрузки.

i.e.:

1. расчет составляющей
<-- я предлагаю преобразование делать сразу здесь
2. сохранение в массив
3. загрузка из массива
<-- вы предполагаете преобразование делать здесь
4. вычисление мощности