Páginas

segunda-feira, 1 de abril de 2013

Masxina Lernado de Davison

Esplori Python, Maŝino Lernado Biblioteko kaj NLTK

Disvolvi apliko categorizar RSS uzante Python, NLTK kaj maŝina lerno
Chris Joakim , Senior Programaro Inĝeniero, Primedia Inc
Resumo: La maŝino lernado, kiu estas cxe la komunaĵo de IT, matematiko kaj natura lingvo, estas ĝenerale uzata en granda datumoj aplikoj. Ĉi tiu artikolo diskutas la programlingvo Pitono kaj NLTK vian bibliotekon kaj aplikas ilin al maŝino-lernado projekto.
Dato: 30/Out/2012
Nivelo: Intera Ankaŭ disponebla en: English
Aktiveco: 1748 vizitoj
Komentoj: 0 (Visualizar | Incluir comentário - Conectar)

Komencanto en Python

Ĉi tiu artikolo estas por programistoj - precipe tiuj kun fono en Java aŭ Rubeno - kiu alfrontas siajn unuajn deplojon de maŝino lernado.
La defio: Uzante maŝino lerni categorizar RSS
Ĵus, mi komisiis kun kreante subsistemo categorización de RSS por kliento. La celo estis legi dekojn aŭ eĉ centoj de RSS kaj aŭtomate categorizar la diversaj artikoloj en unu el dekoj da predefinido temo areoj. La enhavo, navigado kaj serĉo funkciaro de la kliento de afiŝinto baziĝus sur la rezultoj de reakiro kaj categorización, aŭtomata ĉiutaga nutrado.
La kliento sugestis uzi maŝino lernado, eble kun Apache mahout kaj Hadoop ĉar ŝi ĵus legis artikolojn pri tiuj teknologioj. Tamen, ilia evoluo teamo kaj nia estas flua en Ruby anstataŭ Java ™ teknologio. Ĉi tiu artikolo priskribas la veturon tekniko, procezo de lernado kaj fina efektivigo de solvaĵo.
Kio estas maŝino lernado?
Mia unua demando estis: "Kion ekzakte estas maŝino lernado?". Mi aŭdis la terminon kaj sciis malprecize ke la IBM supercomputadora Vatsono ® uzis por venki homaj partoprenantoj en ludo de Jeopardy. Buyer Kiel partoprenanto kaj sociaj retoj, mi ankaŭ sciis ke Amazon.com kaj Facebook estas grandaj rekomendojn (produkto kaj homoj) bazitaj sur datumoj de aĉetantoj. En resumo, maŝino lernado estas la komunaĵo de IT, matematiko kaj natura lingvo. Estas rilataj ĉefe al tiuj tri temoj, sed la solvo al la kliento eventuale impliki la unua du:
  • Taksado. Asignu artikoloj arbitrajn predefinido kategorioj bazitaj sur aro de trejnado datumoj de similaj artikoloj
  • Rekomendo. Rekomendi artikoloj bazita sur observo de similaj artikoloj
  • Clustering. Identigu subgrupoj en loĝantaro de datumoj
Devioj kun mahout kaj Ruby
Komprenante kio maŝino lernado, la sekva paŝo estis determini kiom apliki. Kiel la kliento sugestas, mahout estis bona deirpunkto. Mi elŝutis la kodon de Apache kaj eklernis pri maŝino lernado kun mahout kaj lia frato, Hadoop. Bedaŭrinde, mi trovis ke mahout havas krutajn lernado kurbo, eĉ por sperta Java programisto, kaj ke ne estis funkcia specimeno kodo. Estis ankaŭ ne strukturoj aŭ gemojn por Ruby-bazita maŝino lernado.
Finding Python kaj NLTK
Mi konservis serĉas solvon kaj ĉiam trovis "Python" en la rezulto aro. Kiel Rubeno programisto, mi sciis estis Python programlingvo simila (objektema, teksto-bazita, interpretita kaj dinamika), sed mi ne lernis la lingvon. Malgraŭ ĉi tiuj similecoj, mi ne tedis lerni Python tra la jaroj, kiel kvalifiko konsideras superfluaj. Python estis en mia "blinda punkto" kiel mi kredas ke devus esti por multaj kolegoj de Ruby.
Serĉante libroj sur maŝino lernado kaj profundigo mi en ĝia enhavo, mi malkovris ke granda procento de tiuj sistemoj uzas Python kiel la efektivigo lingvo kune kun biblioteko nomita Natura Lingvo Toolkit (NLTK). Aliaj serĉoj ke relevaram Python estis pli populara ol mi pensis - ekz, Google App Engine, YouTube kaj retejoj kreitaj kun la Django kadro. Do estas antaŭ-instalita sur la laborstacioj Mac OS X, kiun mi uzas ĉiutage! Cetere, Python norma biblioteko proponas interesan (ekz. NumPy kaj SciPy) por Y, la scienco kaj inĝenierado. Kiu sciis?
Mi decidis serĉi solvon en Python post trovi ekzemplojn de eleganta kodo. La sekva linio, ekzemple, estas tuta kodo bezonis legi RSS-servo per HTTP kaj presi la enhavo:
     feedparser.parse print ("http://feeds.nytimes.com/nyt/rss/Technology")

Sciante Python
Kiam lerni novan lingvon de programado, la facila parto estas kutime lernas la lingvon mem. La malmola parto lernas lia ekosistemo - kiel instali, inkluzive bibliotekoj, skribi kodon, strukturigi vian kodo dosieroj, kuri, debug, kaj skribu unueco provoj. Tiu sekcio enhavas mallongan enkondukon al tiuj temoj. Kontrolu Rimedoj por ligiloj al pli da informoj.
Pip
La Python Pako Indekso ( pip ) estas la defaŭlta pakaĵa administrilo por Pitono. Ĝi estas la programo uzita por inkluzivi bibliotekoj en la sistemo. Ĝi estas analoga al la gemoj de Ruby bibliotekoj. Por inkludi la NLTK biblioteko en la sistemo, la uzanto enigas la sekva komando:
   $ Pip instalon nltk

Por vidi liston de Python bibliotekoj instalitaj en via sistemo, kuri jena ordono:
   $ Pip freeze

Kurante programoj
Kuri Python programo estas same simpla. Donita programo nomata locomotive_main.py kaj tri argumentojn, ni kompilos kaj ekzekuti la programon kun python :
   $ Python locomotive_main.py arg1 arg2 arg3

Pitono uzas la sintakson if __name__ == "__main__": en kantoj 1 determini se la dosiero estas kurante en la komanda linio aŭ esti importitaj de aliaj kodo. Fari plenumebla dosiero, inkluzive de la detekto de "__main__" .

Kantoj 1. Detekto de ĉefaj
 importado sys
 importado tempo
 importado lokomotivo

 se __ name__ == "__main__":
     start_time = time.time ()
     se len (sys.argv)> 1:
         locomotive.app.Application programo = ()
         ...  pliaj logiko ...

virtualenv
Plej Rubeno programistoj konas la temon de sistemo bibliotekoj aŭ gemoj. Aro de bibliotekoj por la tuta sistemo ne estas ideala, ĉar unu el la projektoj povas dependi de la versio 1.0.0 de iu biblioteko, dum alia projekto dependas versio 1.2.7. Simile, Java programistoj konata problemo kun ĉi tiu sistemo Classpath. Kiel la Rubeno komunumo kun la ilo rvm , la komunumo uzas la Python ilo virtualenv (vidu Rimedoj por ligilon) por krei apartajn ekzekuto medioj, inkludante specifaj versioj de Python kaj aro de bibliotekoj. La komandoj en Listing 2 montras kiel krei virtualan medion nomis p1_env p1 por la projekto, kiu enhavas la bibliotekojn feedparser , numpy , scipy kaj nltk .

Kantoj 2. Komandoj por krei virtualan medion kun virtualenv
   $ Ŝvitas Pip instali virtualenv
   $ Cd ~
   $ Mkdir p1
   $ Cd p1
   P1_env $ virtualenv - distribui
   $ Fonto p1_env/bin/activate
   (P1_env) [~ / p1] $ Pip instali feedparser
   (P1_env) [~ / p1] $ Pip instali numpy
   (P1_env) [~ / p1] $ Pip instalon scipy
   (P1_env) [~ / p1] $ Pip instalon nltk
   (P1_env) [~ / p1] $ Pip freeze

