Corpora Processing Software

Obsah

Stahování, zpracování a indexování rozsáhlých textových korpusů (corpproc)

Tento SW slouží ke stažení, zpracování a indexaci rozsáhlých textových korpusů (v řádu desítek TB).

Popis zpracování

Zpracování je rozděleno do několika kroků. K jednotlivým krokům byly vytvořeny skripty zjednodušující práci pomocí jednotných argumentů a umožňují zpracování provádět na jednom stroji, nebo paralelně na více strojích.

Veškeré zdrojové texty programů a skripty jsou v repozitáři corpora_processing_sw a případné chybějící závislosti (knihovny) jsou na serverech KNOT dostupné v /mnt/minerva1/nlp/projects/corpproc (kdo nemá přístup, zašleme na vyžádání).

1. Distribuce programů / dat ke zpracování

Skript umožňuje přerozdělit data (soubory) mezi dané servery. Data to rozděluje na základě jejich velikosti tak, aby všechny servery dostaly podobné množství dat. Přepínačem -a se přerozdělování vypne a každý soubor bude nakopírován na všechny servery. To je vhodné především k distribuci programů pro zpracování.

 ./processing_steps/1/distribute.py

Použití:

 ./distribute.py [-i INPUT_DIRECTORY] -o OUTPUT_DIRECTORY -s SERVER_LIST [-a] [-e ERRORS_LOG_FILE]

Například:

 ./distribute.py -i ~/data_to_distribution/ -o /mnt/data/project/data/ -s ~/servers
 # Všechny soubory z adresáře ~/data_to_distribution/ přerozdelí mezi servery, určenými souborem ~/servers.
 # Výstupním adresářem je /mnt/data/project/data/. Pokud adresář data na některém stroji neexistuje, pokusí se ho skript vytvořit.
 ./distribute.py -i ~/NLP-slave-0.0.1-SNAPSHOT-jar-with-dependencies.jar -o /mnt/data/commoncrawl/software/ -s ~/servers -a
 # Zkopíruje program NLP-slave na servery, určené souborem ~/servers.
 # Výstupním adresářem je /mnt/data/commoncrawl/software/. Pokud adresář software na některém stroji neexistuje, pokusí se ho skript vytvořit.

1. a) Stažení dumpu Wikipedie

Pro extrakci čistého textu z Wikipedie slouží program WikiExtractor (https://github.com/bwbaugh/wikipedia-extractor). Spouští se:

 cd /mnt/minerva1/nlp/corpora_datasets/monolingual/english/wikipedia/
 ./download_wikipedia_and_extract_html.sh 20151002

Skript v pracovním adresáři očekává soubor hosts.txt se seznamem serverů (1 na řádek), na kterých se má spustit

/mnt/minerva1/nlp/corpora_datasets/monolingual/english/wikipedia/tools/WikiExtractor.py

Výsledkem je sada cca 100MB souborů rozdělených na uvedené servery v /mnt/data/wikipedia/enwiki-.../html_from_xml/enwiki=...

1. b) Stažení CommonCrawlu

Pro stažení WARC je potřeba znát označení CommonCrawlu, např. "2015-18"

 ./processing_steps/1b/download_commoncrawl/dl_warc.sh

stažené soubory jsou v

 /mnt/data/commoncrawl/CC-označení Commoncrawlu/warc/

pomocné soubory do

 /mnt/minerva1/nlp-2/download_commoncrawl/CC-označení Commoncrawlu/download/

Následně je možné vypočítat statistiku URI spuštěním:

 ./processing_steps/1b/uri_stats.sh

výsledek se uloží do

 /mnt/minerva1/nlp-2/download_commoncrawl/CC-označení Commoncrawlu/uri/

a na jednotlivých strojích jsou data v

 /mnt/data/commoncrawl/CC-označení Commoncrawlu/uri/

1. c) Stažení webových stránek z RSS zdroje

K získání url ze zadaného RSS zdroje slouží:

 ./processing_steps/1c/collect.py

Použití:

 ./collect.py [-i INPUT_FILE] [-o OUTPUT_FILE [-a]] [-d DIRECTORY|-] [-e ERRORS_LOG_FILE]
 
 -i   --input     vstupní soubor s RSS url oddělenými '\n' (pokud není nastaven jsou očekávány na stdin)
 -o   --output    výstupní soubor pro uložení vyparsovaných url (pokud není nastaven jsou tisknuty na stdout)
 -a   --append    výstupní soubor je v režimu přidávání
 -d   --dedup     deduplikace získávaných odkazů (podle shody url), volitelně může být zadána složka se soubory se seznamem již nasbíraných url, tyto url budou zahrnuty do deduplikace, v režimu -a je výstupní soubor táké zahrnut
 -e   --errors    pokud je nastaven jsou chyby logovány do tohoto souboru s aktuálním datem a časem

Například:

 ./collect.py -i rss -o articles -a
 # Do souboru articles přidá url z RSS zdrojů v souboru rss

Pro stažení webových stránek dle zadaného seznamu url a ukložení do WARC archívu slouží:

 ./processing_steps/1c/download.py

Použití:

 ./download.py [-i INPUT_FILE] -o OUTPUT_FILE [-e ERRORS_LOG_FILE]
 
 -i   --input     vstupní soubor s url (pokud není nastaven jsou očekávány na stdin)
 -o   --output    výstupní soubor pro uložení warc archívu
 -r   --requsts   limit počtu požadavků za minutu na jednu doménu (výchozí 10)
 -e   --errors    pokud je nastaven jsou chyby logovány do tohoto souboru s aktuálním datem a časem

Skript stránky nestahuje v pořadí podle vstupního souboru, ale, aby nedocházelo k "útokům", stahuje rovnoměrně podle domény. Zároveň je možné nastavit limit požadavků na doménu za minut. V případě že je limit vyčerpán u všech domén je stahování pozastaveno, než je limit obnoven. Limit se obnovuje každých 6s (1/10 minuty) a to na 1/10 celkového limitu.

Pokud dojde ke stahování k jakékoliv chybě (cokoliv kromě kódu 200), je celá doména vyřazena ze stahování.

Například:

 ./download.py -i articles -o today.warc.gz
 # Stáhne stránky jejichž url jsou v souboru articles do archívu today.warc.gz

2. Vertikalizace

Popis vertikálneho formátu

Vstupem vertikalizátoru je soubor warc.gz, ze kterého se postupně vybalují jednotlivé záznamy, vyfiltruje se z nich HTML, vyfiltrují se neanglické články a provede se tokenizace. Zpracovat lze také 1 webovou stránku v .html a Wikipedii v předzpracovaném HTML. Výsledek je uložen s příponou vert do cílového adresáře.

Nový vertikalizátor:

 ./processing_steps/2/vertikalizator/main.py

Přeloží se příkazem:

 make
V prípade chyby pri preklade skúste zavolať príkaz:
 make configure

Použití:

 ./main.py [-i INPUT_FILE] -o OUTPUT_FILE [-l] [-d] [-w] -w STOPWORDS_LIST
 
 -i   --input        vstupní soubor určený k vertikalizaci (pokud není nastaveno očekává WARC na stdin)
 -o   --output       výstupní soubor, pokud není zadaný, výstup se vypisuje na stdout
 -n   --nolangdetect vypne detekci jazyka, vertikalizace je rychlejší, rozdíl minimální
 -d   --debug        tiskne ladící informace
 -w   --wiki         na vstupu se očekáva wiki formát
 -s   --stopwords    soubor se seznamem stop slov
 -l   --log          soubor pro ukládaní logu (ladících informací), užitečné pouze pokud je přítomen parameter -d. Pro výstup na stdout musí být jeho hodnota STDOUT, pro výstup na stderr musí být hodnota STDERR

Pro podrobneší info ohledem návrhu a implementace odkaz na BP: https://www.fit.vutbr.cz/study/DP/BP.php?id=18729&file=t

Starý vertikalizátor: - NEPOUŽÍVAT

Pro vertikalizaci slouží program NLP-slave (závislý na lokálním langdetect), jehož zdrojové kódy jsou v repozitáři v:

 ./processing_steps/2/NLP-slave

