एक शब्द में शब्दांश का पता लगाना

Question

मुझे एक शब्द में शब्दांश का पता लगाने के लिए एक काफी कुशल तरीका खोजने की आवश्यकता है। उदाहरण के लिए,

अदृश्य -> ​​in-vi-sib-le

कुछ नियम नियम हैं जिनका उपयोग किया जा सकता है:

वी सीवी वीसी सीवीसी सीसीवी सीसीसीवी सीवीसीसी

* जहाँ V एक स्वर है और C एक व्यंजन है। उदाहरण के लिए,

उच्चारण (5 Pro-nun-ci-a-tion; CV-CVC-CV-V-CVC)

मैंने कुछ तरीकों की कोशिश की है, जिनमें से रेगेक्स का उपयोग कर रहे थे (जो सिलेबल्स गिनने के लिए केवल तभी मदद करता है) या हार्ड कोडेड रूल डेफिनिशन (एक ब्रूट फोर्स अप्रोच जो बहुत अक्षम साबित होती है) और अंत में एक परिमित स्टेट ऑटोमेटा (जो किया था) का उपयोग कर रहा है उपयोगी कुछ भी परिणाम नहीं)।

मेरे आवेदन का उद्देश्य किसी दिए गए भाषा में सभी शब्दांशों का शब्दकोश बनाना है। इस शब्दकोश का उपयोग बाद में वर्तनी जांच अनुप्रयोगों (बायेसियन क्लासिफायर का उपयोग करके) और भाषण संश्लेषण के लिए पाठ के लिए किया जाएगा।

मैं सराहना करूंगा अगर कोई मुझे अपने पिछले दृष्टिकोणों के अलावा इस समस्या को हल करने के लिए वैकल्पिक तरीके से सुझाव दे सके।

मैं जावा में काम करता हूं, लेकिन C / C ++, C #, पायथन, पर्ल ... में कोई भी टिप मेरे लिए काम करेगा।

Comments

क्या आप वास्तव में एक शब्द में वास्तविक विभाजन अंक या सिलेबल्स की संख्या चाहते हैं? यदि उत्तरार्द्ध, पाठ-से-भाषण शब्दकोश में शब्दों को देखने पर विचार करें और स्वरों को ध्वनित करने वाले स्वरों को गिनें।

— एड्रियन मैक्कार्थी

सबसे कुशल तरीका (कम्प्यूटेशन-वार; स्टोरेज-वार नहीं), मुझे लगता है कि सिर्फ पायथन डिक्शनरी होगी जिसमें शब्दों की कुंजी होगी और मूल्यों के रूप में शब्दांशों की संख्या होगी। हालाँकि, आपको अभी भी उन शब्दों के लिए कमबैक की आवश्यकता होगी, जिन्होंने इसे शब्दकोश में नहीं बनाया है। मुझे पता है अगर तुम कभी इस तरह के एक शब्दकोश मिल!

— ब्रूट्सफोरोज़ुथ्रैक्स

Answer 1

TeX दृष्टिकोण के बारे में इस समस्या के लिए हाइफ़नेशन के प्रयोजनों के लिए पढ़ें। कॉम-पुट-एर द्वारा विशेष रूप से फ्रैंक लियांग के शोध प्रबंध शब्द हाइ-फिन-ए-टायन को देखें । उनका एल्गोरिथ्म बहुत सटीक है, और फिर उन मामलों के लिए एक छोटा अपवाद शब्दकोश शामिल है जहां एल्गोरिदम काम नहीं करता है।

Comments

मुझे पसंद है कि आप इस विषय पर एक शोध प्रबंध का हवाला देते हैं, यह मूल पोस्टर के लिए थोड़ा संकेत है कि यह एक आसान सवाल नहीं हो सकता है।

— कर्ल

हां, मुझे पता है कि यह एक आसान सवाल नहीं है, हालांकि मैंने इस पर ज्यादा काम नहीं किया है। मैंने समस्या को कम करके आंका, हालांकि मुझे लगा कि मैं अपने ऐप के अन्य हिस्सों पर काम करूंगा, और बाद में इस 'सरल' समस्या पर लौटूंगा। मूर्खतापूर्ण मुझे :)