Vi devas reakiri la skripto aktivigo de la virtuala medio vojo "fonto" ĉiufoje kiam vi laboras kun la projekto en ŝela fenestro. Notu ke la komand-linio shell script ŝanĝas kiam la aktivigo estas restaŭrita. Por krei kaj uzi fenestroj konko en la sistemo por pli facile navigi al via projekto dosierujon kaj aktivigi la virtuala medio, ĝi povas esti utila por inkludi eniro kiel la sekva en via ~ /. Bash_profile dosiero:
 Alias ​​$ p1 = "cd ~ / p1 fonto p1_env/bin/activate"

La strukturo de la kodo bazo
Post pasi programoj per simpla "Saluton Mondo" unu linio de Python programistoj bezonas por kompreni kiel bone strukturigi vian kodo bazon rilate dosierujoj kaj dosierujaj nomoj. Java kaj Ruby havas siajn proprajn kondiĉojn por tio, kaj Python estas malsama. Mallonge, Python uzas la koncepton de pakoj kolekti rilatantaj kodo kaj krei nomspacoj senduba. Por pruvo intencoj en ĉi tiu artikolo, la kodo estas en la radiko de iu projekto, kiel ~ / p1. En tiu ĉi dosierujo ekzistas dosierujo lokomotivo por la Python pako de la sama nomo. Listing 3 montras ĉi dosierujo strukturo.

Kantoj 3. Directory strukturo ekzemplo
 locomotive_main.py
 locomotive_tests.py

 lokomotivo /
     __init__.py
     app.py
     capture.py
     category_associations.py
     classify.py
     news.py
     recommend.py
     rss.py

 locomotive_tests /
     __init__.py
     app_test.py
     category_associations_test.py
     feed_item_test.pyc
     rss_item_test.py

Rimarku la dosierojn kun la stranga nomo de __ init__.py. Tiuj dosieroj diru la Python ŝarĝi la necesajn bibliotekojn por la pako dosierojn kaj apliko kodo kiu estas specifa al la sama dosierujo. Listing 4 montras la enhavon de la lokomotivo / __ init__.py.

Kantoj 4. lokomotivo / __ init__.py
     # Sistemo importoj; ŝarĝoj instalita pakoj
     importado codecs
     importado locale
     importado sys

     # Apliko importoj; tiuj specifaj ŝarĝo vian *. Py dosieroj
     importado programo
     importi kapti
     importado category_associations
     klasifiki importado
     importado rss
     importado novaĵoj
     importi rekomendas

Kun la lokomotivo pako strukturita kiel en Listing 4 , la ĉefaj programoj en la radika dosierujo de la projekto povas importi ĝin kaj uzi ĝin. Ekzemple, la dosiero locomotive_main.py enhavas la sekvajn importoj:
     importado sys #> - sistemo biblioteko
     importado tempo #> - sistemo biblioteko
     importi lokomotivo #> - kutimo apliko kodo biblioteko en la "lokomotivo" dosierujon

Testo
La norma biblioteko unittest Python estas bona solvo por testado. Por Java programistoj konas JUnit kaj Ruby programistoj konas Testo :: Unueco kadro, kodo unittest Python en Listing 5 estos pli facile legi.

Kantoj 5. Pitono unittest
   AppTest klaso (unittest.TestCase):

       def instalinstrukciojn (self):
           self.app locomotive.app.Application = ()

       def tearDown (self):
           pasas

       test_development_feeds_list def (self):
           feeds_list self.app.development_feeds_list = ()
           self.assertTrue (len (feeds_list) == 15)
           self.assertTrue ('feed :/ / news.yahoo.com / rss / stock-merkatoj' en feeds_list)
  

La kodo en Listing 5 ankaŭ evidentigas diferencante karakterizaĵo de Python: ĉiuj kodo devus esti dentado konsekvence, aŭ ne kompili sukcese. La metodo tearDown(self) povas simili iom stranga, unue. Vi devas esti demandante kial la provo agordi por ĉiam pasos. Vere, ne estis. Tiel estas kiel oni kreas malplenajn metodo en Python.
Ilo kit
Kion mi vere bezonis estis integrita disvolviĝo medio (IDE) kun sintaksa kolorigo, kodo finaĵon kaj depuración funcionalidad Haltpunkto helpi en lerni Python. Kiel uzanto de la Eklipso IDE por Java disvolviĝo, la plug-in pyeclipse estis la unua ilo kiu mi ekzamenis. Bone funkcias, kvankam malrapida foje. Mi finis renversi en PyCharm IDE, kiu havas ĉion, kion mi bezonas.
Kun bazaj scioj de Python kaj lia ekosistemo, estis tempo por komenci realiganta la solvo de maŝino lernado.
Implementando categorización kun Python kaj NLTK
Apliki la solvon, oni devis kapti RSS simulita, pura teksto, uzu NaiveBayesClassifier kaj klasifiki kategorioj kun la kNN algoritmo. Ĉiu de ĉi tiuj agoj estas priskribita tie.
Kaptante kaj analizi feeds
La projekto havis specialan defio: la kliento ankoraux ne starigis liston de RSS kiu estus celoj. Sekve, ne estis "trejnado datumoj". Sekve, la nutrado kaj la trejnado datumoj devis esti simulita dum frua evoluo.
La unua alproksimiĝo mi uzis por akiri specimenon datumoj simple serĉas liston de RSS nutras precizigita en teksta dosiero. Pitono biblioteko proponas bonan analizon de RSS, nomita feedparser , kiu Abstracts la diferencoj inter RSS kaj Atom formatoj. Alia utila biblioteko por objekto serialización teksto bazita havas la komika nomo pickle . Ambaŭ bibliotekoj estas uzataj en la kodo en Listing 6 , kiu kaptas ĉiu RSS kiel encurtido objekto dosierojn por posta uzo. Kiel vi povas vidi, Python estas konciza kaj efika.

Kantoj 6. La klaso CaptureFeeds
 importado feedparser
 importi encurtido

 CaptureFeeds klaso:

     def __ init__ (self):
         por (i, url) en _enumerate_ (self.rss_feeds_list ());
             self.capture_as_pickled_feed (url.strip (), i)

     rss_feeds_list def (self):
         f = open ('feeds_list.txt', 'r')
         f.readlines listo = ()
         f.close
         revenu listo

     capture_as_pickled_feed def (Vin mem, url, feed_index):
         feed = feedparser.parse (url)
         f = open ('data / feed_' + str (feed_index) + '. pkl', 'w')
         pickle.dump (feed, f)
         f.close ()

 se __ name__ == "__main__":
     CaptureFeeds = cf ()

La sekva paŝo estis surprize defia. Nun mi nutros datumoj specimeno, estis necese klasifiki ilin por uzo kiel trejnado datumoj. Datumoj de la trejnado datuma aro estas donita al la categorización algoritmo por ke ĝi povu lerni.
Ekzemple, la specimeno nutras ke mi uzis inkludis ESPN, la Sports Reto. Unu el flueroj parolis pri la transigo de Tim Tebow, la teamo de futbalo Denver Malafablaj, la New York Jetoj dum la Malafablaj estis dungita Peyton Manning esti lia nova antaŭa. Alia listero pri la rezultoj de la nutrado estis pri la entrepreno kaj lia nova Boeing jeto. La demando estas: kio specifa kategorio valoro devas esti atribuita al la unua artikolo? La valoroj tebow , broncos , manning , jets , quarterback , trade kaj nfl estas ĉiuj taŭgaj. Sed nur unu valoro povas esti precizigita en la trejnado datumoj kiel lia kategorio. Simile la dua artikolo estas la kategorio boeingjet ? La problemo estas tiuj detaloj. La manlibro categorización bezonas grandan aron de trejnado datumoj estas esenca por la algoritmo produktas precizaj rezultoj. La tempo bezonata por fari ĉi ne estu subtaksata.
Ĝi baldaŭ evidentiĝis, ke mi bezonis pli datumojn por labori, kaj oni devis jam esti _categorized_ - kaj precizeco. Kie mi trovas ĉi datumoj? Jen venas la Python NLTK. Krom esti bonega biblioteko por vorto prilaborado, ĝi eĉ venas kun specimeno datenaroj por malŝarĝi, aŭ korpuso en lia terminologio, kaj apliko programado interfaco por facile aliri la elŝutitaj datumoj. Por instali la Reuters korpuso, ruli la komandojn sube. Super 10.000 gazetaro artikoloj estos kopiitaj al la dosierujo ~ / nltk_data / korpusoj / Reuters /. Ĝuste kiel la RSS-flueroj, ĉiu Reuters artikolo enhavas titolo kaj korpo, tiel ke datumoj antaŭ-_categorized_ NLTK estas bonegaj kampoj por simuli RSS.
 $ Python # eniri interaga Python konko
 # >>> Importi nltk importi la nltk biblioteko
 Nltk.download >>> () # ruli la NLTK Downloader, skribu 'd' Elŝuti
 Ensalutilo> # Specifu la Reuters 'Reuters' corpus