Tento program předpokládá na vstupu (jako první parametr) soubor warc.gz, ze kterého postupně vybaluje jednotlivé záznamy, vyfiltruje z nich HTML, vyfiltruje neanglické články a provede tokenizaci. Zpracovat lze také 1 webovou stránku v .html a Wikipedii v předzpracovaném plaintextu či HTML. Výsledek je uložen s příponou vert do cílového adresáře.

Přeloží se příkazem:

 mvn clean compile assembly:single

Použití starého vertikalizátoru:

 java -jar package [opts] input_file.html output_dir file_URI [langdetect_profiles]
 java -jar package [opts] input_file.txt output_dir [langdetect_profiles]
 java -jar package [opts] input_file-warc.gz output_dir [langdetect_profiles]
 java -jar package [opts] input_file output_dir [langdetect_profiles]

Skript pro paralelní spuštění na více serverech:

 ./processing_steps/2/verticalize.py

Použití:

 ./verticalize.py -i INPUT_DIRECTORY -o OUTPUT_DIRECTORY [-s SERVERS_FILE] [-b BINARY] [-t THREADS] [-l] [-d] [-s STOPWORDS_LIST] [-e ERRORS_LOG]
 
 -i   --input     vstupní adresář se soubory určenými k vertikalizaci
 -o   --output    výstupní adresář, pokud adresář neexistuje, skript se jej pokusí vytvořit
 -s   --servers   soubor se seznamem serverů, kde je formát: HOSTNAME '\t' THREADS '\n' (jeden řádek pro jeden stroj)
 -e   --errors    pokud je nastaven jsou chyby logovány do tohoto souboru s aktuálním datem a časem
 -b   --binary    argument specifikující cestu k vetrikalizátoru (výchozí je ./processing_steps/2/vertikalizator/main.py)
 -t   --threads   nastavuje počet vláken (výchozí je 6, jsou-li počty vláken v souboru se seznamem serverů, mají vyšší prioritu)
 -l   --no-lang   vypne detekci jazyka
 -d   --debug     vertikalizátor tiskne ladící informace
 -w   --stopwords soubor se seznamem stop slov (výchozí je ./processing_steps/2/vertikalizator/stoplists/English.txt)

Například:

 ./verticalize.py -i /mnt/data/commoncrawl/CC-2015-18/warc/ -o /mnt/data/commoncrawl/CC-2015-18/vert/ -s ~/servers -b /mnt/data/commoncrawl/software/NLP-slave-0.0.1-SNAPSHOT-jar-with-dependencies.jar
 # Data z adresáře /mnt/data/project/CC-2015-18/warc/ vertikalizuje do adresáře /mnt/data/commoncrawl/CC-2015-18/vert/
 # Vetrikalizaci provede na všech serverech daných souborem -s ~/servers
 # Použije k tomu program /mnt/data/commoncrawl/software/NLP-slave-0.0.1-SNAPSHOT-jar-with-dependencies.jar, který musí být na všech strojích

3. Deduplikace

Detailná dokumentácia deduplikácie je umiestnená v Corpproc_dedup

Stručný prehľad:

K deduplikci slouží programy dedup a server dostupné přeložením pomocí Makefile ve složce:

 processing_steps/3/dedup/ 
v repozitári corpproc_dedup

Parametry pro spouštění těchto programů jsou následující:

 ./server [-i=INPUT_FILE] [-o=OUTPUT_FILE [-d]] -w=WORKERS_COUNT [-s=STRUCT_SIZE] [-p=PORT] [-j=JOURNAL_FILE]

-i   --input     vstupní soubor 
-o   --output    výstupní soubor
-w   --workers   počet workerů
-p   --port      port serveru (výchozí je 1234)
-s   --size      změna velikosti struktury pro uložení hashů (výchozí velikost je 300,000,000)
-d   --debug     zároveň s výstupním souborem je generován soubor s debug výpisy
-j   --journal   obnovenie hashov zo zálohy (vhodné použiť v kombinácii s -r u klienta)
-k   --keep      ponechanie záložného súboru aj po úspešnom uložení hashov do výstupného súboru 

Server běží do doby než je "killnut". Reakcí na signály SIGHUP a SIGTERM je uložení hashů do výstupního souboru (pokud je zadána cesta).

./dedup -i=INPUT_DIR -o=OUTPUT_DIR -s=SERVERS_STRING [-p=PORT] [-t=THREADS] [-n] [-d] [-wl] [-uf=FILTER_FILE]

-i   --input       vstupní adresář se soubory určenými k deduplikaci
-o   --output      výstupní adresář, pokud adresář neexistuje, skript se jej pokusí vytvořit
-s   --servers     seznam serverů oddělený mezerami
-p   --port        port serveru (výchozí je 1234)
-t   --threads     nastavuje počet vláken (výchozí je 6)
-n   --near        použije algoritmus "nearDedup"
-d   --debug       ke každému výstupnímu souboru .dedup je zároveň generován soubor .dedup.debug obsahující debug výpisy
-wl  --wikilinks   deduplikace formátu WikiLinks
-uf  --usefilter   vstupný súbor s reťazcami(jeden na riadok), ktoré majú odfiltrovať nepotrebné dokumenty - názov/URL
-dr  --dropped     ke každému výstupnímu souboru .dedup je zároveň generován soubor .dedup.dropped obsahující odstraněné duplicity
-f   --feedback    záznamy v souboru .dedup.dropped obsahující referenci na záznamy kvůli kterým byly vyloučeny (viz. níže) 
-dd  --droppeddoc  ku každému výstupnému súboru *.dedup je zároveň vytvorený súbor .dedup.dd obsahujúci zoznam URL adries
                         kompletne vylúčených dokumentov
-r   --restore     pokračovanie v deduplikácii po páde systému - spracované dokumenty budú preskočené, rozpracované budú dokončené
                   (používať v kombinácii s -j na serveri)

Pro jejich jednodušší spouštění byly vytvořeny skripty server.py a deduplicate.py (popsány níže), které umožnují spustit deduplikaci paralelně na více strojích. Programy musí být předem rozdistribuovány na všechny použité stroje a na nich být ve stejném umístění například: /mnt/data/bin/dedup

Spuštění serverů pro deduplikaci. Skript s argumentem start nejprve spouští screeny a v nich teprve samotné servery. Zadáním argumentu stop naopak screeny ukončuje. Pokud není zadán ani start ani stop ani restart, tak skript testuje nejprve zda běží screeny a poté také servery.

 ./processing_steps/3/server.py

Použití:

 ./server.py [start|stop|restart] [-i INPUT_FILE] [-o OUTPUT_FILE [-d]] [-a] -s SERVERS_FILE [-t THREADS] [-p PORT]
[-e ERRORS_LOG_FILE] [-b BINARY] [-d] [-j] [-k] [-r SPARSEHASH_SIZE] 

-i   --input      vstupní soubor 
-o   --output     výstupní soubor
-s   --servers    soubor se seznamem serverů, kde na každém řádku je hostname jednoho stroje, pokud řádek obsahuje tabulátor,
                   je brán jako oddělovač a jako hostname se bere jen text před ním (kvůli kompatibilitě tohoto konfiguračního
                   souboru se skripty, u kterých je možné specifikovat počet vláken pro konkrétní stroj, tam je možný formát:
                   HOSTNAME \t THREADS pro každý řádek)
-t   --threads    počet vlákien obsluhujúcich workerov (default = 384)
-p   --port       port serveru (výchozí je 1234)
-r   --resize     změna velikosti struktury pro uložení hashů (výchozí velikost je 300000000)
-e   --errors     pokud je nastaven jsou chyby logovány do tohoto souboru s aktuálním datem a časem
-b   --binary     argument specifikující cestu k deduplikačnímu serveru (výchozí je /mnt/data/commoncrawl/corpproc/bin/server)
-d   --debug      zároveň s výstupním souborem je generován soubor s debug výpisy
-j   --journal    obnovenie hashov zo žurnálového súboru (vhodné použiť v kombinácii s -r u klienta)
-k   --keep       ponechanie záložného súboru aj po úspešnom uložení hashov do výstupného súboru 
-a   --append     Výstupný súbor je zhodný so vstupným