— user50705

मैंने डिसर्ट पेपर को पढ़ा, और इसे बहुत उपयोगी पाया। दृष्टिकोण के साथ समस्या यह थी कि मेरे पास अल्बानियाई भाषा के लिए कोई पैटर्न नहीं था, हालांकि मुझे कुछ उपकरण मिले जो उन पैटर्न को उत्पन्न कर सकते थे। वैसे भी, मेरे उद्देश्य के लिए मैंने एक नियम आधारित ऐप लिखा था, जिसने इस समस्या को हल किया ...

— user50705

ध्यान दें कि TeX एल्गोरिथ्म वैध हाइफ़नेशन बिंदुओं को खोजने के लिए है, जो शब्दांश विभाजनों के समान नहीं है। यह सच है कि हाइफ़नेशन अंक शब्दांश डिवीजनों पर आते हैं, लेकिन सभी शब्दांश विभाजन मान्य हाइफ़नेशन पॉइंट नहीं हैं। उदाहरण के लिए, हाइफ़न (आमतौर पर) एक अक्षर या शब्द के दो में से दो के भीतर उपयोग नहीं किया जाता है। मेरा यह भी मानना ​​है कि TeX पैटर्न को झूठी सकारात्मक के लिए झूठी नकारात्मक व्यापार करने के लिए तैयार किया गया था (कभी भी ऐसा हाइफ़न न रखें जहाँ यह नहीं है, भले ही इसका मतलब है कि कुछ वैध हाइफ़नेशन अवसरों को याद रखना)।

— एड्रियन मैक्कार्थी

मुझे विश्वास नहीं है कि हाइफ़नेशन भी इसका जवाब है।

— इजेक्वियल

Answer 2

मैं एक ही चीज़ की तलाश में इस पृष्ठ पर ठोकर खा गया, और यहाँ लिआंग पेपर के कुछ कार्यान्वयन पाए गए: https://github.com/mnater/hyphenator या उत्तराधिकारी: https://github.com/mnater/Hyphotopoly

यह तब तक है जब तक आप वह प्रकार न हों जो गैर-अद्वितीय समस्या के लिए स्वतंत्र रूप से उपलब्ध कोड को अपनाने के बजाय 60 पृष्ठ की थीसिस पढ़ने में आनंद लेता हो। :)

Comments

सहमत - एक मौजूदा

— निहितार्थ का

Answer 3

यहाँ NLTK का उपयोग कर एक समाधान है :

from nltk.corpus import cmudict
d = cmudict.dict()
def nsyl(word):
  return [len(list(y for y in x if y[-1].isdigit())) for x in d[word.lower()]] 

Comments

अरे धन्यवाद छोटे बच्चे में त्रुटि होना चाहिए फ़ंक्शन डी nsyl (शब्द): वापसी [l (लिस्ट में y के लिए x यदि y [-1] .isdigit ()) x में d के लिए x [word.lower ()] ]

— ११

आप उन शब्दों के लिए एक वापसी के रूप में क्या सुझाव देंगे जो उस कॉर्पस में नहीं हैं?

— डैन गेल

@Pureferret cmudict उत्तर अमेरिकी अंग्रेजी शब्दों के लिए एक उच्चारण शब्दकोश है। यह शब्दों को फोनेम्स में विभाजित करता है, जो सिलेबल्स से छोटे होते हैं (उदाहरण के लिए 'कैट' शब्द को तीन स्वरों में विभाजित किया गया है: के - एई - टी)। लेकिन स्वरों में एक "तनाव मार्कर" भी होता है: शब्द के उच्चारण के आधार पर या तो 0, 1, या 2, (इसलिए 'cat' में AE AE बन जाता है)। उत्तर में कोड तनाव मार्करों और इसलिए स्वरों की संख्या को गिनता है - जो प्रभावी रूप से शब्दांशों की संख्या देता है (ध्यान दें कि ओपी के उदाहरणों में प्रत्येक शब्दांश में ठीक एक स्वर है)।

— billy_chapters

यह सिलेबल्स की संख्या लौटाता है, सिलेबस का नहीं।

— एडम माइकल वुड

Answer 4