De aparta intereso estas la dosiero ~ / nltk_data / korpusoj / Reuters / cats.txt. Ĝi enhavas liston de nomoj de arkivoj kaj eron kategorio atribuita al ĉiu el ili. La dosiero havas la jena formato, do la artikolo sur dosiero en la subdosierujo testo 14828 temo apartenas al la grain .
 test/14826 komerco
 test/14828 greno

Naturaj lingvoj estas malklara
La kruda enigo algoritmo categorización de RSS estas evidente skribita teksto en la angla. Estas vere malpura.
Angla, aŭ iu ajn alia natura lingvo (te lingvoj parolataj aŭ komuna) estas tre malregula kaj malpreciza el la vidpunkto de komputila prilaborado. Unue, tie estas la demando de la distingo inter majuskloj kaj minuskla. La vorto egalas Malafabla Malafabla? La respondo estas eble. Tiam estas la problemo de interpunkcio kaj spacoj. La termino Malafabla. Egalas MalafablaMalafabla,? Pli aŭ malpli. Plie, estas pluralo kaj similaj vortoj. Kuru, kurante, kaj kuris ekvivalento? Nu, tio dependas. La tri vortoj havas komunan radikon. Kaj se ni havas naturan lingvon estas integritaj en markado lingvo kiel HTML? En ĉi tiu kazo, estus necesa por manipuli tekston <strong>bronco</strong> . Fine, estas la problemo de esence sensignifa vortoj, sed ofte uzata kiel, e kaj o. Tiaj "stopwords" nur malhelpas. Naturaj lingvoj estas malklara. Vi devas liberigi antaux prilaborado.
Feliĉe, Python kaj NLTK permesi purigi ĉi salato. La metodo normalized_words klaso RssItem en Listing 7 , prizorgas tiujn temojn. Notu, precipe, kiel NLTK forigas HTML markado integrita krudan tekston de la artikolo en nur unu linion de kodo! Regula esprimo estas uzata por forigi la partituro, kaj tiam la individuaj vortoj estas dividita kaj ununormigita al minuskla.

Kantoj 7. La klaso RssItem
 RssItem klaso:
     ...
     regex = re.compile ('[% s]'% re.escape (string.punctuation))
     ...
     normalized_words def (Vin mem, article_text):
         vortoj = []
         article_text.replace oneline = ('\ n','')
         = Nltk.clean_html purigis (oneline.strip ())
         toks1 cleaned.split = ()
         T1 estas en toks1:
             Tradukis self.regex.sub = ('', T1)
             toks2 translated.split = ()
             T2 estas en toks2:
                 t2s t2.strip = (). malsupreniri ()
                 se self.stop_words.has_key (t2s):
                     pasas
                 alie:
                     words.append (t2s)
         revenu vortoj

La listo de stopwords venis de NLTK kun jena linio de kodo. Estas apogo por aliaj naturaj lingvoj:
 nltk.corpus.stopwords.words ('english')

NLTK ankaŭ ofertas plurajn klasojn "lematizadoras" por normaligi eĉ pli vortoj. Vidu la dokumentado sur la NLTK devenaj, frazo strukturo kaj gramatiko por pli informo.
Klasifiko kun Naiva Bayes algoritmo
Naiva Bayes algoritmo estas larĝe uzata kaj implementado en NLTK kun klaso nltk.NaiveBayesClassifier . La Bayes algoritmo klasifikas erojn laŭ la ĉeesto aŭ foresto de karakterizaĵoj en la datumoj aroj. En la kazo de artikoloj de RSS nutras ĉiu trajto estas donita vorto (pura) natura lingvo. La algoritmo estas "naiva" ĉar ĝi supozas ke ne ekzistas rilato inter la trajtojn (en tiu kazo, vortoj).
Tamen, la angla enhavas pli ol 250.000 vortojn. Mi certe ne volas devi krei Bulea objekto enhavas 250.000 por ĉiu RSS ero pasi al la algoritmo. Do kio vortoj mi uzas? Mallonge, la respondo estas la plej uzataj vortoj en la loĝantaro de la trejnado datumoj kiuj ne stopwords. NLTK havigas klaso excepciona, nltk.probability.FreqDist kiu povas esti uzata por identigi tiujn vortojn plej ofte uzata. En Listing 8 , la metodo collect_all_words revenas tabelo de ĉiuj vortoj de ĉiuj artikoloj de trejnado.
Tiu tabelo estas pasita al la metodo identify_top_words identigi la plej oftaj vortoj. Utila karakterizaĵo de la klaso nltk.FreqDist estas kiu estas esence hash, sed lia klavoj estas stokitaj en konsento kun la respondaj valoroj, aŭ interpunkcioj. Tial, estas facile atingi la 1.000 plej ofte uzataj vortoj kun la sintakso [:1000] Python .

Kantoj 8. Uzante la klaso nltk.FreqDist
   collect_all_words def (Vin mem, artikoloj):
       all_words = []
       por artikolo en artikoloj:
           w estas en item.all_words:
               words.append (c)
       revenu all_words

   identify_top_words def (Vin mem, all_words):
       freq_dist = nltk.FreqDist (w.lower () estas en all_words w)
       freq_dist.keys reveno () [: 1000]

Por RSS feed items kun simulita datumoj de la NLTK artikoloj de Reuters, mi bezonas por identigi la kategorioj de ĉiu ero. Por tio, mi legis la dosieron ~ / nltk_data / korpusoj / Reuters / cats.txt menciita antaŭe. Legante dosieron kun Python estas simpla:
   read_reuters_metadata def (Vin mem, cats_file):
       f = open (cats_file, 'r')
       f.readlines linioj = ()
       f.close ()
       reveno linioj

La sekva paŝo estas akiri la rimedojn por ĉiu ero de RSS. La metodo features la klaso RssItem , montrita sube, tion faras. En ĉi tiu metodo, la tabelo all_words Artikolo estas unue reduktas al celo set malgranda forigi duplikatajn vortoj. Tiam top_words estas ripetita kaj komparis ĉi grupo por kontroli lian ĉeesto aŭ foresto. Al hash de 1.000 Bulea estas revenis, kun la ŝlosilo w_ sekvita de la vorto mem. Ĉi Python estas vere konciza.
   def trajtoj (Vin mem, top_words):
       word_set = aro (self.all_words)
       karakterizaĵoj = {}
       w estas en top_words:
           trajtoj ["w_% s"% c] = (w en word_set)
       revenu trajtoj

Tiam mi enspezi trejnado aro de eroj de RSS kaj iliaj individuaj trajtoj kaj paŝo al la algoritmo. La kodo en Listing 9 montras tiun taskon. Notu ke la imposto estas trejnita en akurate unu linio de kodo.

Kantoj 9. Trejnado nltk.NaiveBayesClassifier
   classify_reuters def (self):
         ...
         training_set = []
         por artikolo en rss_items:
             karakterizaĵoj item.features = (top_words)
             tup = (funkciojn, item.category) # tup estas 2-elemento opo
             featuresets.append (tup)
         clasificador = nltk.NaiveBayesClassifier.train (training_set)

La NaiveBayesClassifier , en memoro de la Python programo, estas trejnitaj. Nun nur persisti la aro de eroj de RSS feeds kiu bezonas esti ordo kaj peti la clasificador diveni la kategorio de ĉiu. Simpla.
   por artikolo en rss_items_to_classify:
       karakterizaĵoj item.features = (top_words)
       kategorio = classifier.classify (heroaĵo)

