Разбор текста с фонемами - Javascript

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

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

http://www.dtic.mil/dtic/tr/fulltext/u2/a021929.pdf

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

По сути, начиная с первого символа строки, мы проверяем символы слева и справа от нее.

(для символов в начале слова левый символ будет пустым)

Мы устанавливаем правила, основанные на 44 английских фонемах, и графы, которые подпадают под каждую фонему.

Вот где я получил данные для составления этих правил: http://www.boardman.k12.oh.us/userfiles/363/Phonological%20Awareness/44Phonemes.pdf - которые, как я считаю, отличаются от некоторых правил в статья перед этим.

Вот пример объекта правила, который я создал до сих пор:

        var rules_syntax = {
            cons_b: {case:["b", "bb"], pro: "b"},
            cons_d: {case:["d", "dd", "ed"], pro: "d"},
            cons_f: {case:["f", "ph"], pro: "f"},
            cons_g: {case:["g", "gg"], pro: "g"},
            cons_h: {case:["h"], pro: "h"},
            cons_j: {case:["j", "g", "ge", "dge"], pro: "j"},
            cons_k: {case:["c", "k", "ck", "ch", "cc", "que"], pro: "k"},
            cons_l: {case:["l", "ll"], pro: "l"},
            cons_m: {case:["m", "mm", "mb"], pro: "m"},
            cons_n: {case:["n", "nn", "kn", "gn"], pro: "n"},
            cons_p: {case:["p", "pp"], pro: "p"},
            cons_r: {case:["r", "rr", "wr"], pro: "r"},
            cons_s: {case:["s", "se", "ss", "ci", "ce", "sc"], pro: "s"},
            cons_t: {case:["t", "tt", "ed"], pro: "t"},
            cons_v: {case:["v", "ve"], pro: "v"},
            cons_w: {case:["w"], pro: "w"},
            cons_y: {case:["y", "oi", "io"], pro: "y"},
            cons_z: {case:["z", "zz", "ze", "se", "x"], pro: "z"},

            cons_diag_th:       {case:["th"], pro: "th"},
            cons_diag_th_voice: {case:["th"], pro: "thh"},
            cons_diag_ng:       {case:["ng", "n"], pro: "n"},
            cons_diag_sh:       {case:["sh", "ss", "ch", "ti", "ci"], pro: "sh"},
            cons_diag_ch:       {case:["ch", "tch"], pro: "ch"},
            cons_diag_zh:       {case:["ge", "s"], pro: "zh"},
            cons_diag_wh:       {case:["wh"], pro: "w"},

            shor_vowe_a: {case: ["a", "au"], pro: "a"},
            shor_vowe_e: {case: ["e", "ea"], pro: "e"},
            shor_vowe_i: {case: ["i"], pro: "i"},
            shor_vowe_o: {case: ["o", "a", "au", "aw", "ough"], pro: "o"},
            shor_vowe_u: {case: ["u", "o"], pro: "u"},

        }

Надеюсь, этого достаточно, чтобы вы поняли эту идею.

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

'#' Один или несколько гласных

'*' (звезда) Один или несколько согласных

'*' (круг) Один из B, D, V, G, J, L, M, N, R, W и Z: озвученный согласный

'$' Один согласный, за которым следует E или I

'%' Один из (ER, E, ES, ED, ING, ELY): суффикс

'&' Один из (S, C, G, Z, X, J, CH, SH): сибилянт

'@' Один из (T, S, R, D, L, Z, N, J, TH, CH, SH): согласный, влияющий на звук следующего длинного u (см. Правило и мул)

'^' Один согласный

'+' Один из (E, I, Y): передняя гласная

':' Нуль или более согласных

Мой первый вопрос:

Кто-нибудь считает, что это адекватный подход к этим правилам? Предложения, пожалуйста.

Двигаясь дальше,

Как только мы узнаем, что такое первичный символ, а также персонаж слева и справа, мы проверяем все правила, применимые к этой группе символов. В первой опубликованной статье объясняется

Алгоритм перевода сканирует входной текст слева направо и для каждого проверенного символа последовательно ищет правила, относящиеся к этому символу, до тех пор, пока не найдет тот, чья левая сторона соответствует тексту в правильной позиции.

Вот где я сейчас застрял. У меня есть моя настройка кода, чтобы он мог собирать все правила, к которым применяется группа символов, но как только у меня есть это, я не уверен, как выбрать, какая из них является правильной фонемой. Например, я использовал слово «осторожный» в качестве примера. комбинация «au» в этом слове подпадает под правило «a», а также правило «o».