मैं एक प्रोग्राम के लिए इस समस्या से निपटने की कोशिश कर रहा हूं जो टेक्स्ट के ब्लॉक के flesch-kincaid और flesch रीडिंग स्कोर की गणना करेगा। मेरा एल्गोरिथ्म इस वेबसाइट पर मुझे जो मिला है उसका उपयोग करता है: http://www.howmanysyllables.com/howtocountsyllables.html और यह यथोचित रूप से बंद हो जाता है। यह अभी भी अदृश्य और हाइफ़नेशन जैसे जटिल शब्दों पर मुसीबत है, लेकिन मैंने पाया है कि यह मेरे उद्देश्यों के लिए बॉलपार्क में मिलता है।

इसे लागू करना आसान होने का उल्टा है। मैंने पाया कि "es" शब्दांश हो सकता है या नहीं। यह एक जुआ है, लेकिन मैंने अपने एल्गोरिथ्म में ईएस को हटाने का फैसला किया।

private int CountSyllables(string word)
    {
        char[] vowels = { 'a', 'e', 'i', 'o', 'u', 'y' };
        string currentWord = word;
        int numVowels = 0;
        bool lastWasVowel = false;
        foreach (char wc in currentWord)
        {
            bool foundVowel = false;
            foreach (char v in vowels)
            {
                //don't count diphthongs
                if (v == wc && lastWasVowel)
                {
                    foundVowel = true;
                    lastWasVowel = true;
                    break;
                }
                else if (v == wc && !lastWasVowel)
                {
                    numVowels++;
                    foundVowel = true;
                    lastWasVowel = true;
                    break;
                }
            }

            //if full cycle and no vowel found, set lastWasVowel to false;
            if (!foundVowel)
                lastWasVowel = false;
        }
        //remove es, it's _usually? silent
        if (currentWord.Length > 2 && 
            currentWord.Substring(currentWord.Length - 2) == "es")
            numVowels--;
        // remove silent e
        else if (currentWord.Length > 1 &&
            currentWord.Substring(currentWord.Length - 1) == "e")
            numVowels--;

        return numVowels;
    }

Comments

उचित नामों में शब्दांशों को खोजने के मेरे सरल परिदृश्य के लिए ऐसा लगता है कि शुरू में यह काफी अच्छा काम कर रहा था। इसे यहां डालने के लिए धन्यवाद।

— नॉर्मन एच

Answer 5

यह एक विशेष रूप से कठिन समस्या है जो पूरी तरह से LaTeX hyphenation एल्गोरिथ्म द्वारा हल नहीं की गई है। कुछ उपलब्ध तरीकों और शामिल चुनौतियों का एक अच्छा सारांश अंग्रेजी (Marchand, Adsett और Damper 2007) के लिए स्वचालित सिलेबस एल्गोरिदम का मूल्यांकन पेपर में पाया जा सकता है ।

Answer 6

इसकी गणना क्यों? हर ऑनलाइन शब्दकोश में यह जानकारी है। http://dEDIA.reference.com/browse/inv अदृश्य में · · · · · ब्लीड

Comments

हो सकता है कि इसे ऐसे शब्दों के लिए काम करना है जो शब्दकोशों में प्रकट नहीं होते हैं, जैसे कि नाम?

— राउटर लीवेंस

@ राउटरलाइन्स: मुझे नहीं लगता कि नाम कहीं भी हैं, जो स्वचालित रूप से शब्दांश पार्सिंग के लिए पर्याप्त व्यवहार के पास हैं। अंग्रेजी नामों के लिए एक शब्दांश पार्सर वेल्श या स्कॉटिश मूल के नामों पर बुरी तरह से विफल हो जाएगा, भारतीय और नाइजीरियाई मूल के अकेले नाम दें, फिर भी आपको ये सभी एक ही कमरे में मिल सकते हैं जैसे कि लंदन।

— जीन-फ्रांस्वा कॉर्बेट

यह ध्यान रखना चाहिए कि मानव से बेहतर प्रदर्शन की उम्मीद करना उचित नहीं है, यह विचार कर सकता है कि यह एक स्केच डोमेन के लिए एक विशुद्ध रूप से विधर्मी दृष्टिकोण है।