Poznámka k -j, --journal: pre obnovenie hashov zo zálohy je potrebné uviesť cestu k vstupnému súboru, ktorý bol pred pádom servera zadaný ako výstupný. Skript overí, či sa pri ňom nachádza súbor "vstupný_súbor".backup. Ak vstupný súbor na nejakých serveroch neexistuje, bude vytvorený.

Například:

./server.py start -s ~/servers
# Spustí screeny a v nich servery na strojích určených souborem ~/servers
# Servery čekají až se připojí workery
./server.py -s ~/servers
# Otestuje zda jsou spuštěny screeny a servery na strojích určených souborem ~/servers
./server.py stop -s ~/servers 
# Ukončí screeny a v nich spuštěné servery na strojích určených souborem ~/servers

Spuštění workerů pro deduplikaci. Před tím je nutné spustit servery se stejnými parametry -s a -p.

 ./processing_steps/3/deduplicate.py

Použití:

./deduplicate.py -i INPUT_DIRECTORY -o OUTPUT_DIRECTORY -w WORKERS_FILE -s SERVERS_FILE [-p PORT] 
[-e ERRORS_LOG_FILE] [-b BINARY] [-n] [-d] [-wl] -uf FILTER_FILE

-i  --input      vstupní adresář se soubory určenými k deduplikaci
-o  --output     výstupní adresář, pokud adresář neexistuje, skript se jej pokusí vytvořit
-s  --servers    soubor se seznamem serverů, kde na každém řádku je hostname jednoho stroje, pokud řádek obsahuje tabulátor,
                   je brán jako oddělovač a jako hostname se bere jen text před ním (kvůli kompatibilitě tohoto konfiguračního
                   souboru se skripty, u kterých je možné specifikovat počet vláken pro konkrétní stroj, tam je možný formát:
                   HOSTNAME \t THREADS pro každý řádek)
-w  --workers    soubor se seznamem workerů, kde je formát: HOSTNAME '\t' THREADS '\n' (jeden řádek pro jeden stroj)
                   (pozn. pozor na nahrádzanie tabov medzerami, nebude fungovať)
-p  --port       port serveru (výchozí je 1234)
-e  --errors     pokud je nastaven jsou chyby logovány do tohoto souboru s aktuálním datem a časem
-b  --binary     argument specifikující cestu k deduplikačnímu programu (výchozí je /mnt/data/commoncrawl/corpproc/bin/dedup)
-t  --threads    nastavuje počet vláken (výchozí je 6, jsou-li počty vláken v souboru se seznamem serverů, mají vyšší prioritu)
-n  --near       použije algoritmus "nearDedup"
-d  --debug      ke každému výstupnímu souboru .dedup je zároveň generován soubor .dedup.dropped obsahující odstraněné duplicity
                   a .dedup.debug obsahující debug výpisy
-wl --wikilinks  deduplikace formátu Wikilinks
-uf --usefilter  súbor s reťazcami(jeden na riadok), ktoré majú odfiltrovať nepotrebné dokumenty - názov/URL
-dr --dropped    ke každému výstupnímu souboru .dedup je zároveň generován soubor .dedup.dropped obsahující odstraněné duplicity
-f  --feedback   záznamy v souboru .dedup.dropped obsahující referenci na záznamy kvůli kterým byly vyloučeny (viz. níže)
-dd --droppeddoc Vo výstupnom adresári bude vytvorený súbor "droppedDocs.dd" obsahujúci zoznam kompletne vylúčených dokumentov
-r  --restore    pokračovanie v deduplikácii po páde systému - spracované dokumenty budú preskočené, rozpracované budú dokončené
                 (používať v kombinácii s -j na serveri)

Deduplikace formátu wikilinks je implementována tak, že se počítá hash pro konkatenaci sloupců 2, 3, 5, 6, tedy musejí byt všechny sloupce stejné, aby byl řádek vyhodnocen jako duplicitní. Neardedup funguje tak, že výpočet hashů pomocí N-gramů se provádí na konkatecaci sloupců 5, 3, 6 (v tomto pořadí), dále se počítá hash 2. sloupce a aby byl rádek duplicitní, musejí oba předchozí přístupy odhalit shodu.

Například:

 ./deduplicate.py -i /mnt/data/commoncrawl/CC-2015-18/vert/ -o /mnt/data/commoncrawl/CC-2015-18/dedup/ -w ~/workers-s ~/servers 
 # Data z adresáře /mnt/data/commoncrawl/CC-2015-18/vert/ deduplikuje do adresáře /mnt/data/commoncrawl/CC-2015-18/dedup/
 # Deduplikace probíhá na strojích specifikovaných v souboru ~/workers
 # Očekává, že na strojích určených souborem ~/servers je spuštěn server

3.1. Deduplikace pro Salomon

Jediný tento krok je pro Salomon jiný, protože se jedná o distribuovaný výpočet. Ve standardním provedení se komunikuje přes sokety standardním TCP/IP. Na Salomonu to však není možné (InfiniBand), proto je použita knihovna mpi. Zdrojové kódy jsou v

 /mnt/minerva1/nlp/projects/corpproc/corpora_processing_sw/processing_steps/salomon/mpidedup

Odporúča sa používať výhradne modul OpenMPI/1.8.8-GNU-4.9.3-2.25, kvôli problémom s kompatibilitou s niektorými verziami (pády, problémy pri spúštaní atď.).

Překlad

 module load OpenMPI/1.8.8-GNU-4.9.3-2.25
 make

Spustenie na salomone: Deduplikáciu je najjednoduchšie spustiť pomocou skriptu v5/start.sh, spúšťacie parametre sa nastavujú v skripte, odporúča sa použiť 4 uzly napr:

bash start.sh dedup 4 qexp

Parametry:

 -h --hash - relativní počet serverů držících jednotlivé podprostory celkového hashovacího prostoru
 -w --work - relativní počet worker serverů, které provádějí vlastní deduplikaci
 -i --input - vstupní adresář se soubory určenými k deduplikaci
 -o --output - výstupní adresář
 -l --load - volitelný adresář odkud se nahrají existující hashe (pro inkrementální deduplikaci - musí se to samozřejmě
     pustit stejným způsobem (infrastruktura, počet workerů a serverů s hashovacím prostorem), jakým byly hashe dříve uloženy)
 -s --store - volitelný adresář pro uložení hashů
 -r --resize - volitelný parametr pro změnu velikosti struktury pro uložení hashů
 -d --debug - zapne ladící režim (generuje logy a soubory s odstraněnými řetězci)
 -n --near - přepne na neardedup algoritmus
 -j --journal - zohľadní spracované súbory a žurnály (neuložené hashe a nedokončené súbory)
              - pokúsi sa zotaviť po páde a pokračovať v deduplikácii

Pri použití 4 uzlov sa teda vytvorí 96 procesov, z čoho 32 hashholderov a 64 workerov. Pri pokračovaní v rozpracovanej, či havarovanej deduplikácii je potrebné zachovať celkový počet hashholderov z predchádzajúceho spustenia.

Čo robiť pri páde?

Preskúmať čo pád spôsobilo (súbory dedup.eXXXXX a dedup.oXXXXX v priečinku v5) a spustiť znova.

Pri spúšťaní cez v5/start.sh, ktorý po nastavení premenných prostredia volá v5/dedup.sh je prednastavený parameter -j, ktorý sa postará o pokračovanie v rozpracovanej deduplikácii nezávisle od toho, či bola ukončená správne alebo nie. Treba mať na pamäti, že použitie parametra -j spôsobí, že už spracované vertikály sa preskočia, teda ak požadujete nové/čisté spustenie, je dôležité vymazať obsah výstupného priečinka s deduplikovanými vertikálmi. Režim obnovy je možné vypnúť v súbore v5/dedup.sh.

Ako presne funguje režim obnovy(-j)?