это создало бы звук, как в смехе, или это создало бы звуки o, как в обучении. Очевидно, что o, как в преподаваемом, будет правильным ответом, но как я могу сделать код для этого?

как я могу определить, какая фонема правильна здесь?

Является ли это тем, что второй набор правил, который я еще не использовал, вступает в игру? Если да, то как вы предлагаете использовать эти правила для устранения / сужения применяемых правил?

Некоторое время я сидел на этой концепции, я не профессионал, но я хотел бы вернуть чей-то канал. Если вам нужна дополнительная информация, пожалуйста, дайте мне знать. Вот код, который у меня есть:

    var test01 = function(word)
    {
        var arr = [];
        var arr2 = [];

        //for every letter in the word
        for(var x = 0; x < word.length; x ++)
        {
            //grab the letter
            var index = word[x];
            var pert = [];
            //push the letter to an array
            arr.push(index);

            //create an object which holds the neighboring letters
            var pro = new Object();
            pro.left = word[x - 1];
            pro.org = index;
            pro.right = word[x + 1];
            //store this object in an array
            arr2.push(pro);


            //check to see if any spaces exist (undefined) and replace them with a ""
            for(b in pro)
            {
                if(!pro[b])
                {
                    pro[b] = "";
                }
            }

            //loop through each letter object
            for(var y = 0; y < arr2.length; y ++)
            {
                var letter = arr2[y];
                letter.rules = [];

                //loop through each rule that exists
                for (z in rules_syntax)
                {
                    var rule = rules_syntax[z];

                    //for each rule, loop through its graphemes
                    for(var a = 0; a < rule.case.length; a ++)
                    {

                        var grapheme = rule.case[a];
                        //combine the original letter, and the letter to the left
                        var letterCheck = letter.left + letter.org;

                        //check if the above combo (left + original) exists in the list of graphemes
                        if(letterCheck === grapheme)
                        {
                            //here is where I would put any other conditions to check for any other rules.
                            pert.push(rule.pro);
                            letter.rules.push(rule.pro);
                        } 

                        if(letter.org === grapheme)
                        {
                            //here is where I would put any other conditions to check for any other rules.
                            pert.push(rule.pro);
                            letter.rules.push(rule.pro);

                        } 
                    }
                }
            }

            console.log(pert);

        }
    }

    test01("cautious");

И вот последняя строка вывода

(16) ["k", "k", "a", "o", "a", "o", "u", "t", "sh", "i", "y", "o", "u", "u", "s", "zh"]

Любые ответы приветствуются.

Спасибо.

javascript,string,algorithm,sorting,parsing,

1

Ответов: 1


1

Я думаю, что вы неправильно читаете таблицу 2 из статьи:

'#' Один или несколько гласных

'*' (звезда) Один или несколько согласных

'*' (круг) Один из B, D, V, G, J, L, M, N, R, W и Z: озвученный согласный

'$' Один согласный, за которым следует E или I

'%' Один из (ER, E, ES, ED, ING, ELY): суффикс

'&' Один из (S, C, G, Z, X, J, CH, SH): сибилянт

'@' Один из (T, S, R, D, L, Z, N, J, TH, CH, SH): согласный, влияющий на звук следующего длинного u (см. Правило и мул)

'^' Один согласный

'+' Один из (E, I, Y): передняя гласная

':' Нуль или более согласных

Подпись для этой таблицы гласит:

Специальные символы, появляющиеся в Правилах перевода с английского на IPA

Другими словами, это не правила, а скорее описания обозначений.

Настоящие правила начинаются на странице 51 статьи. Поскольку я понимаю алгоритм, он начнется с разбора «t» и перейдите в раздел TRULE.ENG (стр. 58). Единственное правило, которое там применяется [T]=/T/. Затем он разбирает «a» и смотрит в ARULE.ENG (стр. 51). Сканирование правил там, первое, что я вижу, что это применимо [AU]=/AO/, дает вам «au», как в «обученном». Оттуда он переходит в список GRULE.ENG и производит / /для «gh», а затем /T/снова воспроизводит окончательный «t».

Что касается «смеха», из правил я бы сказал, что это произнесет «au», как в «обученном». И поскольку это правило #[GH]=/ /, не будет другого звука. «Смех», вероятно, будет звучать как «закон».

JavaScript, строка, алгоритм, сортировка, анализ,
Похожие вопросы