— डैरेन रिंगर

Answer 7

धन्यवाद जो बेसिरिको, C # में अपने त्वरित और गंदे कार्यान्वयन को साझा करने के लिए। मैंने बड़े पुस्तकालयों का उपयोग किया है, और वे काम करते हैं, लेकिन वे आमतौर पर थोड़ा धीमा होते हैं, और त्वरित परियोजनाओं के लिए, आपकी विधि ठीक काम करती है।

यहाँ परीक्षण के मामलों के साथ-साथ जावा में आपका कोड है:

public static int countSyllables(String word)
{
    char[] vowels = { 'a', 'e', 'i', 'o', 'u', 'y' };
    char[] currentWord = word.toCharArray();
    int numVowels = 0;
    boolean lastWasVowel = false;
    for (char wc : currentWord) {
        boolean foundVowel = false;
        for (char v : vowels)
        {
            //don't count diphthongs
            if ((v == wc) && lastWasVowel)
            {
                foundVowel = true;
                lastWasVowel = true;
                break;
            }
            else if (v == wc && !lastWasVowel)
            {
                numVowels++;
                foundVowel = true;
                lastWasVowel = true;
                break;
            }
        }
        // If full cycle and no vowel found, set lastWasVowel to false;
        if (!foundVowel)
            lastWasVowel = false;
    }
    // Remove es, it's _usually? silent
    if (word.length() > 2 && 
            word.substring(word.length() - 2) == "es")
        numVowels--;
    // remove silent e
    else if (word.length() > 1 &&
            word.substring(word.length() - 1) == "e")
        numVowels--;
    return numVowels;
}

public static void main(String[] args) {
    String txt = "what";
    System.out.println("txt="+txt+" countSyllables="+countSyllables(txt));
    txt = "super";
    System.out.println("txt="+txt+" countSyllables="+countSyllables(txt));
    txt = "Maryland";
    System.out.println("txt="+txt+" countSyllables="+countSyllables(txt));
    txt = "American";
    System.out.println("txt="+txt+" countSyllables="+countSyllables(txt));
    txt = "disenfranchized";
    System.out.println("txt="+txt+" countSyllables="+countSyllables(txt));
    txt = "Sophia";
    System.out.println("txt="+txt+" countSyllables="+countSyllables(txt));
}

परिणाम अपेक्षित था (यह फ्लेश-किन्किड के लिए काफी अच्छा काम करता है):

txt=what countSyllables=1
txt=super countSyllables=2
txt=Maryland countSyllables=3
txt=American countSyllables=3
txt=disenfranchized countSyllables=5
txt=Sophia countSyllables=2

Answer 8

Bumping @Tihamer और @ joe-basirico। बहुत उपयोगी फ़ंक्शन, न कि सही , लेकिन अधिकांश छोटी-से-मध्यम परियोजनाओं के लिए अच्छा है। जो, मैंने पायथन में अपने कोड के कार्यान्वयन को फिर से लिखा है:

def countSyllables(word):
    vowels = "aeiouy"
    numVowels = 0
    lastWasVowel = False
    for wc in word:
        foundVowel = False
        for v in vowels:
            if v == wc:
                if not lastWasVowel: numVowels+=1   #don't count diphthongs
                foundVowel = lastWasVowel = True
                        break
        if not foundVowel:  #If full cycle and no vowel found, set lastWasVowel to false
            lastWasVowel = False
    if len(word) > 2 and word[-2:] == "es": #Remove es - it's "usually" silent (?)
        numVowels-=1
    elif len(word) > 1 and word[-1:] == "e":    #remove silent e
        numVowels-=1
    return numVowels

आशा है कि कोई इसे उपयोगी पाता है!

Answer 9

पर्ल में लिंगुआ :: ध्वनिविज्ञान :: शब्दांश मॉड्यूल है। आप इसकी कोशिश कर सकते हैं, या इसके एल्गोरिदम को देखने का प्रयास कर सकते हैं। मैंने वहां कुछ अन्य पुराने मॉड्यूल भी देखे।