Getting malpli naiva
Kiel deklaris antaŭe, la algoritmo supozas ke ne ekzistas rilato inter la individuaj rimedoj. Do frazoj kiel "maŝina lerno" kaj "lerni maŝino" aŭ "Nova Jorko Jeto" kaj "jeto al Nov-Jorko," estas ekvivalento (al estas stopword). En la kunteksto de natura lingvo, estas evidenta rilato inter tiuj vortoj. Do kiel mi povas instrui la algoritmo esti "malpli naiva" kaj rekoni tiujn rilatojn inter vortoj?
Unu tekniko estas por inkludi la komuna bigrams (du grupoj de vortoj) kaj trigrams (grupoj de tri vortoj) en la aro de trajtoj. Ne surprize, la NLTK havas subtenon por tio en la formo de la funkcioj nltk.bigrams(...) kaj nltk.trigrams(...) . Ĝuste kiel la unua n vortoj estis kolektita en la loĝantaro de vortoj de trejnado datumoj, la bigrams kaj trigrams komune uzita povas identigi kaj uzita kiel karakterizaĵoj.
La rezultoj varias
Rafini datumojn kaj la algoritmo estas arto. Ni cetere normaligi la aro de vortoj, eble kun devenaj? Aŭ inkluzivas pli ol 1.000 ŝlosilaj vortoj? Malpli? Aŭ uzas aron de trejnado datumoj pli? Inkludi pli stopwords aŭ "ĉesi-gramoj"? Ĉi tiuj estas ĉiuj validaj demandoj. Eksperimento kun ili kaj, tra provo kaj eraro, vi atingos la plej bona algoritmo por viaj datumoj. Mi rimarkis, ke 85% estas bona kurzo de sukcesa categorización.
Rekomendo kun la k-proksima Najbaroj
La kliento volis montri erojn de RSS en selektita kategorio aŭ similaj kategorioj. Nun ke la eroj estis klasifikitaj kun Naiva Bayes algoritmo, la unua parto de la postulo estis donacita. La plej malfacila parto estis realigi la postulo "aŭ similaj kategorioj." Tie estas kie la sistemoj rekomendoj de maŝino lernado. Sistemoj rekomendi artikolon rekomendoj bazitaj sur simileco inter aliaj celoj. La produkto rekomendoj de Amazon.com kaj amikoj en Facebook estas bonaj ekzemploj de ĉi funkciojn.
k-proksima Najbaroj (kNN) algoritmo estas la plej komuna rekomendo. La ideo estas proponi aron de etiketoj (tio, kategorioj) kaj aro de datumoj responda al ĉiu el ili. Tiam, la algoritmo komparas datenaroj identigi similajn objektojn. La datumoj aro konsistas tabeloj de nombraj valoroj, kutime en ununormigita limigo 0 al 1. Ĝi povas tial identigi simila etiketoj en aroj. Kontraste naiva Bayes, kiu produktas nur rezulto, kNN povas produkti ordo listo de rekomendoj (te, la valoro de k).
Mi pensis la rekomendo algoritmoj simple kompreni kaj apliki la algoritmoj por la klasifiko, kvankam la kodo kaj lia matematika komplekseco estas tro granda por inkludi tie. Vidu la bonegan novan libron de Manning, Maŝino Lernado en aktivo, por vidi specimenon kodo kNN (vidu Rimedoj por ligilon). En la kazo de la efektivigo de RSS feed items, valoroj estis etikedita ero kategorioj kaj la datuma aro estis tabelo kun la valoroj de ĉiu de la 1.000 ŝlosilaj vortoj. Denove, kreante ke tabelo engaĝas scienco, matematikoj kaj arto. La valoroj de ĉiu vorto en la tabelo povas esti nulo aŭ simpla bulea, procentoj de spritaĵoj de vortoj en la artikolo, eksponenta valoro de ĉi tiu procento aŭ alian valoron.
Konkludo
Discover Python, NLTK kaj maŝina lerno estis interesa kaj agrabla sperto. La Python lingvo estas efika kaj konciza kaj estas parto de mia ilaro programisto nun. Ĝi taŭgas por aplikoj de maŝina lerno, natura lingvo math / scienco. Kvankam ne estas menciita en tiu artikolo, ankaŭ trovos ĝin utila por grafikaĵoj kaj konspiras. Se Python estis ankaŭ en via blinda makulo, mi sugestas ke vi rigardu en tiu lingvo.

Signifas
Lernu
Get produktoj kaj teknologioj
  • Esplori la retejo NLTK Python kaj la kreo de programoj por labori kun datumoj de homa lingvo.
  • Elŝutu la Pip kaj lerni pli pri ĉi tiu ilo por instali kaj administri Python pakoj.
  • Lernu pli pri virtualenv , ilo por krei izolitan Python medioj.
  • Rigardu la norma biblioteko unittest , a Python versio de JUnit.
  • Kontrolu la plug-in pyeclipse por Eklipso.
  • Kontrolu la IDE PyCharm por kompleta aro de iloj de disvolviĝo por plani kun Python kaj Django trajtoj de la strukturo.
  • Uzu IBM juĝo programaro (elŝutebla aŭ DVD) kaj novigi en via venonta disvolviĝo projekto uzanta propran programaron libera programaro speciale por programistoj.
Diskuti
Pri la Aŭtoro
Foto de Chris Joakim Chris Joakim é Senior Software Engineer na Primedia Inc. Chris desenvolve software há mais de 25 anos em várias linguagens, incluindo Clojure, Ruby, Java, Objective-C, JavaScript, CoffeeScript, Flex, Smalltalk, COBOL e agora Python. Ele mora em Davidson, Carolina do Norte, EUA. Em suas horas de lazer, ele corre em maratonas e escreve código. O email de Chris é cjoakim@bellsouth.net.


5 estrelas




terça-feira, 5 de março de 2013

Lernado Python: La Python norma biblioteko


fonto: http://homepages.dcc.ufmg.br/~joaoreis/Site%20de%20tutoriais/aprendendopython/biblioteca_padrao.html
 
La norma biblioteko estas disponeblaj en ĉiuj Python instalado. Ĝi enhavas grandan nombron da utilaj moduloj. Estas grava ke vi familiarizar vin per ĉi biblioteko ĉar la plimulto de iliaj problemoj povas esti solvitaj per lia moduloj.
Ni esploros kelkajn el la plej kutime uzita moduloj. Vi povas trovi detalajn informojn sur la tuta moduloj en la oficiala dokumentaro kiu venas kun Python.
La sys modulo
La sys modulo enhavas sistemo-specifa funkciojn. Ni vidis ke sys.argv estas listo enhavanta la argumentoj pasis sur la komanda linio.
Uzado komandlinio argumentoj (sys.argv)
#! / Usr / bin / python
# - * - Kodigo: iso-8859-1 - * -
importado sys
def readfile (dosiernomo):
'' 'Printas dosieron al cxefeligo.'''
f = file (dosiernomo)
dum Vera:
f.readline linio = ()
se len (linio) == 0:
rompi
presi linio, # Observu la komo
f.close ()
# La skripto komenciĝas tie
se len (sys.argv) <2:
presi 'Neniu ago specifita.'
sys.exit ()
se sys.argv [1]. startswith ('-'):
eblo = sys.argv [1] [2:]
# Get sys.argv [1] sen la unuaj du signoj
se eblo == 'versio':
print 'Versio 1.2'
elif eblo == 'helpo':
print'' '\
Tiu programo montras la cxefeligo dosierojn.
Neniu numero de dosieroj povas esti precizigita.
Opcioj:
- Versio: Montras la version de tiu skribo
- Helpo: Montras helpo'' '
alie:
print 'Nekonata opcio.
sys.exit ()
alie:
por dosiernomo en sys.argv [1:]:
readfile (dosiernomo)

Ekzekuto:
Samuel @ araneo: ~ / python / skriptoj $ python manipulando_args.py
Neniu ago specifitaj.
Samuel @ araneo: ~ / python / skriptoj $ python-helpi manipulando_args.py
Tiu programo montras la cxefeligo dosierojn.
Povas transiris dosieron.
Opcioj:
- Versio: Montras la version de tiu skribo
- Helpo: Montras helpi
Samuel @ araneo: ~ / python / skriptoj $ python-versio manipulando_args.py
Versio 1.2
Samuel @ araneo: ~ / python / skriptoj $ python-eblo manipulando_args.py
Nekonata opcio.
Samuel @ araneo: ~ / python / skriptoj $ python manipulando_args.py test.txt
Programado estas amuza kiam vi finos la laboron.
Se vi volas fari vian laboron ankaŭ fun:
uzi Python!
Samuel @ araneo: ~ / python / skriptoj $