Spustenie na serveroch KNOT:

mpiexec dedup -h H -w W -i ~/vert/ -o ~/dedup/ -s ~/hash/

4. Tagging

Tagging se provádí programem TT-slave (závislý na /opt/TreeTagger), který lze najít v:

 ./processing_steps/4/TT-slave

Přeloží se příkazem:

 mvn clean compile assembly:single

Použití:

 java -jar package [opts] input_file output_dir [treetagger.home]

Skript pro paralelní spuštění na více serverech:

 ./processing_steps/4/tag.py

Použití:

 ./tag.py -i INPUT_DIRECTORY -o OUTPUT_DIRECTORY [-s SERVERS_FILE] [-e ERRORS_LOG_FILE] [-b BINARY] [-t THREADS] [-d] [-u]
 
 -i   --input     vstupní adresář se soubory určenými k tagování
 -o   --output    výstupní adresář, pokud adresář neexistuje, skript se jej pokusí vytvořit
 -s   --servers   soubor se seznamem serverů, kde je formát: HOSTNAME '\t' THREADS '\n' (jeden řádek pro jeden stroj)
 -e   --errors    pokud je nastaven jsou chyby logovány do tohoto souboru s aktuálním datem a časem
 -b   --binary    argument specifikující cestu k tagovacímu .jar programu (výchozí je ./processing_steps/4/TT-slave/target/TT-slave-0.0.1-SNAPSHOT-jar-with-dependencies.jar)
 -t   --threads   nastavuje počet vláken (výchozí je 6, jsou-li počty vláken v souboru se seznamem serverů, mají vyšší prioritu)
 -d   --debug     ladící výpisy
 -u   --uri       zapne odstraňovaní URI z odkazů

Například:

 ./tag.py -i /mnt/data/commoncrawl/CC-2015-18/dedup/ -o /mnt/data/commoncrawl/CC-2015-18/dedup/tagged/ -s ~/servers
 # taguje soubory ze složky /mnt/data/commoncrawl/CC-2015-18/dedup/ a uloží do
 # složky /mnt/data/commoncrawl/CC-2015-18/dedup/tagged/ na strojích určených souborem ~/servers

5. Parsing

Parsing se provádí upraveným MDParserem, který lze nalézt v:

 ./processing_steps/5/MDP-package/MDP-1.0

Přeloží se příkazem:

 ant make-mdp

Použití:

 java -jar package [opts] input_file output_dir [path_to_props]

Důležité soubory, pokud by se něco měnilo:

 ./processing_steps/5/MDP-package/MDP-1.0/src/de/dfki/lt/mdparser/test/MDParser.java
 ./processing_steps/5/MDP-package/MDP-1.0/src/de/dfki/lt/mdparser/outputformat/ConllOutput.java

Skript pro paralelní spuštění na více serverech:

 ./processing_steps/5/parse.py

Použití:

 ./parse.py -i INPUT_DIRECTORY -o OUTPUT_DIRECTORY [-s SERVERS_FILE] [-e ERRORS_LOG_FILE] [-b BINARY] [-t THREADS] [-u] [-p XML_FILE]
 
 -i   --input     vstupní adresář se soubory určenými k parsování
 -o   --output    výstupní adresář, pokud adresář neexistuje, skript se jej pokusí vytvořit
 -s   --servers   soubor se seznamem serverů, kde je formát: HOSTNAME '\t' THREADS '\n' (jeden řádek pro jeden stroj)
 -e   --errors    pokud je nastaven jsou chyby logovány do tohoto souboru s aktuálním datem a časem
 -b   --binary    argument specifikující cestu k parsovacímu .jar programu (výchozí je ./processing_steps/5/MDP-package/MDP-1.0/build/jar/mdp.jar)
 -t   --threads   nastavuje počet vláken (výchozí je 6, jsou-li počty vláken v souboru se seznamem serverů, mají vyšší prioritu)
 -u   --uri       zapne odstraňovaní URI z odkazů 
 -p   --props     Cesta k .xml súboru s parametrami programu (výchozí je ./processing_steps/5/MDP-package/MDP-1.0/resources/props/propsKNOT.xml)


Například:

 ./parse.py -i /mnt/data/commoncrawl/CC-2015-18/tagged/ -o /mnt/data/commoncrawl/CC-2015-18/parsed/ -s ~/servers
 # parsuje soubory ze složky /mnt/data/commoncrawl/CC-2015-18/tagged/ do 
 # složky /mnt/data/commoncrawl/CC-2015-18/parsed/ na strojích určených souborem ~/servers
 ./parse.py -i /mnt/data/commoncrawl/CC-2015-18/tagged/ -o /mnt/data/commoncrawl/CC-2015-18/parsed/ -s ~/servers \
   -p ./processing_steps/5/MDP-package/MDP-1.0/resources/props/propsKNOT.xml
 # parsuje soubory ze složky /mnt/data/commoncrawl/CC-2015-18/tagged/ do 
 # složky /mnt/data/commoncrawl/CC-2015-18/parsed/ na strojích určených souborem ~/servers
 # zároveň MDParseru předá konfigurační soubor propsKNOT.xml (musí být dostupný na všech strojích kde spouštíme)

6. SEC (NER)

Pro rozpoznání pojmenovaných entit se používá SEC (viz SEC). Klienta sec.py lze paralelně na více serverech spustit pomocí:

 ./processing_steps/6/ner.py

Použití:

 ./ner.py -i INPUT_DIRECTORY -o OUTPUT_DIRECTORY [-s SERVERS_FILE] [-e ERRORS_LOG_FILE] [-b BINARY]
 
 -i   --input     vstupní adresář 
 -o   --output    výstupní adresář
 -s   --servers   soubor se seznamem serverů, kde na každém řádku je hostname jednoho stroje, pokud řádek obsahuje tabulátor, 
                  je brán jako oddělovač a jako hostname se bere jen text před ním (kvůli kompatibilitě tohoto konfiguračního souboru se skripty, 
                  u kterých je možné specifikovat počet vláken pro konkrétní stroj, tam je možný formát: HOSTNAME \t THREADS pro každý řádek)
 -e   --errors    pokud je nastaven jsou chyby logovány do tohoto souboru s aktuálním datem a časem
 -b   --binary    změna cesty k SEC klientovi (výchozí je /var/secapi/SEC_API/sec.py)

Například:

 ./ner.py -i /mnt/data/commoncrawl/CC-2015-18/parsed/ -o /mnt/data/commoncrawl/CC-2015-18/secresult/ -s ~/servers
 # zpracovává soubory ze složky /mnt/data/commoncrawl/CC-2015-18/parsed/ do 
 # složky /mnt/data/commoncrawl/CC-2015-18/secresult/ na strojích určených souborem ~/servers

7. Indexace MG4J

Introduction to MG4J: http://www.dis.uniroma1.it/~fazzone/mg4j-intro.pdf

Zdrojové soubory programu určeného pro sémantické indexování se nacházejí v adresáři:

 ./processing_steps/7/mg4j-big-5.2.1