मुझे समझ में नहीं आता है कि एक नियमित अभिव्यक्ति आपको केवल शब्दांश की गिनती क्यों देती है। कैप्चर कोष्ठक का उपयोग करके आपको स्वयं शब्दांश प्राप्त करने में सक्षम होना चाहिए। मान लें कि आप एक नियमित अभिव्यक्ति का निर्माण कर सकते हैं जो काम करता है, वह है।

Answer 10

आज मुझे अंग्रेजी या जर्मन के पैटर्न के साथ फ्रैंक लियांग के हाइफ़नेशन एल्गोरिदम का यह जावा कार्यान्वयन मिला , जो काफी अच्छा काम करता है और मावेन सेंट्रल पर उपलब्ध है।

गुफा: .texपैटर्न फ़ाइलों की अंतिम पंक्तियों को निकालना महत्वपूर्ण है , क्योंकि अन्यथा उन फ़ाइलों को मेलेन सेंट्रल पर वर्तमान संस्करण के साथ लोड नहीं किया जा सकता है।

लोड करने और उपयोग करने के लिए hyphenator, आप निम्न जावा कोड स्निपेट का उपयोग कर सकते हैं। आवश्यक पैटर्न वाले फ़ाइलों का texTableनाम है .tex। वे फाइलें प्रोजेक्ट गिथब साइट पर उपलब्ध हैं।

 private Hyphenator createHyphenator(String texTable) {
        Hyphenator hyphenator = new Hyphenator();
        hyphenator.setErrorHandler(new ErrorHandler() {
            public void debug(String guard, String s) {
                logger.debug("{},{}", guard, s);
            }

            public void info(String s) {
                logger.info(s);
            }

            public void warning(String s) {
                logger.warn("WARNING: " + s);
            }

            public void error(String s) {
                logger.error("ERROR: " + s);
            }

            public void exception(String s, Exception e) {
                logger.error("EXCEPTION: " + s, e);
            }

            public boolean isDebugged(String guard) {
                return false;
            }
        });

        BufferedReader table = null;

        try {
            table = new BufferedReader(new InputStreamReader(Thread.currentThread().getContextClassLoader()
                    .getResourceAsStream((texTable)), Charset.forName("UTF-8")));
            hyphenator.loadTable(table);
        } catch (Utf8TexParser.TexParserException e) {
            logger.error("error loading hyphenation table: {}", e.getLocalizedMessage(), e);
            throw new RuntimeException("Failed to load hyphenation table", e);
        } finally {
            if (table != null) {
                try {
                    table.close();
                } catch (IOException e) {
                    logger.error("Closing hyphenation table failed", e);
                }
            }
        }

        return hyphenator;
    }

बाद में Hyphenatorउपयोग करने के लिए तैयार है। सिलेबल्स का पता लगाने के लिए, मूल विचार प्रदान किए गए हाइफ़न में शब्द को विभाजित करना है।

    String hyphenedTerm = hyphenator.hyphenate(term);

    String hyphens[] = hyphenedTerm.split("\u00AD");

    int syllables = hyphens.length;

आपको "\u00AD" पर विभाजित करने की आवश्यकता है , क्योंकि एपीआई एक सामान्य वापसी नहीं करता है "-"।

यह दृष्टिकोण जो बासीरिको के उत्तर को बेहतर बनाता है, क्योंकि यह कई अलग-अलग भाषाओं का समर्थन करता है और जर्मन हाइफ़नेशन का अधिक सटीक पता लगाता है।

Answer 11

मैं थोड़ी देर पहले इसी मुद्दे पर भागा था।

मैंने अधिकांश शब्दों के त्वरित और सटीक लुकअप के लिए CMU उच्चारण शब्दकोश का उपयोग किया । शब्दकोष में नहीं शब्दों के लिए, मैं एक मशीन लर्निंग मॉडल पर वापस आ गया, जो शब्दांश गिनती की भविष्यवाणी करने पर ~ 98% सटीक है।

मैंने यहाँ एक आसान-से-उपयोग अजगर मॉड्यूल में पूरी चीज़ को लपेटा है: https://github.com/repp/bit-noney

इंस्टॉल: pip install big-phoney

गणना सिलेबल्स:

from big_phoney import BigPhoney
phoney = BigPhoney()
phoney.count_syllables('triceratops')  # --> 4