Ĉi tiu programo provas reprodukti la konduto de la kato komando jam konata al uzantoj de Linukso. Vi nur specifi la nomoj de iuj tekstaj dosieroj kaj la programon montras la normo eligo.
Kiam Python programo kuras, tio estas, ne la interpretisto estas en interaga reĝimo, ĉiam estas almenaŭ unu eron en la listo sys.argv kiu estas la programo la nomo kaj tiu nomo estas disponebla en sys.argv [0] a Ekde Pitono komencas rakonti de nulo. La alia komandlinio argumentoj sekvas ĉi artikolo.
Por fari la programon pli uzanto amika ni ofertas kelkajn eblojn kiuj la uzanto povas specifi lerni pli pri la programo. Ni uzas la unuan argumenton por kontroli se iu el tiuj ebloj estis aprobita. Se la opcio estis aprobita - versio, la versio de la programo estas montrata. Se la opcio estis aprobita - help malgranda helpo teksto estas montrata. Ĉi tie ni uzu la funkcion sys.exit por eliri la programon. Por detaloj de ĉi tiu funkcio vidu helpi (sys.exit).
Kiam neniu opcio estas indikita, kaj dosiero nomoj estas pasita al la programo, ĝi simple montras ĉiu linio de la dosiero. La dosieroj estas legitaj unu post alia.
Aliaj interesaj eroj, sys.version sys modulo kiu revenas la versio de la Python interpretisto, sys.stdin kiu korespondas al la normo eniro rivereto, sys.stdout kiu korespondas al la normo eligo rivereto kaj la rojo sys.stderr responda cxeferarigo .
La modulo la
Tiu modulo reprezentas ĝeneralajn karakterizaĵojn de la mastruma sistemo. Estas grava, se vi volas, ke via programo esti platformo sendependaj, tio permesas via programo por funkcii en Vindozo kaj Linukso sen postuli ajnan ŝanĝojn. Unu ekzemplo estas uzi la variablo os.sep anstataŭ uzi la specifa karaktero de la disiĝo vojon mastruma sistemo.
Jen listo de la plej gravaj partoj de ĉi tiu modulo:
  • os.name estas ĉeno kiu specifas la platformo vi uzas kiel "nt" por Vindozo kaj "POSIX" por Linukso;
  • os.getcwd () estas funkcio kiu prenas la aktuala dosierujo;
  • os.getenv () kaj os.putenv () funkcioj estas uzitaj por akiri kaj starigis medio variabloj, respektive;
  • os.listdir () estas funkcio kiu resendas liston de dosierujoj kaj dosieroj de specifita dosierujo;
  • os.remove () funkcio estas uzita por forigi dosieron;
  • os.system () estas funkcio uzata por ruli iu komando en konzolo;
  • os.linesep estas ĉeno kiu redonas la linio finilo de la platformo uzata. Por Vindozo estas '\ r \ n', por Linukso estas '\ n' kaj por Mac estas '\ r';
  • os.path.split () estas funkcio kiu redonas la katalogo vojo kaj la dosiero pasis kiel argumento:
Os.path.split >>> ('/ home / Samuel / test.txt')
('/ Hejmo / Samuel', 'test.txt')
>>>
  • os.path.isfile () kaj os.path.isdir () estas funkcioj kiuj kontrolu ĉu vojo pasis kiel argumento referencas al dosiero aŭ dosierujo, respektive. Same os.path.exists () kontrolas ke vojo ekzistas.
Esplori la lingvo dokumentado por detaloj pri tiuj funkcioj kaj variabloj.

domingo, 3 de março de 2013

Kreante la KD deĉenigis MODELO DIFINO DOSIERO

fonto: http://www.speech.cs.cmu.edu/sphinxman/scriptman1.html#3g

Maŝin-instruo kun kontinuaj modeloj

La sekva paŝo estas la KD-deĉenigis trejnado, en kiu HMMs estas trejnitaj por ĉiuj kunteksto-dependa telefonoj (kutime triphones) kiu vidas en la trejnado korpuso. Por la KD-deĉenigis trejnado, ni unue bezonas por generi modelo difino dosiero por ĉiuj triphones occuring en la trejnado aro. Ĉi tiu estas farita en pluraj paŝoj:
    Unue, liston de ĉiuj triphones ebla en la vortprovizo estas generita de la vortaro. Por atingi ĉi kompleta listo de triphones de la vortaro, ĝi estas unua necesa por skribi la liston de telefonoj en la jena formato:
      phone1 0 0 0 0
     phone2 0 0 0 0
     phone3 0 0 0 0
     phone4 0 0 0 0
     ...
    
    La phonelist uzata por la CI trejnado devas esti uzata por generi tion, kaj la ordo en kiu la telefonoj estas listigitaj devas esti la sama. Tuj poste, portempa vortaro estas generita, kiu havas ĉiujn vortojn krom la kompletigo vortoj (vortoj enmetitaj en + + () + +). La eniro
      SIL SIL
    
    devas esti adiciita al ĉi provizora vortaro, kaj la vortaro devas esti ordo en alfabeta ordo. La programo "quick_count" provizita kun la sfinkso-III pako povas nun esti uzata por generi la listo de ĉiuj eblaj triphones de la provizora vortaro. Ĝi portas la sekvaj argumentoj:
    FLAG PRISKRIBO
    -Q deviga flago diri quick_count konsideri tutan vorton paroj dum konstrui triphone listo
    -P formatan phonelist
    -B provizora vortaro
    -O eligo triphone listo
    Jen tipa eliro el quick_count
      AA (AA, AA) s 1
     AA (AA, AE) b 1
     AA (AA, AO) 1 1
     AA (AA, AW) e 1
    
    La "1" en AA (AA, AO) 1 indikas ke tiu estas vorto-interna triphone. Tio ĉi estas carry super el Sfinkso-II. La eliro de quick_count devas esti nun skribita en la jena formato:
      AA AA AA s
     AA AA AE b
     AA AA AO i
     AA AA AW TTT
    
    Ĉi tiu povas esti farita per simple anstataŭante "(", ",", kaj ")" en la eligo de quick_count de spaco kaj presi nur la unuaj kvar kolumnoj. Dum tio, ĉiuj okazoj de "1" devas esti anstataŭita de "i". Al la supro de la rezultanta dosiero la listo de CI telefonoj devas appened en la jena formato
      AA ---
     AE ---
     AO ---
     AW ---
     ..
     ..                                                         
     AA AA AA s
     AA AA AE b
     AA AA AO i
     AA AA AW TTT
    

    Ekzemple, se la eligo de la quick_count stokas en dosiero nomata "quick_count.out", la jena perl komando generos la telefono lerta en la dezirata formo. perl-Nae '$ F [0] = ~ s / \ (| \) | \, / / g; $ F [0] = ~ s/1/i/g; print $ F [0]; if ($ F [0] = ~ / \ s + $ /) {print "i"}; print "\ n" 'quick_count.out La supra listo de triphones (kaj poŝtelefonoj) estas konvertita al la modelo difino dosiero listigas ĉiujn eblajn triphones de la vortaro. La programo uzita de ĉi tiu estas "mk_model_def" kun jenaj argumentoj nombro de ŝtatoj por HMM
    FLAG PRISKRIBO
    -Moddeffn modelo difino dosieron kun ĉiuj eblaj triphones (alltriphones_mdef) esti skribita
    -Phonelstfn Listo de ĉiuj triphones
    -N_state_pm
    En la venonta paŝo ni trovas la nombro da fojoj ĉiu el la triphones listigitaj en la alltriphones_mdef okazis en la trejnado korpuso Por fari tion ni nomas la programo "param_cnt" kiu prenas la sekvaj argumentoj:
    FLAG PRISKRIBO
    -Moddeffn modelo difino dosieron kun ĉiuj eblaj triphones (alltriphones_mdef)
    -Ts2cbfn prenas la valoro ". daŭrigo." se vi konstruas kontinua modeloj
    -Ctlfn kontroli dosieron responda al via trejnado transskriboj
    -Lsnfn transskribo dosiero por trejnado
    -Dictfn trejnado vortaro
    -Fdictfn plenigita vortaro
    -Paramtype skribi "telefono" cxi tie, sen la duoblaj citiloj
    -Segdir / Dev / null
    param_cnt skribas el la grafoj por ĉiu el la triphones sur stdout. Ĉiuj aliaj mesaĝoj senditaj al stderr. La stdout do devas esti direktita al dosiero. Se vi uzas csh aux tcsh estus farita en la jena maniero:
      (Param_cnt [argumentoj]> triphone_count_file)> &!  LOG
    
    Jen ekzemplo de la eligo de ĉi tiu programo
      + + --- Rubo 98
     + Ridi + --- 29
     SIL --- 31694
     AA --- 0
     AE --- 0
     ...
     AA AA AA s 1
     AA AA AE s 0
     AA AA AO s 4
    
    La fina nombro en ĉiu vico montras la nombron de fojoj ke aparta triphone (aŭ plenigita telefono) estas okazis en la trejnado korpuso. Ne ke se ĉiuj eblaj triphones de CI telefono estas listigitaj en la all_triphones.mdef la CI telefono havos 0 grafoj ĉar ĉiuj okazoj de gxi estus mapita al triphone. Tiu listo de rakontita triphones uzas por Shortlist la triphones kiuj okazis minimuma nombro (sojlo) de fojoj. La antaŭselektita triphones aperas en la sama formato kiel la dosiero el kiu ili estis selektitaj. La antaŭselektita triphone listo havas la saman formaton kiel la triphone listo uzita por generi la all_triphones.mdef. La formatan liston de CI telefonoj devas esti inkluzivita en tiu kiel antauxe. Do, en la pli frua ekzemplo, se sojlo de 4 estis uzataj, ni akirus la antaŭselektita triphone lerta kiel
      AA ---
     AE ---
     AO ---
     AW ---
     ..
     ..                                 
     AA AA AO s
     ..
    
    La sojlo estas ĝustigitaj tia ke la tuta nombro de triphones super la sojlo estas malpli ol la maksimuma nombro de triphones ke la sistemo povas trejni (aŭ ke vi volas trejni). Ĝi estas bona por trejni kiel multaj triphones ebla. La maksimuma nombro da triphones povas tamen esti dependa de la disponebla memoro en via maŝino. La loĝistiko rilataj al ĉi estas priskribitaj en la komenco de ĉi manlibro. Notu ke thresholding estas kutime farita tiel redukti la nombron de triphones, por ke la rezultanta modeloj estos sufiĉe malgranda por havi en la komputilo la memoro. Se ĉi tiu ne estas problemo, tiam la sojlo povas agordi al plej malgranda nombro. Se la triphone okazas tro malmultaj fojoj, tamen, (tio estas, se la sojlo estas tro malgranda), tie estos plu sufiĉe da datumoj por trejni la HMM stato distribuoj konvene. Ĉi tio kondukas al malbone taksita KD deĉenigis modeloj, kiu siavice povas tuŝi la decido arboj kiuj devas esti konstruita uzanta tiuj modeloj en la sekva granda paŝo de la trejnado.
    Modelo difino dosiero estas nun kreita por inkluzivi nur tiuj antaŭselektita triphones. Ĉi tiu estas la modelo fino difino dosiero estu uzata por la KD deĉenigis trejnado. La reduktita triphone listo estas tiam la modelo difino dosieron per mk_model_def kun jenaj argumentoj: multaj regnoj por HMM
    FLAG PRISKRIBO
    -Moddeffn modelo difino dosiero por KD deĉenigis trejnado
    -Phonelstfn Listo de antaŭselektita triphones
    -N_state_pm