Přeloží se příkazem (při problémech s 'missing definitions' je více info na Mg4j_improvements):

 ant ivy-setupjars && ant
 mkdir /mnt/data/indexes/CC-2015-18/collPart001
 mkdir /mnt/data/indexes/CC-2015-18/final
 find /mnt/data/indexes/CC-2015-18/collPart001 -type f | java -cp $(echo ./processing_steps/7/mg4j/*.jar | tr ' ' ':') it.unimi.di.big.mg4j.document.CustomDocumentCollection /mnt/data/indexes/CC-2015-18/final/collPart001.collection
 java -cp $(echo ./processing_steps/7/mg4j/*.jar | tr ' ' ':') it.unimi.di.big.mg4j.tool.IndexBuilder -S /mnt/data/indexes/CC-2015-18/final/collPart001.collection /mnt/data/indexes/CC-2015-18/final/collPart001

Skript pro paralelní spuštění na více serverech:

Skript spouští indexaci tak, že vytvoří 6 shardů, ty naplní a z nich vytvoří kolekce a nad nimi spustí indexaci. K tomu je potřeba zadat argument start. Pokud není zadán, bude vypsán stav jednotlivých screenů a stav programů v nich. Argumentem stop budou screeny ukončeny.

 ./processing_steps/7/index.py

Použití:

 ./index.py [start|stop] -i INPUT_DIRECTORY -o OUTPUT_DIRECTORY [-s SERVERS_FILE] [-e ERRORS_LOG_FILE] [-b BINARY]
 
 -i   --input     vstupní adresář 
 -o   --output    výstupní adresář
 -s   --servers   soubor se seznamem serverů, kde na každém řádku je hostname jednoho stroje, pokud řádek obsahuje tabulátor, 
                  je brán jako oddělovač a jako hostname se bere jen text před ním (kvůli kompatibilitě tohoto konfiguračního souboru se skripty,
                  u kterých je možné specifikovat počet vláken pro konkrétní stroj, tam je možný formát: HOSTNAME \t THREADS pro každý řádek)
 -e   --errors    pokud je nastaven jsou chyby logovány do tohoto souboru s aktuálním datem a časem
 -b   --binary    cesta do složky obsahující .jar soubory (výhozí je /mnt/data/wikipedia/scripts/mg4j/)

Například:

 ./index.py -s ~/servers
 # zobrazí stav spuštění screenů a programu v nich na všech serverech ze souboru ~/servers
 ./index.py -i /mnt/data/commoncrawl/CC-2015-18/secresult/ -o /mnt/data/indexes/CC-2015-18/ -s ~/servers start
 # spustí indexaci na zvolených serverech
 ./index.py -s ~/servers stop
 # ukončí screeny a tím i procesy v nich na všech serverech ze souboru ~/servers


Sloupce: https://docs.google.com/spreadsheets/d/1S4sJ00akQqFTEKyGaVaC3XsCYDHh1xhaLtk58Di68Kk/edit?usp=sharing

Pozn.: Zatím není jasné, jestli mají být speciální znaky XML ve sloupcích escapované. Současná implementace SEC je neescapuje, resp. případné escapování odstraní. tagMG4JMultiproc.py je také neescapuje, ale escapování, které je na vstupu (pouze částečné - pravděpodobně jen některé sloupce) ponechá.

když se sloupce změní, je nutné změnit:

Daemony odpovídající na dotazy (servery běžící nad indexy)

Spouští se:

 cd /mnt/data/indexes/CC-2015-18/final
 java -cp $(echo ./processing_steps/7/mg4j/*.jar | tr ' ' ':') it.unimi.di.big.mg4j.query.HttpJsonServer -p 12000 /mnt/data/indexes/CC-2015-18/final/collPart001.collection

Skript pro paralelní spuštění na více serverech:

Spouští daemony odpovídající na dotazy. Spouštění probíhá ve screenech a musí být zadán parametr start. Bez parametru vypíše stav screenů a daemonů. Parametr stop ukončí screeny.

 ./processing_steps/7/daemon.py

Použití:

 ./daemon.py [start|stop|restart] -i INPUT_DIRECTORY [-s SERVERS_FILE] [-e ERRORS_LOG_FILE] [-b BINARY]
 
 -i   --input     vstupní adresář (automaticky přidává na konec cesty /final/)
 -p   --port      port (defaut is 12000)
 -s   --servers   soubor se seznamem serverů, kde na každém řádku je hostname jednoho stroje, pokud řádek obsahuje tabulátor, 
                  je brán jako oddělovač a jako hostname se bere jen text před ním (kvůli kompatibilitě tohoto konfiguračního souboru se skripty, 
                  u kterých je možné specifikovat počet vláken pro konkrétní stroj, tam je možný formát: HOSTNAME \t THREADS pro každý řádek)
 -e   --errors    pokud je nastaven jsou chyby logovány do tohoto souboru s aktuálním datem a časem
 -b   --binary    cesta do složky obsahující .jar soubory (výhozí je /mnt/data/wikipedia/scripts/mg4j/)

Například:

 ./daemon.py -i /mnt/data/indexes/CC-2015-18/final -s ~/servers start
 # spustí screeny a v nich daemon nad kolekcemi ve složce /mnt/data/indexes/CC-2015-18/final
 # na strojích v souboru ~/servers
 ./daemon.py -s ~/servers
 # zobrazí stav spuštěných screenů a daemonů na strojích v souboru ~/servers
 ./daemon.py -s ~/servers stop
 # ukončí screeny na strojích v souboru ~/servers

8. a) Commandlinový dotazovač

Zdrojové soubory programu jsou v adresáři:

 ./processing_steps/8a/mg4jquery

Lze je přeložit příkazem:

 JAVA_HOME=/usr/lib/jvm/java-8-oracle/; mvn clean compile assembly:single

Příklady spuštění:

 JAVA_HOME=/usr/lib/jvm/java-8-oracle/; java -jar mg4jquery-0.0.1-SNAPSHOT-jar-with-dependencies.jar -h ../../servers.txt -m ../src/main/java/mg4jquery/mapping.xml -s ../src/main/java/mg4jquery/config.xml  -q "\"was killed\""
 JAVA_HOME=/usr/lib/jvm/java-8-oracle/; java -jar mg4jquery-0.0.1-SNAPSHOT-jar-with-dependencies.jar -h ../../servers.txt -m ../src/main/java/mg4jquery/mapping.xml -s ../src/main/java/mg4jquery/config.xml  -q "1:nertag:person < 2:nertag:person" -c "1.nerid != 2.nerid"

Tohle by například vrátilo dokumenty, kde jsou alespoň dva různí lidé. Soubor se servery na očekává na každém řádku adresu serveru s portem, např.:

 knot01.fit.vutbr.cz:12000

8. b) Webové GUI

Zprovoznění:

Instalace artefaktů:

 mvn install:install-file -Dfile=./processing_steps/8b/maven_deps/jars/vaadin-html5-widgets-1.0.jar -DgroupId=de.akquinet.engineering.vaadin -DartifactId=vaadin-html5-widgets -Dversion=1.0 -Dpackaging=jar
 mvn install:install-file -Dfile=./processing_steps/8b/maven_deps/jars/MyComponent-1.0-SNAPSHOT.jar -DgroupId=cz.vutbr.fit -DartifactId=MyComponent -Dversion=1.0-SNAPSHOT -Dpackaging=jar

Příprava:

 cd ./processing_steps/8b/mg4j-gui
 mvn install

Spuštění na portu 8086:

 mvn jetty:run -Djetty.port=8086

V podadresáři maven_deps/src jsou obsaženy i zdroje vlastní gwt komponenty pro zobrazení dynamických tooltipů. Pro úspěšné navrácení výsledků dotazu ze serveru je nutné v nastavit v možnostech adresy těchto serverů (v klasickém formátu doménové_jméno_serveru:port). Dále lze nastavit počet výsledků na stránku, chování info oken (dynamické - po odjetí kurzoru myši z entity se info okno skryje, statické - zůstane viditelné, dokud uživatel nenajede kurzorem nad jinou entitu, či jiným způsobem nezmění stav aplikace) a typ zobrazení (defaultní je corpus based, ale lze zapnout i document based).

Dotazování

Probíhá podobným způsobem, jako v mg4j, sémantický index automaticky přemapuje dotazy do stejného indexu, není tedy třeba psát:

 "(nertag:person{{nertag-> token}}) killed"

Stačí takovýto dotaz:

 "nertag:person killed"

Oproti mg4j je zde rozšířeí "Global constraints", které umožňuje označit token a provést na něm post-filter.

 1:nertag:person < 2:nertag:person
 1.fof != 2.fof AND 1.nerid = 2.nerid

Toto by například vrátilo dokumenty, kde je tatáž osoba v různých formách (nejčastěji asi jméno a koreference). V případě potřeby dotazování se na výskyty v rámci jedné věty lze použít operátor diference.

 nertag:person < nertag:person - _SENT_
 nertag:person < nertag:person - _PAR_

Tyto dotazy hledají dva lidi uvnitř věty, resp. odstavce. Diference znamená, že se má vzít takový úsek textu, ve kterém se daný token nevyskytuje.

Indexy

Existuje množství indexů, do kterých se dá dotazovat:

 position
 token
 tag
 lemma
 parpos
 function
 parword
 parlemma
 paroffset
 link
 length
 docuri
 lower
 nerid
 nertag
 person.name
 person.gender
 person.birthplace
 person.birthdate
 person.deathplace
 person.deathdate
 person.profession
 person.nationality
 artist.name
 artist.gender
 artist.birthplace
 artist.birthdate
 artist.deathplace
 artist.deathdate
 artist.role
 artist.nationality
 location.name
 location.country
 artwork.name
 artwork.form
 artwork.datebegun
 artwork.datecompleted
 artwork.movement
 artwork.genre
 artwork.author
 event.name
 event.startdate
 event.enddate
 event.location
 museum.name
 museum.type
 museum.estabilished
 museum.director
 museum.location
 family.name
 family.role
 family.nationality
 family.members
 group.name
 group.role
 group.nationality
 nationality.name
 nationality.country
 date.year
 date.month
 date.day
 interval.fromyear
 interval.frommonth
 interval.fromday
 interval.toyear
 interval.tomonth
 interval.today
 form.name
 medium.name
 mythology.name
 movement.name
 genre.name
 nertype
 nerlength

Jen upozornění, že všechny dotazy začínající na číslo nebo obsahující hvězdičku se musí závorkovat, jinak je to syntaktická chyba dotazu.

 nertag:event ^ event.startdate: (19*)

Také je dobré vědět, že dotazy na atributy nějaké pojmenované entity by se měly uvádět v kombinaci s dotazem do indexu nertag (to protože se indexy překrývají z důvodu úspory místa). Pro "Global constraints" lze navíc použít dotaz "fof", což je zkratka pro "full occurrence form".

Redistribuce souborů

Skript umožňuje přerozdělit data (soubory) mezi dané servery tak, aby byla rovnoměrně využitá kapacita diskových polí (přerozděluje i z N serverů na M serverů, kde M je větší než N).

 ./processing_steps/1/redistribute.py

Použití:

 ./redistribute.py -i INPUT_DIRECTORY [-o OUTPUT_DIRECTORY [-d DISTRIB_DIRECTORY]] -s SERVER_LIST [-p RELATED_PATHS] [-x EXTENSION] [-r] [-m] [-e ERRORS_LOG_FILE]

Výsledné rozdistribuované skripty je potřeba spustit paralelním ssh a pak odstranit.

Například:

 python /mnt/minerva1/nlp/projects/corpproc/corpora_processing_sw/processing_steps/1/redistribute.py -i /mnt/data/commoncrawl/CC-2015-14/warc -s /mnt/minerva1/nlp/projects/corpproc/corpora_processing_sw/processing_steps/servers.txt -m -o /home/idytrych/redistributionScripts -d /mnt/data/commoncrawl/software/redistributionScripts -x "-warc.gz" -p /home/idytrych/CC-2015-14-rel.txt >moves.txt

kde CC-2015-14-rel.txt obsahuje:

 /mnt/data/commoncrawl/CC-2015-14/uri	-warc.domain
 /mnt/data/commoncrawl/CC-2015-14/uri	-warc.domain.srt
 /mnt/data/commoncrawl/CC-2015-14/uri	-warc.netloc
 ...

následně se skripty ve screenu spustí:

 parallel-ssh -h servery_b9_idytrych.txt -t 0 -A -i "bash /mnt/data/commoncrawl/software/redistributionScripts/\$HOSTNAME.sh"

a odstraní

 parallel-ssh -h servery_b9_idytrych.txt -t 0 -A -i "rm /mnt/data/commoncrawl/software/redistributionScripts/\$HOSTNAME.sh"


Pozn.: Na serverech, na které se nebude nic přesouvat, není žádný skript, takže to vypíše chybu.

Kde lze otestovat?

Aktuálně běží vyhledávač na serveru athena1, lze vyzkoušet např. [http://athena1.fit.vutbr.cz:8088/#1:nertag:%28artist%20OR%20person%29%20%3C%20lemma:%28inspire%20OR%20influence%20OR%20admiration%20OR%20tutelage%20OR%20tribute%20OR%20homage%29%20%3C%202:nertag:%28artist%20OR%20person%29%20-%20_SENT_;1.nerid%20!=%202.nerid]

Indexy pro tento vyhledávač běží téměř na všech serverech. Pro Wikipedii lze démony restartovat takto (může udělat jen ten, kdo je spustil):

 python daemon.py restart -i /mnt/data/indexes/wikipedia/enwiki-20150901/ -s /mnt/minerva1/nlp/projects/corpproc/serverLists/serversIW.txt -b /mnt/data/wikipedia/software/mg4j

Pro CC (v pořadí dle inkrementální deduplikace):

 python daemon.py restart -i /mnt/data/indexes/CC-2015-32/ -s /mnt/minerva1/nlp/projects/corpproc/serverLists/serversIC32.txt -b /mnt/data/commoncrawl/software/mg4j -p 12001
 python daemon.py restart -i /mnt/data/indexes/CC-2015-35/ -s /mnt/minerva1/nlp/projects/corpproc/serverLists/serversIC35.txt -b /mnt/data/commoncrawl/software/mg4j -p 12002
 python daemon.py restart -i /mnt/data/indexes/CC-2015-40/ -s /mnt/minerva1/nlp/projects/corpproc/serverLists/serversIC40.txt -b /mnt/data/commoncrawl/software/mg4j -p 12003
 python daemon.py restart -i /mnt/data/indexes/CC-2015-27/ -s /mnt/minerva1/nlp/projects/corpproc/serverLists/serversIC27.txt -b /mnt/data/commoncrawl/software/mg4j -p 12004

Zprovoznění na Salomonu

  1. Naklonovat si repozitář se SEC API (minerva1.fit.vutbr.cz:/mnt/minerva1/nlp/repositories/decipher/secapi) do home na Salomonu
  2. Stáhnout KB (ve složce secapi/NER ./downloadKB.sh)
  3. Nakopírovat si do home na Salomon:
  4. Vyhledat si ve všech souborech v home (a v podsložkách) string "idytrych", případně "smrz" a upravit absolutní cesty
  5. Build mpidedup (cd mpidedup; make)
  6. Vytvořit pracovní adresáře skriptem createWorkDirs_single.sh
  7. Soubor warcDownloadServers.cfg obsahuje seznam uzlů, na kterých se bude stahovat CommonCrawl - je vhodné zkontrolovat jeho aktuálnost.
  8. Pro stahování CommonCrawl je nutné někde nějak získat soubor .s3cfg a dát si ho do home.

Pro verzi skriptů 4:

  1. ...
  2. Build mpidedup (cd mpidedup; make)
  3. Vytvořit pracovní adresáře skriptem createWorkDirs_single.sh
  4. Soubor warcDownloadServers.cfg obsahuje seznam uzlů, na kterých se bude stahovat CommonCrawl - je vhodné zkontrolovat jeho aktuálnost.
  5. Pro stahování CommonCrawl je nutné někde nějak získat soubor .s3cfg a dát si ho do home.

Spuštění na serverech skupiny KNOT

Zpracování WIkipedie

Kompletní sekvence pro spuštění (zatím neotestováno):

 (označení dumpu je RRRRMMDD)
 cd 1a
 ./download_wikipedia_and_extract_html.sh RRRRMMDD
 cd ..
 
 python ./1/distribute.py -i ./2/NLP-slave/target/NLP-slave-0.0.1-SNAPSHOT-jar-with-dependencies.jar -o /mnt/data/wikipedia/software/ -s servers.txt -a
 python ./2/verticalize.py -i /mnt/data/wikipedia/enwiki-RRRRMMDD/html_from_xml/AA/ -o /mnt/data/wikipedia/enwiki-RRRRMMDD/vert/ -s servers.txt -b /mnt/data/wikipedia/software/NLP-slave-0.0.1-SNAPSHOT-jar-with-dependencies.jar
 python ./1/distribute.py -i ./4/TT-slave/target/TT-slave-0.0.1-SNAPSHOT-jar-with-dependencies.jar -o /mnt/data/wikipedia/software/ -s servers.txt -a
 python ./4/tag.py -i /mnt/data/wikipedia/enwiki-RRRRMMDD/vert/ -o /mnt/data/wikipedia/enwiki-RRRRMMDD/tagged/ -s servers.txt -b /mnt/data/wikipedia/software/TT-slave-0.0.1-SNAPSHOT-jar-with-dependencies.jar
 python ./1/distribute.py -i ./5/MDP-package/MDP-1.0/build/jar/mdp.jar -o /mnt/data/wikipedia/software/ -s servers.txt -a
 python ./5/parse.py -i /mnt/data/wikipedia/enwiki-RRRRMMDD/tagged/ -o /mnt/data/wikipedia/enwiki-RRRRMMDD/parsed/ -s servers.txt -b /mnt/data/wikipedia/software/mdp.jar
 python ./6/ner.py -i /mnt/data/wikipedia/enwiki-RRRRMMDD/parsed/ -o /mnt/data/wikipedia/enwiki-RRRRMMDD/secresult/ -s servers.txt
 python ./1/distribute.py -i ./7/mg4j/ -o /mnt/data/wikipedia/software/mg4j/ -s servers.txt -a
 python ./7/index.py -i /mnt/data/wikipedia/enwiki-RRRRMMDD/secresult/ -o /mnt/data/indexes/enwiki-RRRRMMDD/ -s servers.txt start

Spuštění démonů odpovídajících na dotazy:

 python ./daemon.py -i /mnt/data/indexes/enwiki-RRRRMMDD/final -s servers.txt -b /mnt/data/wikipedia/software/mg4j/ start

Zpracování CommonCraawl

Kompletní sekvence pro spuštění (zatím neotestováno):

 (označení CC je RRRR-MM)
 cd processing_steps/1b/download_commoncrawl
 ./dl_warc.sh RRRR-MM
 cd ../..
 python ./1/distribute.py -i ./2/NLP-slave/target/NLP-slave-0.0.1-SNAPSHOT-jar-with-dependencies.jar -o /mnt/data/commoncrawl/software/ -s servers.txt -a
 python ./2/verticalize.py -i /mnt/data/commoncrawl/CC-RRRR-MM/warc/ -o /mnt/data/commoncrawl/CC-RRRR-MM/vert/ -s servers.txt -b /mnt/data/commoncrawl/software/NLP-slave-0.0.1-SNAPSHOT-jar-with-dependencies.jar
 python ./1/distribute.py -i ./3/dedup/server -o /mnt/data/commoncrawl/software/dedup/ -s servers.txt -a
 python ./1/distribute.py -i ./3/dedup/dedup -o /mnt/data/commoncrawl/software/dedup/ -s servers.txt -a
 cd 3
 parallel-ssh -h servers_only.txt -t 0 -i "mkdir /mnt/data/commoncrawl/CC-RRRR-MM/hashes/"
 (chceme-li načíst hashe z předchozího zpracování, je v následujícím příkazu nutné přidat -i /mnt/data/commoncrawl/CC-RRRR-MM/hashes/)
 python ./server.py start -s servers.txt -w workers.txt -o /mnt/data/commoncrawl/CC-RRRR-MM/hashes/ -b /mnt/data/commoncrawl/software/dedup/server
 python ./deduplicate.py -i /mnt/data/commoncrawl/CC-RRRR-MM/vert/ -o /mnt/data/commoncrawl/CC-RRRR-MM/dedup/ -w workers.txt -s servers.txt -b /mnt/data/commoncrawl/software/dedup/dedup
 python ./server.py stop -s servers.txt -w workers.txt -b /mnt/data/commoncrawl/software/dedup/server
 cd ..
 python ./1/distribute.py -i ./4/TT-slave/target/TT-slave-0.0.1-SNAPSHOT-jar-with-dependencies.jar -o /mnt/data/commoncrawl/software/ -s servers.txt -a
 python ./4/tag.py -i /mnt/data/commoncrawl/CC-RRRR-MM/dedup/ -o /mnt/data/commoncrawl/CC-RRRR-MM/dedup/tagged/ -s servers.txt -b /mnt/data/commoncrawl/software/TT-slave-0.0.1-SNAPSHOT-jar-with-dependencies.jar
 python ./1/distribute.py -i ./5/MDP-package/MDP-1.0/build/jar/mdp.jar -o /mnt/data/commoncrawl/software/ -s servers.txt -a
 python ./5/parse.py -i /mnt/data/commoncrawl/CC-2RRRR-MM/tagged/ -o /mnt/data/commoncrawl/CC-RRRR-MM/parsed/ -s servers.txt -b /mnt/data/commoncrawl/software/mdp.jar
 python ./6/ner.py -i /mnt/data/commoncrawl/CC-RRRR-MM/parsed/ -o /mnt/data/commoncrawl/CC-RRRR-MM/secresult/ -s servers.txt
 python ./1/distribute.py -i ./7/mg4j/ -o /mnt/data/commoncrawl/software/mg4j/ -s servers.txt -a
 python ./7/index.py -i /mnt/data/commoncrawl/CC-RRRR-MM/secresult/ -o /mnt/data/indexes/CC-RRRR-MM/ -s servers.txt start

Spuštění démonů odpovídajících na dotazy:

 python ./daemon.py -i /mnt/data/indexes/CC-RRRR-MM/final -s servers.txt -b /mnt/data/commoncrawl/software/mg4j/ start

Spuštění na Salomonu

 ls -1 /scratch/work/user/idytrych/warc | sed 's/\-warc.gz//' > ~/namelist
 nebo
 ls -1 /scratch/work/user/idytrych/wikitexts/ > ~/namelist
 seq 14 > numtasks
 bash createCollectionsList_single.sh 192
 #PBS -q qexp
 např. za
 #PBS -q qprod
 #PBS -A IT4I-9-16

a přidat

 #PBS -l walltime=48:00:00
 bash prepare_dl_warc_single.sh 2015-3
 Stažení CC (manuálně na login uzlech):
   /scratch/work/user/idytrych/CC-2015-32/download/dload_login1_all.sh
   /scratch/work/user/idytrych/CC-2015-32/download/dload_login2_all.sh
   /scratch/work/user/idytrych/CC-2015-32/download/dload_login3_all.sh
   /scratch/work/user/idytrych/CC-2015-32/download/dload_login4_all.sh
 ls /scratch/work/user/idytrych/CC-2015-32/warc/ | sed 's/\-warc.*//g' > ~/namelist
 mv /scratch/work/user/idytrych/CC-2015-32/warc /scratch/work/user/idytrych/
 wc -l namelist
 (vypsaný počet řádků v namelist je NNN - budeme potřebovat níže)
 (spočítáme NU = NNN / MU, kde MU je max. počet uzlů, co podle dokumentace Salomonu smíme použít paralelně)
 seq NU >numtasks
 qsub -N vert -J 1-NNN:NU vert.sh
 qsub dedup.sh
 qsub -N tag -J 1-NNN:NU tag.sh
 qsub -N parse -J 1-NNN:NU parse.sh
 secapi/SEC_API/salomon/v3/start.sh 3
 (M je počet kolekcí - mělo by být cca 6 na každý cílový server)
 bash createCollectionsList_single.sh M
 (dále předpokládáme, že je dost uzlů na to, aby při 24 i při 8 procesech na uzel bylo možné zpracovat všechny kolekce paralelně)
 seq 24 >numtasks
 qsub -N createShards -J 1-M:24 createShards.sh
 qsub -N populateShards -J 1-M:24 populateShards.sh
 qsub -N makeCollections -J 1-M:24 makeCollections.sh
 seq 8 >numtasks
 qsub -N makeIndexes -J 1-M:8 makeIndexes.sh
 (NP je počet částí, na které chceme Wikipedii rozdělit - tedy počet cílových serverů)
 bash createWikiParts_single.sh NP
 (Neotestovaná část: )
   bash download_and_split_wikipedia_single.sh 20150805
   qsub -N extract_wikipedia extract_wikipedia_html.sh
 ls -1 /scratch/work/user/idytrych/wikitexts/ > ~/namelist
 wc -l namelist
 (vypsaný počet řádků v namelist je NNN - budeme potřebovat níže)
 (spočítáme NU = MAX(14, (NNN / MU)), kde MU je max. počet uzlů, co podle dokumentace Salomonu smíme použít paralelně - tedy nemá smysl méně než 14 na uzel)
 qsub -N vertWiki -J 1-NNN:NU vertWiki.sh
 qsub -N tagWiki -J 1-NNN:NU tag.sh
 qsub -N parseWiki -J 1-NNN:NU parseWiki.s
 (spočítáme NUL = MAX(3, (NNN / MUL)), kde MUL je max. počet uzlů, co podle dokumentace Salomonu smíme použít paralelně v qlong - tedy nemá smysl méně než 3 na uzel)
 secapi/SEC_API/salomon/v3/start.sh NUL
 (M je počet kolekcí - měla by být 1 na každý cílový server)
 bash createCollectionsList_single.sh M
 (dále předpokládáme, že je dost uzlů na to, aby při 24 i při 8 procesech na uzel bylo možné zpracovat všechny kolekce paralelně)
 seq 24 >numtasks
 qsub -N createShards -J 1-M:24 createShards.sh
 qsub -N populateShards -J 1-M:24 populateShards.sh
 qsub -N makeCollections -J 1-M:24 makeCollections.sh
 seq 8 >numtasks
 qsub -N makeIndexes -J 1-M:8 makeIndexes.sh

Spuštění na Salomonu s novými skripty

 ls -1 /scratch/work/user/idytrych/warc | sed 's/\-warc.gz//' > ~/namelist
 nebo
 ls -1 /scratch/work/user/idytrych/wikitexts/ > ~/namelist
 bash prepare_dl_warc_single.sh 2015-32
 Stažení CC (manuálně na login uzlech):
   /scratch/work/user/idytrych/CC-2015-32/download/dload_login1_all.sh
   /scratch/work/user/idytrych/CC-2015-32/download/dload_login2_all.sh
   /scratch/work/user/idytrych/CC-2015-32/download/dload_login3_all.sh
   /scratch/work/user/idytrych/CC-2015-32/download/dload_login4_all.sh
 ls /scratch/work/user/idytrych/CC-2015-32/warc/ | sed 's/\-warc.*//g' > ~/namelist
 mv /scratch/work/user/idytrych/CC-2015-32/warc /scratch/work/user/idytrych/
 bash start.sh vert 10 qprod
 (lze opakovat N-krát a přidat tak další uzly - místo 10 lze i po 20 - ale celkově není dobré dát přes 70 uzlů)
 bash start.sh dedup 4 qprod
 (nelze přidávat uzly)
 bash start.sh tag 10 qprod
 (lze opakovat N-krát a přidat tak další uzly - místo 10 lze i po 20 - ale celkově není dobré dát přes 40 uzlů)
 bash start.sh parse 10 qprod
 (lze opakovat N-krát a přidat tak další uzly - místo 10 lze i po 25 - ale celkově není dobré dát přes 90 uzlů)
 bash start.sh sec 1 qprod
 (lze opakovat N-krát a přidat tak další uzly - místo 1 lze i po 50, ale poprvé po 1. 10 min. pauza na build a celkově není dobré dát přes 100 uzlů)
 mkdir /scratch/work/user/idytrych/CC-2015-32/mg4j_index
 mkdir /scratch/work/user/idytrych/CC-2015-32/mg4j_index/final
 (MMM je počet požadovaných kolekcí - vhodný může být počet cílových serverů * 6)
 bash startIndexing.sh cList MMM
 bash startIndexing.sh cShards qprod /scratch/work/user/idytrych/CC-2015-32/mg4j_index
 bash startIndexing.sh pShards qprod /scratch/work/user/idytrych/CC-2015-32/mg4j_index
 bash startIndexing.sh colls qprod /scratch/work/user/idytrych/CC-2015-32/mg4j_index
 bash startIndexing.sh indexes qprod /scratch/work/user/idytrych/CC-2015-32/mg4j_index
 ...
 bash start.sh vert 1:f qprod
 bash start.sh vert 50 qprod
 (tedy 1. uzel se spustí zvlášť a musí být zaručeno, že poběží po celou dobu zpracování - případně využít qlong)
 (další uzly lze spouštět libovolně rychle a může jich být neomezené množství - i když nemá smysl dát moc přes 150 - pak nestíhají disky)
 bash start.sh dedup 4 qprod
 bash start.sh tag 1:f qprod
 bash start.sh tag 50 qprod
 bash start.sh parse 1:f qprod
 bash start.sh parse 50 qprod
 bash start.sh sec 1:f qlong
 bash start.sh sec 20 qprod
 bash startCheckSec.sh qprod namelist 2 1 /scratch/work/user/idytrych/parsed /scratch/work/user/idytrych/secsgeresult
 bash startCheckSec.sh qprod namelist 2 2 /scratch/work/user/idytrych/parsed /scratch/work/user/idytrych/secsgeresult
 (2 1 je počet částí a která se má spustit - s více částmi lze rychleji dosáhnout výsledku; dalšímu příkazu se počet částí předá -n)
 python remove.py -n 2 -s /scratch/work/user/idytrych/secsgeresult >rm.sh
 sed "s/secsgeresult/sec_finished/;s/.vert.dedup.parsed.tagged.mg4j//" rm.sh >rmf.sh
 bash rm.sh
 bash rmf.sh
 rm rm.sh
 rm rmf.sh
 bash create_restlist.sh namelist /scratch/work/user/idytrych/secsgeresult >restlist
 rm /scratch/work/user/idytrych/counter/*
 bash start.sh sec 1:f qlong restlist
 bash start.sh sec 20 qprod restlist
 bash startCheckIndexes.sh /home/idytrych/collectionlist /scratch/work/user/idytrych/CC-2015-32/mg4j_index "/home/idytrych/check_i.txt"
 (na každém řádku v check_i.txt by měl být správný počet souborů indexu a současně by v žádném chybovém logu neměla být výjimka)

Formáty dat

Manatee

Dobrý příklad manatee formátu lze stáhnout zde:
http://nlp.fi.muni.cz/trac/noske/wiki/Downloads
Konkrétně korpus SUSANNE.
Tento se liší od našeho v tom, že má jen 4 sloupce (my jich máme 27). Všechny tagy začínající na < v tomto formátu zůstávají, nic se nijak netransformuje jako v případě MG4J.
Tedy co se týče potřebných změn, tak to bude pouze nepřidávat GLUE jako variantu tokenu a negenerovat věci jako %%#DOC PAGE PAR SEN. V manatee se také místo prázdné anotace dává podtržítko (v mg4j 0).
V manatee se pak navíc musí vytvořit konfigurační soubor, který definuje tagy a určuje cestu k vertikálnímu souboru, aby bylo možné to programem encodevert naindexovat.

Elasticsearch

Formát ElasticSearch pro sémantické anotace vypadá následovně:

 Slovo[anotace1;anotace2...] a[anotace1;anotace2...] další[...;anotace26;anotace27] slovo[...;anotace26;anotace27]

Tvary anotací mohou být libovolné, avšak mohou obsahovat pouze alfanumerické znaky a podtržítko.
Aktuálně je použit formát zápisu anotací, kde jedna anotace je ve tvaru typAnotace_hodnota.

Typy anotací jsou
position token tag lemma parpos function parword parlemma paroffset link length docuri lower nerid nertag param0 param1 param2 param3 param4 param5 param6 param7 param8 param9 nertype nerlength

Konkrétní anotovaný text pak tedy vypadá:

 Slovo[position_1;token_Slovo...] 

Pro sémantické dotazování se pak používají klasické Lucenovské dotazy (viz testovací dotaz v adresáři projektu).