यदि आप पायथन का उपयोग नहीं कर रहे हैं और आप एमएल-मॉडल-आधारित दृष्टिकोण की कोशिश करना चाहते हैं, तो मैंने कागले पर शब्दांश गणना मॉडल कैसे काम करता है, इस पर एक विस्तृत विवरण दिया ।

Comments

यह सुपर कूल है। क्या किसी को आईओएस पर उपयोग के लिए परिणामी केरस मॉडल को एक कोरएमएल मॉडल में परिवर्तित करने का कोई सौभाग्य मिला है?

— अलेक्जेंडर अकर्स

Answer 12

साभार @ जो-बेसिरिको और @तिहार्म मैंने @ tihamer के कोड को Lua 5.1, 5.2 और luajit 2 में चित्रित किया है ( सबसे अधिक संभावना यह है कि लूआ के अन्य संस्करणों पर भी चलेगा ):

countsyllables.lua

function CountSyllables(word)
  local vowels = { 'a','e','i','o','u','y' }
  local numVowels = 0
  local lastWasVowel = false

  for i = 1, #word do
    local wc = string.sub(word,i,i)
    local foundVowel = false;
    for _,v in pairs(vowels) do
      if (v == string.lower(wc) and lastWasVowel) then
        foundVowel = true
        lastWasVowel = true
      elseif (v == string.lower(wc) and not lastWasVowel) then
        numVowels = numVowels + 1
        foundVowel = true
        lastWasVowel = true
      end
    end

    if not foundVowel then
      lastWasVowel = false
    end
  end

  if string.len(word) > 2 and
    string.sub(word,string.len(word) - 1) == "es" then
    numVowels = numVowels - 1
  elseif string.len(word) > 1 and
    string.sub(word,string.len(word)) == "e" then
    numVowels = numVowels - 1
  end

  return numVowels
end

और यह पुष्टि करने के लिए कुछ मज़ेदार परीक्षण ( जितना संभव हो उतना काम करता है ):

countsyllables.tests.lua

require "countsyllables"

tests = {
  { word = "what", syll = 1 },
  { word = "super", syll = 2 },
  { word = "Maryland", syll = 3},
  { word = "American", syll = 4},
  { word = "disenfranchized", syll = 5},
  { word = "Sophia", syll = 2},
  { word = "End", syll = 1},
  { word = "I", syll = 1},
  { word = "release", syll = 2},
  { word = "same", syll = 1},
}

for _,test in pairs(tests) do
  local resultSyll = CountSyllables(test.word)
  assert(resultSyll == test.syll,
    "Word: "..test.word.."\n"..
    "Expected: "..test.syll.."\n"..
    "Result: "..resultSyll)
end

print("Tests passed.")

Comments

मैंने दो और परीक्षण मामले "एंड" और "आई" जोड़े। यह निर्णय असंवेदनशील रूप से स्ट्रिंग्स केस की तुलना करने के लिए था। यदि वे एक ही समस्या से पीड़ित हैं और अपने कार्यों को अद्यतन करना चाहते हैं, तो पिंग'जो-बेसिरिको और टाइहमेर।

— josefnpat

@tihamer अमेरिकन 4 सिलेबल्स है!

— josefnpat

Answer 13

मुझे सिलेबल्स गिनने का पर्याप्त तरीका नहीं मिला, इसलिए मैंने खुद एक तरीका तैयार किया।

आप यहाँ मेरी विधि देख सकते हैं: https://stackoverflow.com/a/32784041/2734752

मैं एक शब्दकोश और एल्गोरिथ्म विधि के संयोजन का उपयोग करने के लिए शब्दांशों की गणना करता हूं।

आप मेरी लाइब्रेरी यहाँ देख सकते हैं: https://github.com/troywatson/Lawrence-Style-Checker

मैंने अभी-अभी अपने एल्गोरिथ्म का परीक्षण किया और ९९.४% स्ट्राइक रेट था!

Lawrence lawrence = new Lawrence();

System.out.println(lawrence.getSyllable("hyphenation"));
System.out.println(lawrence.getSyllable("computer"));

आउटपुट:

4
3

Comments