Fine, do, modelo difino dosiero kiu listigas ĉiujn CI telefonoj kaj vidis triphones estas konstruita. Ĉi tiu dosiero, kiel la CI modelo difino dosiero, asignas unika id estas al ĉiu HMM stato kaj utilas kiel referenco dosiero por manipuli kaj identigi la KD-deĉenigis modelo parametroj. Jen ekzemplo de la KD-deĉenigis modelo difino dosiero: Se vi listigitaj kvin telefonoj en via phones.list dosiero,
SIL B AE T
kaj specifi ke vi volas konstrui tri ŝtataj HMMs por ĉiu el tiuj telefonoj, kaj se vi havas parolo listigitaj en via transskribo dosiero:
<s> BAT A TAB </ s> por kiu via vortaro kaj fillerdict elementoj estas:
  Fillerdict:
 <s> SIL
 </ S> SIL
  Vortaro:
 Al AX 
 BAT B AE T
 TAB T AE B
tiam via KD-deĉenigis modelo difino dosiero aspektos tiel ĉi:
  # Generated by / mk_model_def on Tue Mar 10 14:57:15 2000
 0.3
 5 n_base
 7 n_tri
 48 n_state_map
 36 n_tied_state
 15 n_tied_ci_state
 5 n_tied_tmat                                                                  
 #
 # Kolumnoj difinoj
 # Bazo lft rt p ATTRIB tmat ... stato id La ...
 SIL --- plenigita 0 0 1 2 N
 AE --- n / a 1 3 4 5 N
 AX --- n / a 2 6 7 8 N
 B --- n / a 3 9 10 11 N
 T --- n / a 4 12 13 14 N
 AE BT en / a 1 15 16 17 N
 AE TB en / a 1 18 19 20 N
 AX TT sn / a 2 21 22 23 N
 B SIL AE bn / a 3 24 25 26 N
 B AE SIL eo / de 3 27 28 29 N
 T AE AX eo / al 4 30 31 32 N
 T AX AE bn / a 4 33 34 35 N

 La # linioj estas simple komentojn.  La resto de la variabloj signifi la sekvajn:

   n_base: ne.  de CI telefonoj (ankaŭ nomata "bazo" telefonoj), 5 tie
   n_tri: ne.  de triphones, 7 en ĉi tiu kazo
   n_state_map: Tuta ne.  de HMM statoj (emisiaj kaj ne-emisiaj)
                 La Sfinkso appends ekstran fina ne-emisiaj stato
                 al cxiu HMM, de ĉi tie dum 5 +7 telefonoj, ĉiu precizigita per
                 la uzanto esti modelita per 3-stato HMM, ĉi tiu numero
                 estos 12phones * 4states = 48
   n_tied_state: ne.  de ŝtatoj de ĉiuj telefonoj post stato-interŝanĝo estas farita.
                 Ni ne dividas ŝtatoj en tiu etapo.  Sekve ĉi tiu nombro estas la
                 sama kiel la nombro de emisiaj ŝtatoj, 12 * 3 = 36
 n_tied_ci_state: ne.  de ŝtatoj por via CI telefonoj post stato-interŝanĝo     
                 estas farita.  La CI ŝtatoj ne estas dividitaj, nun aŭ poste.
                 Ĉi tiu nombro estas tial denove la tuta numero de elsendante CI
                 ŝtatoj, 5 * 3 = 15
  n_tied_tmat: La tuta nombro de transiro matricoj estas ĉiam la sama
                  kiel la tuteca nombro de CI telefonoj esti modelita.  Ĉiuj triphones
                  por donita telefono dividas la saman traira matrico.  Ĉi
                  nombro estas tial 5.

 Kolumnoj difinoj: La jenaj kolumnoj estas difinita:
        bazo: nomo de ĉiu telefono
        lft: maldekstra kadro de la telefono (- se neniu)
        rt: dekstra kunteksto de la telefono (- se neniu)
        p: pozicio de triphone.  Kvar pozicio markiloj estas subtenataj:
                b = vorto begining triphone
                kaj = vorto finas triphone
                mi = vorto interna triphone
                s = sola vorto triphone 
        ATTRIB: atributo de telefono.  En la telefono listo, se la telefono estas "SIL",
                aŭ se la telefono estas enfermita per "+", kiel en "+ BANG +", tiuj
               telefonoj estas interpretitaj kiel ne-parolado okazaĵoj.  Tiuj estas
                ankaŭ nomita "plenigita" telefonoj, kaj la atributo "plenigita" estas
                atribuita al ĉiu tia telefono.  La bazo telefonoj kaj la
                triphones ne havas specialajn atributoj, kaj do estas 
                etikedita kiel "n / a", staranta por "neniu atributo"
       tmat: la id de la traira matrico asociita kun la telefono      
  ŝtata id La: la IDS de la HMM ŝtatoj ligita kun ajna telefono.  Ĉi tiu listo
                estas eksigita de la "N", kiu staras por ne-emisiaj
                ŝtato.  Neniu id atribuas al ĝi.  Tamen, ekzistas, kaj estas
                listigita.

CREATING THE CD UNTIED MODEL DEFINITION FILE

TRAINING CONTINUOUS MODELS