आम तौर पर, टूल या लाइब्रेरी के लिंक का उपयोग नोटों के साथ किया जाना चाहिए, समस्या के लिए लिंक किए गए संसाधन या कुछ नमूना कोड , या यदि उपरोक्त सभी संभव हो , तो इसका एक विशिष्ट विवरण ।

— इक्यावनघ

सिंटेक्स हाइलाइटिंग देखें । एसओ संपादक में एक सहायता बटन (प्रश्न चिह्न) है जो आपको लिंक किए गए पृष्ठ पर ले जाएगा।

— इक्यावनघ

Answer 14

बहुत सारे परीक्षण करने और हाइफ़नेशन पैकेजों को आज़माने के बाद, मैंने कई उदाहरणों के आधार पर अपना लिखा। मैंने हाइफ़नेशन शब्दकोशों के साथ इंटरफेस pyhyphenऔर pyphenपैकेज की भी कोशिश की , लेकिन वे कई मामलों में गलत संख्या में शब्दांश का उत्पादन करते हैं। nltkपैकेज बस उपयोग के इस मामले बहुत धीमी गति से किया गया था।

पायथन में मेरा कार्यान्वयन मेरे द्वारा लिखी गई कक्षा का हिस्सा है, और शब्दांश की गिनती की दिनचर्या नीचे चिपकाई गई है। यह अनुमान लगाता है कि सिलेबल्स की संख्या थोड़ी अधिक है क्योंकि मुझे अभी भी साइलेंट वर्ड एंडिंग के लिए एक अच्छा तरीका नहीं मिला है।

फ़ंक्शन शब्द के अनुसार शब्दांश के अनुपात को लौटाता है क्योंकि इसका उपयोग फ़्लेश-किन्काइड पठनीयता स्कोर के लिए किया जाता है। संख्या का सटीक होना आवश्यक नहीं है, बस एक अनुमान के लिए पर्याप्त है।

मेरी 7 वीं पीढ़ी के i7 सीपीयू पर, इस फ़ंक्शन ने 759 शब्द नमूना पाठ के लिए 1.1-1.2 मिलीसेकंड लिया।

def _countSyllablesEN(self, theText):

    cleanText = ""
    for ch in theText:
        if ch in "abcdefghijklmnopqrstuvwxyz'’":
            cleanText += ch
        else:
            cleanText += " "

    asVow    = "aeiouy'’"
    dExep    = ("ei","ie","ua","ia","eo")
    theWords = cleanText.lower().split()
    allSylls = 0
    for inWord in theWords:
        nChar  = len(inWord)
        nSyll  = 0
        wasVow = False
        wasY   = False
        if nChar == 0:
            continue
        if inWord[0] in asVow:
            nSyll += 1
            wasVow = True
            wasY   = inWord[0] == "y"
        for c in range(1,nChar):
            isVow  = False
            if inWord[c] in asVow:
                nSyll += 1
                isVow = True
            if isVow and wasVow:
                nSyll -= 1
            if isVow and wasY:
                nSyll -= 1
            if inWord[c:c+2] in dExep:
                nSyll += 1
            wasVow = isVow
            wasY   = inWord[c] == "y"
        if inWord.endswith(("e")):
            nSyll -= 1
        if inWord.endswith(("le","ea","io")):
            nSyll += 1
        if nSyll < 1:
            nSyll = 1
        # print("%-15s: %d" % (inWord,nSyll))
        allSylls += nSyll

    return allSylls/len(theWords)

Answer 15

मैंने एक बार ऐसा करने के लिए jsoup का इस्तेमाल किया। यहाँ एक नमूना शब्दांश पार्सर है:

public String[] syllables(String text){
        String url = "https://www.merriam-webster.com/dictionary/" + text;
        String relHref;
        try{
            Document doc = Jsoup.connect(url).get();
            Element link = doc.getElementsByClass("word-syllables").first();
            if(link == null){return new String[]{text};}
            relHref = link.html(); 
        }catch(IOException e){
            relHref = text;
        }
        String[] syl = relHref.split("·");
        return syl;
    }

Comments

यह एक सामान्य शब्दांश पार्सर कैसे है? ऐसा लगता है कि यह कोड केवल एक शब्दकोष

— Nico Haase