The next step is the CD-untied training, in which HMMs are trained for all context-dependent phones (usually triphones) that are seen in the training corpus. For the CD-untied training, we first need to to generate a model definition file for all the triphones occuring in the training set. This is done in several steps:
    First, a list of all triphones possible in the vocabulary is generated from the dictionary. To get this complete list of triphones from the dictionary, it is first necessary to write the list of phones in the following format:
    phone1 0 0 0 0
    phone2 0 0 0 0
    phone3 0 0 0 0
    phone4 0 0 0 0
    ...
    
    The phonelist used for the CI training must be used to generate this, and the order in which the phones are listed must be the same. Next, a temporary dictionary is generated, which has all words except the filler words (words enclosed in ++()++ ). The entry
    SIL    SIL
    
    must be added to this temporary dictionary, and the dictionary must be sorted in alphabetical order. The program "quick_count" provided with the SPHINX-III package can now be used to generate the list of all possible triphones from the temporary dictionary. It takes the following arguments:
    FLAG DESCRIPTION
    -q mandatory flag to tell quick_count to consider all word pairs while constructing triphone list
    -p formatted phonelist
    -b temporary dictionary
    -o output triphone list
    Here is a typical output from quick_count
    AA(AA,AA)s              1
    AA(AA,AE)b              1
    AA(AA,AO)1              1
    AA(AA,AW)e              1
    
    The "1" in AA(AA,AO)1 indicates that this is a word-internal triphone. This is a carry over from Sphinx-II. The output from quick_count has to be now written into the following format:
    AA AA AA s
    AA AA AE b
    AA AA AO i
    AA AA AW e
    
    This can be done by simply replacing "(", ",", and ")" in the output of quick_count by a space and printing only the first four columns. While doing so, all instances of " 1" must be replaced by " i". To the top of the resulting file the list of CI phones must be appened in the following format
    AA - - -
    AE - - -
    AO - - -
    AW - - -
    ..
    ..                                                         
    AA AA AA s
    AA AA AE b
    AA AA AO i
    AA AA AW e
    

    For example, if the output of the quick_count is stored in a file named "quick_count.out", the following perl command will generate the phone list in the desired form. perl -nae '$F[0] =~ s/\(|\)|\,/ /g; $F[0] =~ s/1/i/g; print $F[0]; if ($F[0] =~ /\s+$/){print "i"}; print "\n"' quick_count.out The above list of triphones (and phones) is converted to the model definition file that lists all possible triphones from the dictionary. The program used from this is "mk_model_def" with the following arguments number of states per HMM
    FLAG DESCRIPTION
    -moddeffn model definition file with all possible triphones(alltriphones_mdef)to be written
    -phonelstfn list of all triphones
    -n_state_pm
    In the next step we find the number of times each of the triphones listed in the alltriphones_mdef occured in the training corpus To do this we call the program "param_cnt" which takes the following arguments:
    FLAG DESCRIPTION
    -moddeffn model definition file with all possible triphones(alltriphones_mdef)
    -ts2cbfn takes the value ".cont." if you are building continuous models
    -ctlfn control file corresponding to your training transcripts
    -lsnfn transcript file for training
    -dictfn training dictionary
    -fdictfn filler dictionary
    -paramtype write "phone" here, without the double quotes
    -segdir /dev/null
    param_cnt writes out the counts for each of the triphones onto stdout. All other messages are sent to stderr. The stdout therefore has to be directed into a file. If you are using csh or tcsh it would be done in the following manner:
    (param_cnt [arguments] > triphone_count_file) >&! LOG
    
    Here's an example of the output of this program
    +GARBAGE+ - - - 98
    +LAUGH+ - - - 29
    SIL - - - 31694
    AA - - - 0
    AE - - - 0
    ...
    AA AA AA s 1
    AA AA AE s 0
    AA AA AO s 4
    
    The final number in each row shows the number of times that particular triphone (or filler phone) has occured in the training corpus. Not that if all possible triphones of a CI phone are listed in the all_triphones.mdef the CI phone itself will have 0 counts since all instances of it would have been mapped to a triphone. This list of counted triphones is used to shortlist the triphones that have occured a minimum number (threshold) of times. The shortlisted triphones appear in the same format as the file from which they have been selected. The shortlisted triphone list has the same format as the triphone list used to generate the all_triphones.mdef. The formatted list of CI phones has to be included in this as before. So, in the earlier example, if a threshold of 4 were used, we would obtain the shortlisted triphone list as
    AA - - -
    AE - - -
    AO - - -
    AW - - -
    ..
    ..                                 
    AA AA AO s
    ..
    
    The threshold is adjusted such that the total number of triphones above the threshold is less that the maximum number of triphones that the system can train (or that you wish to train). It is good to train as many triphones as possible. The maximum number of triphones may however be dependent on the memory available on your machine. The logistics related to this are described in the beginning of this manual. Note that thresholding is usually done so to reduce the number of triphones, in order that the resulting models will be small enough to fit in the computer's memory. If this is not a problem, then the threshold can be set to a smaller number. If the triphone occurs too few times, however, (ie, if the threshold is too small), there will not be enough data to train the HMM state distributions properly. This would lead to poorly estimated CD untied models, which in turn may affect the decision trees which are to be built using these models in the next major step of the training.
    A model definition file is now created to include only these shortlisted triphones. This is the final model definition file to be used for the CD untied training. The reduced triphone list is then to the model definition file using mk_model_def with the following arguments: number of states per HMM
    FLAG DESCRIPTION
    -moddeffn model definition file for CD untied training
    -phonelstfn list of shortlisted triphones
    -n_state_pm
Finally, therefore, a model definition file which lists all CI phones and seen triphones is constructed. This file, like the CI model-definition file, assigns unique id's to each HMM state and serves as a reference file for handling and identifying the CD-untied model parameters. Here is an example of the CD-untied model-definition file: If you have listed five phones in your phones.list file,
SIL B AE T
and specify that you want to build three state HMMs for each of these phones, and if you have one utterance listed in your transcript file:
<s> BAT A TAB </s> for which your dictionary and fillerdict entries are:
Fillerdict:
<s>   SIL
</s>  SIL
Dictionary:
A      AX 
BAT    B AE T
TAB    T AE B
then your CD-untied model-definition file will look like this:
# Generated by /mk_model_def on Thu Aug 10 14:57:15 2000
0.3
5 n_base
7 n_tri
48 n_state_map
36 n_tied_state
15 n_tied_ci_state
5 n_tied_tmat                                                                  
#
# Columns definitions
#base lft  rt p attrib   tmat  ...state id's ...
SIL     -   -  - filler    0    0       1      2     N
AE      -   -  -    n/a    1    3       4      5     N
AX      -   -  -    n/a    2    6       7      8     N
B       -   -  -    n/a    3    9       10     11    N
T       -   -  -    n/a    4    12      13     14    N
AE      B   T  i    n/a    1    15      16     17    N
AE      T   B  i    n/a    1    18      19     20    N
AX      T   T  s    n/a    2    21      22     23    N
B       SIL AE b    n/a    3    24      25     26    N
B       AE  SIL e   n/a    3    27      28     29    N
T       AE  AX e    n/a    4    30      31     32    N
T       AX  AE b    n/a    4    33      34     35    N

The # lines are simply comments. The rest of the variables mean the following:

  n_base      : no. of CI phones (also called "base" phones), 5 here
  n_tri       : no. of triphones , 7 in this case
  n_state_map : Total no. of HMM states (emitting and non-emitting)
                The Sphinx appends an extra terminal non-emitting state
                to every HMM, hence for 5+7 phones, each specified by
                the user to be modeled by a 3-state HMM, this number
                will be 12phones*4states = 48
  n_tied_state: no. of states of all phones after state-sharing is done.
                We do not share states at this stage. Hence this number is the
                same as the total number of emitting states, 12*3=36
n_tied_ci_state:no. of states for your CI phones after state-sharing     
                is done. The CI states are not shared, now or later.
                This number is thus again the total number of emitting CI
                states, 5*3=15
 n_tied_tmat   : The total number of transition matrices is always the same
                 as the total number of CI phones being modeled. All triphones
                 for a given phone share the same transition matrix. This
                 number is thus 5.

Columns definitions: The following columns are defined:
       base  : name of each phone
       lft   : left-context of the phone (- if none)
       rt    : right-context of the phone (- if none)
       p     : position of a triphone. Four position markers are supported:
               b = word begining triphone
               e = word ending triphone
               i = word internal triphone
               s = single word triphone 
       attrib: attribute of phone. In the phone list, if the phone is "SIL",
               or if the phone is enclosed by "+", as in "+BANG+", these
              phones are interpreted as non-speech events. These are
               also called "filler" phones, and the attribute "filler" is
               assigned to each such phone. The base phones and the
               triphones have no special attributes, and hence are 
               labelled as "n/a", standing for "no attribute"
      tmat   : the id of the transition matrix associated with the phone      
 state id's  : the ids of the HMM states associated with any phone. This list
               is terminated by an "N" which stands for a non-emitting
               state. No id is assigned to it. However, it exists, and is
               listed.

ENTRENAMIENTO kuntekston SENDEPENDA Modeloj

ENTRENAMIENTO kontinua Modeloj

Iam la ebena inicialización estas farita, vi estas preta por komenci trejnado la akustiko modeloj por la bazo aŭ "kunteksto-sendependa" aŭ CI telefonoj. Tiu paŝo estas nomata CI-trejnado. En CI-trejnado, la plat-inicializado modeloj estas re-taksita tra la antaŭen-malantaŭen re-korinklino algoritmo nomata Baum-Welch algoritmo. Ĉi tiu estas ripeta re-korinklino procezo, do vi devas kuri multaj "pasas" de la Baum-Welch re-korinklino super via trejnado datumoj. Ĉiu de ĉi tiuj paŝoj, aŭ ripetoj, ripetas, rezultigas iomete pli bonan aron de modeloj por la CI telefonoj. Tamen, ĉar la objektiva funkcio maksimumigita en ĉiu de la tezo pasas estas la verŝajneco, tro multaj iteraciones estus finfine rezultos en modeloj kiuj persvadis tre proksime al la trejnado datumoj. vi eble ne volas ke ĉi tio okazas pro multaj kialoj. Tipe, 5-8 iteraciones de Baum-Welch estas sufiĉa por prenantaj bonaj taksoj de la CI modeloj. Vi povas aŭtomate determinas la nombron de ripetoj, ripetas, ke vi bezonas rigardi la tuta verŝajneco de la trejnado datumojn al la fino de la unua ripeto kaj elektante por "konverĝo rilatumo" de likelihoods. Ĉi tiu estas simple la rilatumo de la plena verŝajneco en la nuna ripeto al tiu de la antaŭa ripeto. Kiel la modeloj ricevas pli kaj pli persvadis al la trejnado datumojn en ĉiu ripeto, la trejnado datumoj likelihoods tipe pliigi monotone. La konverĝo rilatumo estas tiel malgranda pozitiva nombro. La konverĝo rilatumo iĝas pli kaj pli kiel la iteraciones progreso, ĉar ĉiufoje kiam la aktualaj modeloj estas iom malpli diferencas de la antaŭaj. Konverĝo kvocientoj estas datumoj kaj tasko specifa, sed tipa valoroj al kiuj vi povas haltigi la Baum-Welch iteraciones por via CI trejnado povas varii de 0.1-0.001. Kiam la modeloj estas varianco-ununormigita, la konverĝo kvocientoj estas multe pli malgranda.
La plenumebla uzata por ruli Buam-Welch ripeto nomas "BW", kaj prenas la sekvan ekzemplon argumentojn por trejnado kontinua CI modeloj:
FLAG PRISKRIBO
-Moddeffn modelo difino dosiero por CI telefonoj
-Ts2cbfn ĉi flago devas esti aro al ". daŭrigo." se vi trejnis kontinua modeloj, kaj al ". semi". se vi trejnis duon-kontinua modeloj , sen la duoblaj citiloj
-Mixwfn nomo de la dosiero en kiu la miksaĵo-pezoj de la antaŭa ripeto estas stokitaj. Kompletan padon devas esti provizita
-Mwfloor Etaĝo valoro por la miksaĵo pezoj. Ajnan numeron sub la planko valoro estas metita sur la plankon valoro.
-Tmatfn nomo de la dosiero en kiu la transiro matricoj de la antaŭa ripeto estas stokitaj. Kompletan padon devas esti provizita
-Meanfn nomo de la dosiero kiun la rimedoj de la antaŭa ripeto estas stokitaj. Kompletan padon devas esti provizita
-Varfn nomo de la dosiero en kiu la varianzas fromt li antaŭa ripeto estas stokitaj. Kompletan padon devas esti provizita
-Dictfn Vortaro
-Fdictfn Plenigita vortaro
-Ctlfn kontrolo dosieron
-Parto Vi povas dividi la trejnado en N egalaj partoj per opcio flagon. Se estas M eldiroj en via kontrolo dosiero, tiam ĉi ebligos al vi kuri la trejnado aparte sur ĉiu (M / N) th parto. Tiu flago povas esti agordita por specifi, kiu el tiuj partoj vi volas aktuale trejni plu. Kiel ekzemplo, se via tuta numero de partoj estas 3, tiu flago povas preni unu el la valoroj 1,2 aŭ 3
-Npart nombro de partoj en kiuj vi jam fendis trejnado
-Cepdir dosierujo kie viaj karakterizaĵo dosieroj stokitaj
-Cepext la pligrandigo kiu venas post la nomo listigitaj en la kontrolo dosiero. Ekzemple, vi povas havi dosiero nomata / b / cd kaj eble listigita a / b / c en via kontrolo dosiero. Tiam ĉi flago devas esti donita la argumento "d", sen la duoblaj citiloj aux la skalara antaux gxi
-Lsnfn nomo de la transskribo dosieron
-Accumdir Interaj rezultoj de ĉiu parto de via trejnado estos skribita en ĉi tiu dosierujo. Se vi havas T signifas taksi, tiam la grandeco de la meznombro buffer de la aktuala parto de via trejnado estos T * 4 bajtoj (diri). Estos ankaux esti varianco buffer, buffer por miksaĵo pezoj kaj buffer por transiro matricoj
-Varfloor minimuma varianco valoro permesita
-Topn ne. de gaussians konsideri por komputanta la verŝajneco de ĉiu ŝtato. Ekzemple, se vi havas 8 gaussians / stato modeloj kaj topn estas 4, do la 4 plej verŝajne gaŭsa estas uzitaj.
-Abeam antaŭen beamwidth
-Bbeam malantauxen beamwidth
-AGC aŭtomata gajno kontrolo
-CMN cepstral meznombro normaligo
-Varnorm varianco normaligo
-Meanreest signifas re-proksumumo
-Varreest varianco re-proksumumo
-2passvar Opcio ĉi flago por "jes" lasas BW uzi la antaŭa rimedoj en la korinklino de la varianco. La nuna varianco estas tiam taksis kiel E [(x - prev_mean) 2]. Se ĉi tiu flago estas metita al "ne" la nuna takso de la rimedoj estas uzataj por taksi varianzas. Tio necesigas la korinklino de varianco kiel E [x 2] - (E [x]) 2, malstabila proksimumilo ke kelkfoje rezultas en negativaj taksoj de la varianco pro aritmetiko imprecision
-Tmatreest re-takso transiro matricoj aŭ ne
-Heroaĵo karakterizaĵo agordo
-Ceplen longo de baza trajto vektoro
Se vi kuras la trejnado en multaj partoj, aŭ eĉ se vi kuros al la trejnado en unu parto, la ruleblan por Baum-Welch priskribita supre generas nur intera buffer (s). La modelo fino parametroj, nome la rimedoj, varianzas, miksaĵo-pezoj kaj transiro matricoj, devas esti taksita per la valoroj stokitaj en tiuj bufroj. Ĉi tiu estas farita de la ruleblan nomita "normo", kiu portas la sekvajn argumentojn:
FLAG PRISKRIBO
-Accumdir Intera buffer katalogo
-Heroaĵo karakterizaĵo agordo
-Mixwfn nomo de la dosiero kiun vi volas skribi la miksaĵo pezoj. Kompletan padon devas esti provizita
-Tmatfn nomo de la dosiero kiun vi volas skribi la transiro matricoj. Kompletan padon devas esti provizita
-Meanfn nomo de la dosiero kiun vi volas skribi la rimedoj. Kompletan padon devas esti provizita
-Varfn nomo de la dosiero kiun vi volas skribi la varianzas. Kompletan padon devas esti provizita
-Ceplen longo de baza trajto vektoro
Se vi ne re-taksita iu el la modelo parametroj en la BW paŝo, tiam la responda flago devas esti preterlasita de la argumento donita al la normo ruleblan. La plenumebla estos alie provu legi neekzistanta buffer de la buffer dosierujon kaj ne iros tra. Tial se vi starigis-meanreest esti "ne" en la argumento por BW, tiam la flago-meanfn devas ne estos transdonita en la argumento por normo. Ĉi tio estas utila ĉefe dum adapto. Iteraciones de Baum-Welch kaj normo fine rezultos CI modeloj. La iteraciones povas haltis tuj la verŝajneco de la trejnado datumoj konverĝas. La modelo parametroj komputita per normo en la fina ripeto estas nun uzata por pravalorizi la modeloj por kunteksto-dependa telefonoj (triphones) kun deĉenigis ŝtatoj. Ĉi tiu estas la sekva granda paŝo de la trejnado procezo. Ni raportos al la procezo de formado triphones HMMs kun deĉenigis ŝtatoj kiel la "KD deĉenigis trejnado".