====== Etalon.v2020 ======

===== Postup práce =====

Potřebujeme:
  * Starý ''Etalon''
  * Převedený Etalon: ''Etalon.v2020''
  * Etalon sjetý MorphoDitou z vert: ''MDita''
  * Etalon sjetý MorphoDitou z in-utf8: ''MDita-plain''

Postup:
  * Starý ''Etalon'' převedeme na ''Etalon.v2020'', tím dostaneme fázi ''vert-morf-simp''
  * Dorazíme ho do konce programem ''process_vert.sh''
  * Porovnáme s ''MDitou'' a s ''MDita-plain''

==== Rychlý návod ====

  * Opravy v ''.../Etalon.v2020/tokenizace/...''
  * Nový ''.../Etalon.v2020/corr-Etalon/vert-Et'' a '' .../Etalon.v2020/corr-Etalon/vert'':<code>
cd /home/skoumal/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/bin
./01_make-vert-Et.sh</code>
  * Nová ''.../Etalon.v2020/corr-Etalon/MDita'' a ''.../Etalon.v2020/corr-Etalon/MDita-plain'':<code>
cd /home/skoumal/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/bin
./02_make-MDita.sh</code>
  * Nový ''.../Etalon.v2020/corr-Etalon/Etalon.v2020''
  * Porovnání ''Etalon.v2020'' a ''MDita-plain''
==== Adresáře ====

  * Kde budeme skladovat data ke sloučení a porovnání: ''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/corr-Etalon''
  * Etalon:
    * ''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/tokenizace/in-utf8.done''
    * ''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/tokenizace/vert_Etalon.done''
    * ''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/tokenizace/Honza_done/in-utf8''
    * ''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/tokenizace/Honza_done/vert-Etalon''
    * ''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/corr-Etalon/vert-ET'' --- linky na hotové vertikály
  * Etalon.v2020:
    * ''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/corr-Etalon/Etalon.v2020''
    * v adresáři ''in-utf8'' jsou linky do tokenizace, musí být bez ''.txt''
  * MDita:
    * ''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/corr-Etalon/MDita''
    * v adresáři ''in-utf8'' jsou linky do tokenizace, musí být bez ''.txt''
  * MDita-plain:
    * ''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/corr-Etalon/MDita-plain''
    * v adresáři ''in-utf8'' jsou linky do tokenizace, musí být bez ''.txt''
  * Sloučený Etalon s MDitou, ze kterého vyrábíme Etalon.v2020:
    * ''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/corr-Etalon/vert-ET-MDita''

==== Závislosti na verzi ====

Kdy je třeba předělat některý kus korpusu:
  * ''Etalon.v2020/corr-Etalon/vert-Et'' obsahuje linky, netřeba předělávat
  * ''Etalon.v2020/corr-Etalon/vert'' --- pokud se změní tokenizace ''vert-Et'':<code>cd .../corr-Etalon
ll -rt vert | tail
ll -rtL vert-Et | tail
cmp-lines.sh vert-Et vert</code>
  * ''MDita'' --- pokud se změní tokenizace a tím pádem i ''vert'':<code>cd .../corr-Etalon
ll -rt MDita/vert-morf | tail
ll -rtL vert | tail</code>(''MDita/vert'' jsou linky do ''vert'')
  * ''vert-Et-MDita'' --- pokud se změní ''vert-Et'' nebo ''MDita/vert-morf-simp'':<code>cd .../corr-Etalon
ll -rtL vert-Et-MDita | tail
ll -rtL vert-Et | tail
ll -rtL MDita/vert-morf-simp | tail</code>
  * ''Etalon.v2020'' --- pokud se změní ''vert-Et-MDita'':<code>cd .../corr-Etalon
ll -rtL Etalon.v2020/vert-morf-simp | tail
ll -rtL vert-Et-MDita | tail</code>


===== Automatický převod z Etalonu =====

==== Popis na fóru ====

  * Tabulka je na fóru: [[http://utkl.ff.cuni.cz/phpbb/viewtopic.php?f=34&t=138&p=244#p244|Etalon.v2020 | Převodní tabulka mezi Etalonem a NÚM]]
  * Data jsou na grimmovi: ''/store/corp/EtalonMerged/vert-EtalonMerged'' a v bonitu: [[http://utkl.ff.cuni.cz/bonito/run.cgi/first_form?corpname=EtalonMerged-EtalonMerged;align=]]
  * Vyrobíme seznam tagů podle jednotlivých POS v Etalonu a v NÚM:<code>cd /store/corp/EtalonMerged/vert-EtalonMerged
cat * | cut -f3 | grep "^V" | sort -u > ../Verb-Etalon.txt
cat * | cut -f8- | perl -pe 's/\t/\n/g' | cut -f2- -d' ' | perl -pe 's/ /\n/g' | grep "^V" | sort -u > ../Verb-NUM.txt</code>Podle toho, jaké máme POS, upravíme buď ...-Etalon.txt nebo ...-NUM.txt:<code>cd ..
perl -i -pe 's/$/-/' Num-NUM.txt</code>nebo<code>
perl -pe 's/.(..)(.)$/$2$1/' Verb-Etalon.txt | sort -u > qqq.txt
mv qqq.txt Verb-Etalon.txt</code>
  * Potom porovnáváme rozdíly:<code>comm ../Verb-Etalon.txt ../Verb-NUM.txt | l</code>
  * Tvary tagů zapisujeme do tabulky.
  * Kontrolujeme i případy, kdy si POS v Etalonu a v NÚM neodpovídají. Jana vytvořila tabulku, kde jsou tyto rozdíly sepsány.

==== Program pro převod ====

  * Program je (zatím) v adresáři ''~skoumal/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/bin''
  * Program vypisuje na ''STDIN'' převedený korpus a na ''STDERR'' chybové hlášky:
    * Capitalization: lemmata i tagy se shodují, liší se pouze velikost písmen v lemmatu
    * Different lemmas: našli jsme vhodný tag, ale lemma se liší (např. vy X ty apod.)
    * No suitable lemma: nenašli jsme žádný vhodný tag (a tudíž ani lemma)
    * Suspicious abbr: slovo je v Etalonu tagováno jako zkratka, ale v morfflexu ne
    * Unknown abbr: slovo je v Etalonu tagováno jako zkratka, ale v morfflexu je neznámé
    * Unknown pronoun
    * Corrupted line
  * Program se spouští takto (na grimmovi):<code>cd /store/corp/EtalonMerged/vert-EtalonMerged
(for ff in *; do echo $ff >&2; ~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/bin/Etalon2v2020.pl < $ff \
> ~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/data/$ff; done) 2> ~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/errors.txt</code>

=== Výroba finálního korpusu ===

  * Převedeme kompletně opravený Etalon do formátu SYN2020:<code>cd .../Etalon.v2020/corr-Etalon/vert-Et-MDita
(for ff in *; do echo $ff; ../../bin/Etalon2v2020.pl -f4 < $ff > ../vert-syn2020/$ff; done) 2> ../errors-200611.txt</code>
  * Vyrobíme korpus:<code>cd .../Etalon.v2020
ln -s corr-Etalon/vert-syn2020
manatee-registry.sh -c. -f vert-syn2020 -t</code>

=== Kontrola ===

  * Zkontrolujeme i tagy programem ''check-vert-tag.pl'':<code>cd .../Etalon.v2020/corr-Etalon/vert-syn2020
cat * | /net/grimm/usr/local/corp/bin/check-vert-tag.pl -t > /dev/null</code>
  * Vyrobíme korpus z převedeného Etalonu a MorphoDity:<code>cd .../Etalon.v2020/corr-Etalon/vert-syn2020
for ff in *; do echo $ff; paste $ff <(cut -f2- ../vert-morf-simp/$ff) | perl -pe 's/^[\t\ ]+$//' > ../vert-syn2020-MDita/$ff; done</code>
  * Zkontrolujeme programem ''Etalon-cmp-v2020.pl'' a vyrobíme korpus:<code>cd ../vert-syn2020-MDita
for ff in *; do echo $ff; ../../bin/Etalon-cmp-v2020.pl < $ff > ../vert-cmp-MDita/$ff; done</code><code>cd ../..
ln -s corr-Etalon/vert-cmp-MDita
manatee-registry.sh -c. -f vert-cmp-MDita</code>config:<code>
PATH  /net/chomsky/store/manatee-registry/Etalon.v2020-cmp-MDita-data
ENCODING utf-8
INFO "Převedený Etalon porovnaný s nabídkou z MDity, 17.6.2020"

ATTRIBUTE word {
  TYPE "FD_FGD"
}
ATTRIBUTE elemma {
  TYPE "FD_FGD"
}
ATTRIBUTE etag {
  TYPE "FD_FGD"
}
ATTRIBUTE lt {
  TYPE "FD_FGD"
}
ATTRIBUTE l {
  TYPE "FD_FGD"
}
ATTRIBUTE t {
  TYPE "FD_FGD"
}
ATTRIBUTE lemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP " "
}
ATTRIBUTE tag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP " "
}

STRUCTURE doc {
  ATTRIBUTE file
}

STRUCTURE s
</code>

==== Vývoj převodního programu ====

  * Roztřídíme chyby na ''Capitalization.txt'', ''Different_lemmas.txt'' a ''No_suitable_lemma.txt'' a hledáme rozdíly. Buď opravíme Etalon, nebo doplníme seznamy pro program:
    * ''SeznamEtalon_abbreviations.tsv''
    * ''SeznamEtalon_elemmas.tsv''
    * ''SeznamEtalon_etags.tsv''
    * ''SeznamEtalon_mlemmas.tsv''
    * ''SeznamEtalon_mlemmas_mtags.tsv''
    * ''SeznamEtalon_mtags.tsv''

==== Morfologická analýza Etalonu MDitou ====

  * Vyrobíme adresář ''.../Etalon.v2020/corr-Etalon'' a v něm tyto další adresáře:
    * ''Etalon.v2020''
    * ''MDita''
    * ''MDita-plain''
    * ''in-utf8''
    * ''vert-Et''
    * ''vert-Et-MDita''
  * Do ''vert-Et'' zkopírujeme opravený Etalon přetokaný programem ''disconnect.pl'':<code>
cd .../Etalon.v2020/tokenizace/vert_Etalon.done
for ff in *; do echo $ff; ../../bin/disconnect.pl < $ff > ../../corr-Etalon/vert-Et/$ff; done
cd ../Honza_done/vert-Etalon
for ff in *; do echo $ff; ../../../bin/disconnect.pl < $ff > ../../../corr-Etalon/vert-Et/$ff; done</code>a výsledek zkontrolujeme:<code>
cd .../corr-Etalon
parallel-filter.sh -C "check-vert-tag.pl -t -l16" -s vert-Et -n -p10</code>
  * Do vert z něj uřízneme vertikálu:<code>cd vert-Et
for ff in *; do cut -f1 $ff > ../vert/$ff; done</code>nebo paralelně:<code>
parallel-filter.sh -C "cut -f1" -e -p10 -s vert-Et -t vert -v</code>
  * Provedeme analýzu MDitou:<code>cd ../MDita
mkdir vert
cd vert
for ff in ../../vert/*; do ln -s $ff; done
cd ..
process_vert.sh -v -p10 -s vert</code>a omrkneme tokenizaci:<code> cd ..
cmp-lines.sh vert-Et MDita-plain/vert-morf-simp-nosp-sgcr-con-sublm/ | l</code>
  * Sloučíme Etalon s takto vyrobeným korpusem:<code>cd ../vert-Et
for ff in *; do paste $ff <(cut -f2- ../MDita/vert-morf-simp/$ff) | perl -pe 's/^[\ \t]+$//' > ../vert-Et-MDita/$ff; done</code>
  * Zkontrolujeme, zda nedošlo k posunu:<code>cd ../vert-Et-MDita
tail * | l -S</code>nebo<code>grep -P "^[\t\ ]" *
grep -P "[\t\ ]$" *</code>
  * Můžeme vyrobit korpus **''Etalon.v2020-Et-MDita''**:<code>
cd .../Etalon.v2020
ln -s corr-Etalon/vert-Et-MDita
manatee-registry.sh -c. -f vert-Et-MDita</code>config:<code>
PATH  /net/chomsky/store/manatee-registry/Etalon.v2020-Et-MDita-data
ENCODING utf-8
INFO "Celý Etalon porovnaný s MDitou, RC1, 16.6.2020"

ATTRIBUTE word {
  TYPE "FD_FGD"
}
ATTRIBUTE elemma {
  TYPE "FD_FGD"
}
ATTRIBUTE etag {
  TYPE "FD_FGD"
}
ATTRIBUTE lemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP " "
}
ATTRIBUTE tag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP " "
}
STRUCTURE doc {
  ATTRIBUTE file
}

STRUCTURE s</code>
==== Převod Etalonu do formátu SYN2020 a porovnání s MDitou ====

  * Provedeme převod Etalonu do formátu MDity a vypíšeme si chybové hlášky:<code>
cd .../Etalon.v2020/corr-Etalon/vert-Et-MDita
(cat * | ../../bin/Etalon2v2020.pl -f4 > /dev/null) 2> ../errors.txt</code>Chceme-li dostat i převedený Etalon, spustíme program takto:<code>
(for ff in *; do echo $ff; ../../bin/Etalon2v2020.pl -f4 < $ff > ../Etalon.v2020/vert-morf-simp/$ff; done) 2> ../errors-200611.txt</code>
  * Dorazíme Etalon.v2020 do konce:<code>cd ../Etalon.v2020
/usr/local/syn2020/bin/process_vert.sh -v -p10 -s vert-morf-simp</code>
  * Sloučíme s MDitou a přitom provedeme porovnání:<code>cd ../Etalon.v2020/vert-morf-simp-nosp-sgcr-con-sublm
for ff in *; do echo $ff; paste $ff <(cut -f3- ../../MDita/vert-morf-simp-nosp-sgcr-con-sublm/$ff) |\
perl -pe 's/^[\t\ ]+$//' | ../../../bin/Etalon-cmp-v2020.pl > ../../vert-cmp-v2020-MDita/$ff; done</code>
  * Vyrobíme si korpus:<code>cd .../Etalon.v2020
ln -s corr-Etalon/vert-cmp-v2020-MDita
manatee-registry.sh -c. -f vert-cmp-v2020-MDita</code>config:<code>
PATH  /net/chomsky/store/manatee-registry/Etalon.v2020-Merged-data
ENCODING utf-8
INFO "Celý Etalon porovnaný s MDitou, 29.5.2020"

ATTRIBUTE word {
  TYPE "FD_FGD"
}
ATTRIBUTE elemma {
  TYPE "FD_FGD"
}
ATTRIBUTE etag {
  TYPE "FD_FGD"
}
ATTRIBUTE lemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP " "
}
ATTRIBUTE tag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP " "
}
STRUCTURE doc {
  ATTRIBUTE file
}

STRUCTURE s
</code>

==== Dodatečné opravy ====

  * V Etalonu:
    * Entity ''&url;'' a ''&email;'' mají tag <html><span style="font-family:monospace">NN------------8-</span></html>
    * Slovo ''spíše'' má lemma ''spíš'' a tag s ''1'' na konci
  * V seznamech:
    * Slovo ''nazdar'' podle MDity
  * Po konverzi:
    * Slovo ''dřív'' má mít variantu ''1'', ne ''5''
    * Slovo ''lidé'' nemá mít variantu, slovo ''lidi'' naopak má mít ''1'' (v 1. a 5. pádě)
    * Slova ''líp'', ''hůř'', ''míň'', ''víc''
    * Slova ''sto'', ''tisíc'', ''pár''
    * Slova s ''X''
      * ''in-line'' (<html><span style="font-family:monospace">AAXXX----1A----</span></html>)
      * ''džiu-džitsu'', ''tai-či'', ''Sado-maso'', ''go-go'', ''sci-fi'' (<html><span style="font-family:monospace">NNNXX-----A----</span></html>)
      * ''pop-music'' (<html><span style="font-family:monospace">NNFXX-----A----</span></html>)

===== Použití pro trénování pajpy =====

  * Je třeba dodat ''verbtagy'' a dále pracovat s tímto korpusem
  * Převedený ''Etalon.v2020'', který už se nebude znovu generovat ze starého ''Etalonu'' je umístěn v **''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/testing-rules/Opravy/final''**. FIXME Vymyslet lepší adresář a přesunout ho tam. Pro teď máme link **''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/final''**.
  * :!: Aktuální nejlepší ''Etalon.v2020'' je umístěn v **''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/MorphoDiTa-training/vert-final''**. Odtud je pravidelně kopírován do **''/data/syn2020/Etalon/vert-final''**, což je **finální** umístění korpusu.
  * :!: Podobně **finální plain texty** jsou pravidelně kopírovány do **''/data/syn2020/Etalon/in-utf8''**.

==== Přidání verbtagů ====

  * Pouhé přidání ''verbtagů'':<code>
parallel-filter.sh -C "add_verbtag_and_clsep.pl -l | bin/remove-person.pl" -s final -t vrbtg8 -v -p10</code>
  * Přidání ''verbtagů'' a odstranění nesprávných osob u participií:<code>
parallel-filter.sh -C "add_verbtag_and_clsep.pl -l | bin/prune-vrbtg.pl" -s final -t vrbtg8-prune -v -p10</code>

==== Porovnání osob s Etalonem ====

  * Pracuje se v adresáři ''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/testing-rules/Opravy''.
  * Adresář ''final'' obsahuje aktuální nejlepší Etalon.v2020 s tagy o délce 15. Soubory mají formát<code>
<p>
forma<TAB>space<TAB>lemma<SPACE>tag

</code>
  * Vyrobí se ''vrbtg8'', ale jenom u sloves:<code>
parallel-filter.sh -C "add_verbtag_and_clsep.pl -l | ../../bin/remove-person.pl" -s final -t vrbtg8 -v -p45</code>
  * Spustí se pravidla (celý ''root''): <code>
parallel-filter.sh -C "/net/grimm/usr/local/langr/rules/bin/gc_ucs2_release.x --lex=/usr/local/syn2020/LEX_ucs2 \
  --action=single --input=wide_vertical --output=wide_vertical --collocations=restore --empty_positions=restore \
  --trace_deletions=no --group=root | remove-dupl-vert-utf8.pl" \
  -s vrbtg8 -t vrbtg8-rules -p 45 -v 2> errlog/rules-pers.log</code>
  * Vyrobí se korpus tímto příkazem:<code>cd vrbtg8-rules
for ff in *; do echo $ff; paste <(paste <(grep -v "<p>" ../final/$ff) \
  <(../../../bin/move-person.pl < $ff | remove-dupl-vert-utf8.pl | cut -f2- ) \
  | ../../../bin/Etalon.v2020-cmp-rules.pl | cut -f1-7) <(cut -f2- $ff) | perl -pe 's/^[\t ]+$//' > ../osoby/$ff; done</code>

==== Porovnání s všemi pravidly ====

<hidden>
  * Předchozí postup
  * Pracujeme v adresáři ''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/testing-rules/Rules''.
  * Vytvoříme adresář ''Etalon-final'', ve kterém vyrobíme ''Etalon'' ve tvaru<code>
forma<TAB>lemma<SPACE>tag</code>tímto příkazem:<code>cd .../Opravy/final
for ff in $(ls -B); do echo $ff; \
    grep -v "<p>" $ff | sed '1{/^$/d}' | cut -f1,3- > ../../Rules/Etalon-final/$ff; done</code>
  * Vyrobíme i vertikálu, ve které slepíme zpátky agregáty:<code>
cd .../Opravy/final
mkdir ../../Rules/vert
for ff in $(ls -B); do echo $ff; \
    cut -f1-2 $ff | grep -v "<p>" | sed '1{/^$/d}' | perl -pe 'undef $/; s/(\p{Latin}+)\t0\n([\p{Latin}]+)/$1$2/gi' \
    | cut -f1 > ../../Rules/vert/$ff; done</code>
  * Spustíme ''process_text.sh'' od ''vert'':<code>cd .../Rules
process_text.sh -l -p45 -s vert -v</code>a zkontrolujeme zarovnání:<code>cd vert-morf-simp-nosp-sgcr-con-sublm-vrbtg8
for ff in *; do echo $ff; sdiff -s <(cut -f1 $ff) <(cut -f1 ../Etalon-final/$ff); done</code>Pokud vlevo nebo vpravo přebývají volné řádky, spustíme opravu:<code>mkdir ../vert-morf-simp-nosp-sgcr-con-sublm-segcor-vrbtg8
for ff in *; do echo $ff; \
    ../../../bin/correct_segm.pl ../Etalon-final/$ff $ff \
    > ../vert-morf-simp-nosp-sgcr-con-sublm-segcor-vrbtg8/$ff; done</code>A můžeme znovu zkontrolovat:<code>
cd ../vert-morf-simp-nosp-sgcr-con-sublm-segcor-vrbtg8
for ff in *; do echo $ff; sdiff -s <(cut -f1 $ff) <(cut -f1 ../Etalon-final/$ff); done</code>
</hidden>
  * Pracujeme v adresáři ''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/MorphoDiTa-training''.
<hidden>
  * Vytvoříme adresář ''Etalon-final'', ve kterém vyrobíme ''Etalon'' ve tvaru<code>
forma<TAB>lemma<SPACE>tag</code>tímto příkazem:<code>cd vert-korpus
for ff in $(ls -B); do echo $ff; cut -f1,3- $ff > ../Rules/Etalon-final/$ff; done</code>
</hidden>
  * Spustíme ''process_text.sh'' na plain text:<code>
process_text.sh -l -v -p45</code>a spravíme segmentaci:<code>
mkdir -p vert-segcor-vrbtg8
cd vert-vrbtg8
for ff in *; do echo $ff; ../../bin/correct_segm.pl ../vert-korpus/$ff $ff > ../vert-segcor-vrbtg8/$ff; done</code>a zkontrolujeme zarovnání:<code>cd ../vert-segcor-vrbtg8
for ff in *; do echo $ff; sdiff -s <(cut -f1 $ff) <(cut -f1 ../vert-korpus/$ff); done</code>
  * Spustíme pravidla:<code>cd ..
parallel-filter.sh -C "/net/grimm/usr/local/langr/rules/bin/gc_ucs2_release.x --lex=/usr/local/syn2020/LEX_ucs2 \
  --action=single --input=wide_vertical --output=wide_vertical --empty_positions=restore \
  --trace_deletions=no --group=root | negr_kolokace_vert_ucs2.pl | remove-dupl-vert-utf8.pl" \
  -s vert-segcor-vrbtg8 -t vert-segcor-vrbtg8-rules -p 45 -v 2> errlog/rules.log</code>
  * Nakonec vyrobíme korpus:<code>mkdir rules
cd vert-segcor-vrbtg8-rules
for ff in *; do echo $ff; paste <(cut -f1,3- ../vert-korpus/$ff) <(cut -f2- $ff) \
    | ../../bin/Etalon.v2020-cmp-rules.pl > ../rules/$ff; done</code>
  * Program ''manatee-registry.sh'' spouštíme s přepínačem ''-t'':<code>
manatee-registry.sh -c. -f vert-cmp-rules -t</code>

  
==== Definitivní Etalon s dlouhými tagy ====

  * Pro trénování MorphoDiTy potřebujeme Etalon s dlouhými tagy (21 pozic???)
  * Pracujeme v adresáři ''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/MorphoDiTa-training''
  * Za zdroj slouží Etalon s osobami:<code>cd .../Etalon.v2020/testing-rules/Opravy/vrbtg8-rules
for ff in $(ls -B); do echo $ff; \
    cat $ff | perl -pe 's/(\ .{21})[^\ ][^\ ]/$1/g' | remove-dupl-vert-utf8.pl \
    > ../../../MorphoDiTa-training/MDita-21/$ff; done</code>
  * Opravíme osoby podle Etalonu:<code>cd .../Etalon.v2020/testing-rules/Opravy/final
for ff in $(ls -B); do echo $ff; \
    ../../../bin/correct_segm.pl $ff ../../../MorphoDiTa-training/MDita-21/$ff \
    > ../../../MorphoDiTa-training/MDita-21-segcor/$ff; done
for ff in $(ls -B); do echo $ff; \
    paste $ff <(cut -f2- ../../../MorphoDiTa-training/MDita-21-segcor/$ff) | perl -pe 's/^[\t\ ]+$//' \
    | ../../../bin/Etalon.v2020-corr-pers.pl | perl -pe 's/ Vp.{13}V..[13]v.//g' | remove-dupl-vert-utf8.pl \
    > ../../../MorphoDiTa-training/MDita-21-segcor-pers/$ff; done
</code>
  * Připravíme data pro ruční opravy:<code>cd ../../../MorphoDiTa-training
ln -s MDita-21-segcor-pers vert-MDita
make-corp.sh -s vert-MDita -t csts-MDita -v -p45
mv csts-MDita Etalon-import
</code>
  * Po ruční opravě připravíme vertikálu pro dokončení oprav:<code>
cd ~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/MorphoDiTa-training/Etalon-export
for ff in *-HS; do mv $ff ${ff%-HS}; done
for ff in *-TJ; do mv $ff ${ff%-TJ}; done
for ff in *-JS; do mv $ff ${ff%-JS}; done
for ff in *; do echo $ff; \
    cat $ff | perl -pe 's/(<f[^<]+)(.*<t[^\n]+)$/$1<src>M$2/' | perl -pe 's/(<[fd][^<]+)(.*<MMt>[^<\n]+)$/$1<src>R$2/' \
    | perl -pe 's/<MM.*(<l[^>]+>.*<t[^>]+>[^i][^n][^v][^a][^l][^i][^d])/$1/' \
    | perl -pe 's/(<f[^>]*>[^<]+<src>.<MMl>[^<]+)(.*)<l[^>]+>invalid<t[^>]+>(.*)$/$1<MMt>$3$2/' \
    | perl -pe 's/<([lt])[^>]+>/<MM$1>/g' \
    > ../csts-export/$ff; done
cd ..
make-corp.sh -s csts-export -t vert-export -v -p45
</code>a připravíme finální vertikálu, kterou budeme ručně opravovat:<code>cd vert-export
for ff in *; do echo $ff; \
    cat $ff | perl -pe 's/<src>/\t/' | perl -pe 's/ /\t/' | perl -pe 's/(\tinvalid) /$1\t/' \
    > ../vert-korpus/$ff; done</code>
  * Pro Bonito vyrobíme vertikálu, ve které budou oddělené verbtagy:<code>cd ../vert-korpus
for ff in $(ls -B); do echo $ff; \
    perl -pe 's/(\t.{15})(.{6})$/$1\t$2/' $ff > ../vert-korpus-verbtags/$ff; done</code>
  * Korpus pro Bonito bude mít název ''Etalon.v2020-verbtags'' a vyrobí se v adresáři ''Etalon.v2020'' příkazem<code>
manatee-registry.sh -c. -f vert-verbtags -t</code>

==== Sjednocení in-utf8, vert-vrbtags a vert-korpus ====

  * Všechny finální verze korpusů si musí odpovídat.
  * Hlavní adresář se všemi (polo)verzemi je ''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020''.
  * Finální ''in-utf8'' je v ''tokenizace/in-utf8.done'' a ''tokenizace/Honza_done/in-utf8''. Vedou tam linky z ''corr-Etalon/in-utf8''. Další linky jsou v ''testing-rules/Opravy'' a ''testing-rules/Rules''.
  * Finální Etalon s mezerami a ''<p>'' je v ''testing-rules/Opravy/final''.
  * Finální Etalon s verbtagy je v ''MorphoDiTa-training/vert-korpus''. V těchto souborech musíme opravit entity:<code>
cd MorphoDiTa-training/vert-korpus
for ff in $(ls -B | xargs grep -l '&percnt;'); do echo $ff; perl -i.bak -pe 's/&percnt;/%/g' $ff; done
for ff in *.bak; do echo ${ff%.bak}; sdiff -s ${ff%.bak} $ff; done
rm *.bak
for ff in $(ls -B | xargs grep -l '&ast;'); do echo $ff; perl -i.bak -pe 's/&ast;/*/g' $ff; done
for ff in $(ls -B | xargs grep -l '&lsqb;'); do echo $ff; perl -i.bak -pe 's/&lsqb;/[/g' $ff; done
for ff in $(ls -B | xargs grep -l '&rsqb;'); do echo $ff; perl -i.bak -pe 's/&rsqb;/]/g' $ff; done
for ff in $(ls -B | xargs grep -l '&amp;'); do echo $ff; perl -i.bak -pe 's/&amp;/&/g' $ff; done
</code>
  * V ''in-utf8'' je třeba ohlídat segmentaci a mezery před '','' (čárkou) a ''.'' (tečkou).
  * To, že si odpovídají ''in-utf8'' a ''vert-korpus'', zkontrolujeme takto:<code>cd MorphoDiTa-training/vert-korpus
for ff in $(ls -B); do echo $ff; \
    no_space_after_token_morphanal.pl ../in-utf8/$ff /dev/null < $ff > /dev/null; done</code>
  * Podobně zkontrolujeme ''in-utf8'' a ''final'':<code>cd testing-rules/Opravy/final
for ff in $(ls -B); do echo $ff; \
    grep -v "<p>" $ff | no_space_after_token_morphanal.pl ../in-utf8/$ff /dev/null > /dev/null; done</code>
    
==== Data pro Tomáše ====

  * Nalézají se v adresáři ''/data/syn2020/Etalon''.
  * V podadresářích ''vert-verbtag'' (kopie ''verb-korpus'' ode mne) a ''in-utf8'' jsou zkopírovaná moje data.
  * Je třeba vytvořit morfologickou nabídku pro MorphoDiTu, opravit segmentaci a vyrobit trénovací data.
  * **Morfologická nabídka**:<code>cd /data/syn2020/Etalon
process_text.sh -l -v -p45</code>
  * **Oprava segmentace**:<code>cd vert-vrbtg8
for ff in $(ls -B); do echo $ff; ~skoumal/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/bin/correct_segm.pl ../vert-verbtag/$ff $ff \
    > ../vert-vrbtg8-segcor/$ff; done</code>
  * **Trénovací data**:<code>cd ../Tools
./train_data_for_MDita.sh</code>
  * Trénovací data jsou v adresáři ''vert-morphodita''.
    
===== Porovnávání s výsledky z natrénované MorphoDiTy =====

  * Adresář ''/data/syn2020/Etalon/vert-morphodita-result'' se porovnává s ''vert-korpus''.

==== Zarovnání obou korpusů ====

  * Porovnáme zarovnání:<code>cd .../vert-korpus
for ff in $(ls -B); do echo $ff; sdiff -s <(cut -f1 $ff) <(cut -f1 /data/syn2020/Etalon/vert-morphodita-result/$ff); done | l
sdiff -l <(cut -f1 klidXXXXX) <(cut -f1 /data/syn2020/Etalon/vert-morphodita-result/klidXXXXX) | l -j10</code>

==== Výroba korpusu pro porovnání ====

  * V adresáři ''~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/MorphoDiTa-training'' uděláme link ''vert-Morphodita -> /data/syn2020/Etalon/vert-morphodita-result''
  * Vytvoříme adresář ''vert-Morphodita-verbtags'' a v něm vyrobíme korpus s oddělenými verbtagy:<code>cd vert-korpus
for ff in $(ls -B); do echo $ff; \
    perl -pe 's/(\t.{15})(.{6})$/$1\t$2/' ../vert-Morphodita/$ff > ../vert-Morphodita-verbtags/$ff; done</code>
  * Vytvoříme adresář ''vert-cmp-MorphoDiTa'' a v něm vyrobíme texty pro korpus:<code>cd ../vert-korpus
for ff in $(ls -B); do echo $ff; \
    paste $ff <(cut -f2- ../vert-Morphodita/$ff) | perl -pe 's/^[\t\ ]+$//' \
    | ../../bin/Etalon.v2020-cmp-morphodita.pl > ../vert-cmp-MorphoDiTa/$ff; done</code>

==== Výroba korpusu pro porovnání s vert ====

  * Pracujeme v adresáři ''/store/corp/Etalon.2020'', kam si zkopírujeme všechny potřebné soubory/adresáře.
  * Adresář ''start-vert'' obsahuje vertikálu a soubory vyrobené z ní. 
    * Adresáře zkopírované:
      * ''in-utf8''
      * ''vert-final''
    * Adresáře vytvořené skripty:
      * ''vert'' --- formátem odpovídá ''vert-mdita''
      * ''vert-final-sublm-agr'' --- z tohoto adresáře se vyrobí ''vert''
      * ''vert-mdita-kolok-sublm-agr''
      * ''vert-rules-mdita-kolok-sublm-agr''
      * ''vert-rules0-frazrl-rules-mdita-kolok-sublm-agr''
  * Adresář ''etalon'' obsahuje hotový Etalon.
    * Adresáře zkopírované:
      * ''vert-final''
    * Linky:
      * ''in-utf8 -> ../start-vert/in-utf8''
      * ''vert -> ../start-vert/vert''
      * ''vert-mdita -> vert-final''
      * ''vert-morf-simp-nosp-sgcr-con -> ../start-vert/vert-morf-simp-nosp-sgcr-con''
    * Adresáře vytvořené skripty:
      * ''vert-mdita-kolok-sublm-agr''
  * Potřebujeme docílit toho, aby ''vert-final'' byl segmentován stejně jako ''vert''. Problém je v tom, že ''vert-final'' má rozlepené agregáty. ale ve ''vert'' je potřebujeme slepené. Cesta je vyrobit ''vert-final-sublm-agr'' a z něj pak ukousnout ''vert''.
  * Postup výroby ''vert-final-sublm-agr'':
    * V adresáři ''start-vert'' vyrobíme ''vert-mdita-sublm-agr'', abychom získali ''vert-morf-simp-nosp-sgcr-con'':<code>cd start-vert
process_text.sh -s vert -m -v -p45</code>
    * V adresáři ''etalon'' vyrobíme ''vert-mdita-sublm-agr'' (:!: pozor, ať nesmažeme soubory ve ''vert-final'' :!:):<code>cd etalon
process_text.sh -s vert-mdita -v -p45</code>
    * Porovnáme vyrobený ''etalon'' s ''vert'':<code>cd etalon/vert-mdita-sublm-agr
for ff in *; do echo "FILE: $ff"; sdiff -s <(cut -f1 $ff) ../vert/$ff; done | l</code>

===== Porovnání Etalonu s rules, frazrl a mditou =====

  * Vytvoříme kolokace z ručně udělaného etalonu. Dále etalon sjedeme pravidly, pravidly s frazrl a holou MorphoDiTou z vertikály a výsledky taky opatříme kolokacemi.

==== Kolokace z Etalonu ====

  * V adresáři ''/store/corp/Etalon.2020/etalon'' vyrobíme ''vert-morf-simp-nosp-sgcr-con'':<code>cd etalon
process_text.sh -s vert -t vrbtg8 -v -p45</code>
  * Soubory ve ''vert-morf-simp-nosp-sgcr-con'' zarovnáme s těmi z ''vert-final'' pomocí ''correct_segm.pl'':<code>
mkdir vert-morf-simp-nosp-sgcr-con.prac
mkdir vert-final-space
cd vert-morf-simp-nosp-sgcr-con
cp -p * ../vert-morf-simp-nosp-sgcr-con.prac</code><del>cd vert-morf-simp-nosp-sgcr-con
for ff in *; do split-sufixoid.pl < $ff > ../vert-morf-simp-nosp-sgcr-con.prac/$ff; done</del><code>
cd ../vert-final
for ff in *; do echo $ff; no_space_after_token_morphanal.pl ../in-utf8/$ff /dev/null < $ff > ../vert-final-space/$ff; done
cd ../vert-final-space
for ff in *; do echo $ff; correct_segm.pl $ff ../vert-morf-simp-nosp-sgcr-con.prac/$ff > ../vert-morf-simp-nosp-sgcr-con/$ff; done</code>
  * Vyrobíme ''vert-mdita-correct'':<code>ln -s vert-final vert-mdita
process_text.sh -s vert-mdita -t in -v -p45</code>
  * Vyrobíme kolokace:<code>process_kolok.sh -s vert-mdita-correct -v -p45</code>a zkontrolujeme:<code>
cd vert-mdita-kolok-sublm-agr
for ff in *; do echo $ff; no_space_after_token_morphanal.pl ../in-utf8/$ff /dev/null < $ff > /dev/null; done
for ff in *; do cut -f1-6 $ff | check-vert-tag-v2020.pl -c5 -t -V > /dev/null; done</code>

==== Zpracování třemi metodami ====

  * Pracujeme v adresáři ''/store/corp/Etalon.2020/start-vert''

=== S kolokacemi ===

  * Vyrobíme vertikály z ''vert'':<code>cd start-vert
process_text.sh -s vert -t in -m -v -p45
process_text.sh -s vert -t in -v -p45
process_text.sh -s vrbtg8 -t in -f -v -p45</code>
  * Opravíme slepená adjektiva s kolokacemi ve ''vert-mdita-correct'':<code>mkdir -p vert-mdita-correct.prac
mkdir -p vert-rules-mdita-correct.prac
mkdir -p vert-rules0-frazrl-rules-mdita-correct.prac
cd vert-mdita-correct
for ff in *; do correct-sufixoid.pl < $ff > ../vert-mdita-correct.prac/$ff; done
cd ../vert-rules-mdita-correct
for ff in *; do correct-sufixoid.pl < $ff > ../vert-rules-mdita-correct.prac/$ff; done
cd ../vert-rules0-frazrl-rules-mdita-correct
for ff in *; do correct-sufixoid.pl < $ff > ../vert-rules0-frazrl-rules-mdita-correct.prac/$ff; done</code>a přesuneme opravené soubory zpět do ''-correct'':<code>cd ../vert-mdita-correct.prac
mv * ../vert-mdita-correct/
cd ../vert-rules-mdita-correct.prac
mv * ../vert-rules-mdita-correct/
cd ../vert-rules0-frazrl-rules-mdita-correct.prac
mv * ../vert-rules0-frazrl-rules-mdita-correct/</code>

  * Vyrobíme kolokace:<code>cd ..
process_kolok.sh -s vert-mdita-correct -v -p45
process_kolok.sh -v -p45
process_kolok.sh -s vert-rules0-frazrl-rules-mdita-correct -v -p45</code>

=== Bez kolokací ===

  * Vyrobíme vertikály z ''vert'':<code>
process_text.sh -s vert -m -v -p45
process_text.sh -s vert -v -p45
process_text.sh -s vrbtg8 -f -v -p45</code>
  * Opravíme slepená adjektiva ve ''vert-mdita-sublm-agr'':<code>mkdir -p vert-mdita-sublm-agr.prac
mkdir -p vert-rules-mdita-sublm-agr.prac
mkdir -p vert-rules0-frazrl-rules-mdita-sublm-agr.prac
cd vert-mdita-sublm-agr
for ff in *; do correct-sufixoid.pl < $ff > ../vert-mdita-sublm-agr.prac/$ff; done
cd ../vert-rules-mdita-sublm-agr
for ff in *; do correct-sufixoid.pl < $ff > ../vert-rules-mdita-sublm-agr.prac/$ff; done
cd ../vert-rules0-frazrl-rules-mdita-sublm-agr
for ff in *; do correct-sufixoid.pl < $ff > ../vert-rules0-frazrl-rules-mdita-sublm-agr.prac/$ff; done</code>
  * Přesuneme opravené soubory zpět do ''-sublm-agr'':<code>cd ../vert-mdita-sublm-agr.prac
mv * ../vert-mdita-sublm-agr/
cd ../vert-rules-mdita-sublm-agr.prac
mv * ../vert-rules-mdita-sublm-agr/
cd ../vert-rules0-frazrl-rules-mdita-sublm-agr.prac
mv * ../vert-rules0-frazrl-rules-mdita-sublm-agr/</code>


  * Zkontrolujeme vůči ''in-utf8'' ve všech adresářích:<code>cd ../vert-mdita-sublm-agr
for ff in *; do no_space_after_token_morphanal.pl ../in-utf8/$ff /dev/null < $ff > /dev/null; done
cd ../vert-rules-mdita-sublm-agr
for ff in *; do no_space_after_token_morphanal.pl ../in-utf8/$ff /dev/null < $ff > /dev/null; done
cd ../vert-rules0-frazrl-rules-mdita-sublm-agr
for ff in *; do no_space_after_token_morphanal.pl ../in-utf8/$ff /dev/null < $ff > /dev/null; done</code>

==== Výroba korpusu pro porovnání všech tří metod s Etalonem ====

  * Pracujeme v adresáři ''/store/corp/Etalon.2020/compare''
  * V něm jsou tyto adresáře:''etalon'', ''etalon-prac'', ''frazrl'', ''frazrl-prac'', ''mdita'', ''mdita-prac'', ''rules'' a ''rules-prac'', ve kterých připravujeme zarovnaná data pro korpus, a ''korpus'', kde je výsledná vertikála.

=== S kolokacemi ===

  * Nejdříve nakopírujeme data do pracovních adresářů: <del>cd ../etalon/vert-mdita-kolok-sublm-agr
cp -p * ../../compare/etalon</del><code>
cd ../start-vert/vert-mdita-kolok-sublm-agr
cp -p * ../../compare/mdita-prac
# for ff in astroprvX bulv0518 si080520 zitkonceX; do split-sufixoid.pl < $ff > ../../compare/mdita-prac/$ff; done
cd ../vert-rules-mdita-kolok-sublm-agr
cp -p * ../../compare/rules-prac
# for ff in astroprvX bulv0518 si080520 zitkonceX; do split-sufixoid.pl < $ff > ../../compare/rules-prac/$ff; done
cd ../vert-rules0-frazrl-rules-mdita-kolok-sublm-agr
cp -p * ../../compare/frazrl-prac
# for ff in astroprvX bulv0518 si080520 zitkonceX; do split-sufixoid.pl < $ff > ../../compare/frazrl-prac/$ff; done</code>a v adresáři ''compare/mdita-prac'' ještě ručně opravíme roztržené //Cos// v souboru ''zassrdvf01'' okolo řádky 31776, //nemohls// v souboru ''o_lasceXX''okolo řádky 34872 a //Neměls// v souboru samanebX01 okolo řádky 48870.
  * Spravíme segmentaci a při tom vytvoříme soubory v základních adresářích:<code>cd ../../compare/etalon
for ff in $(ls -B); do echo $ff; correct_segm.pl $ff ../mdita-prac/$ff > ../mdita/$ff; done
for ff in $(ls -B); do echo $ff; correct_segm.pl $ff ../rules-prac/$ff > ../rules/$ff; done
for ff in $(ls -B); do echo $ff; correct_segm.pl $ff ../frazrl-prac/$ff > ../frazrl/$ff; done
</code>
  * Korpusy rozházíme po sloupcích:<code>cd ../compare/etalon
for ff in $(ls -B); do cut -f1-2 $ff > ../etalon-prac/$ff.1-2; done
for ff in $(ls -B); do for ii in {3..8}; do cut -f$ii $ff > ../etalon-prac/$ff.$ii; done; done
cd ../rules
for ff in $(ls -B); do for ii in {3..8}; do cut -f$ii $ff > ../rules-prac/$ff.$ii; done; done
cd ../frazrl
for ff in $(ls -B); do for ii in {3..8}; do cut -f$ii $ff > ../frazrl-prac/$ff.$ii; done; done
cd ../mdita
for ff in $(ls -B); do for ii in {3..8}; do cut -f$ii $ff > ../mdita-prac/$ff.$ii; done; done</code>
  * Vyrobíme další sloupce s porovnáním atributů:<code>cd ../etalon-prac
for ff in *.3; do paste $ff ../rules-prac/$ff ../frazrl-prac/$ff ../mdita-prac/$ff | add_collumn_to_corp.pl > $ff.9 2>$ff.log; done
for ff in *.4; do paste $ff ../rules-prac/$ff ../frazrl-prac/$ff ../mdita-prac/$ff | add_collumn_to_corp.pl > $ff.10 2>$ff.log; done
for ff in *.5; do paste $ff ../rules-prac/$ff ../frazrl-prac/$ff ../mdita-prac/$ff | add_collumn_to_corp.pl > $ff.11 2>$ff.log; done
for ff in *.6; do paste $ff ../rules-prac/$ff ../frazrl-prac/$ff ../mdita-prac/$ff | add_collumn_to_corp.pl > $ff.12 2>$ff.log; done
for ff in *.7; do paste $ff ../rules-prac/$ff ../frazrl-prac/$ff ../mdita-prac/$ff | add_collumn_to_corp.pl > $ff.13 2>$ff.log; done
for ff in *.8; do paste $ff ../rules-prac/$ff ../frazrl-prac/$ff ../mdita-prac/$ff | add_collumn_to_corp.pl > $ff.14 2>$ff.log; done
</code>
  * Nakonec vytvoříme korpus:<code>cd ../etalon-prac
for ff in $(cat ../list.txt); do echo $ff; paste $ff.1-2 $ff.3 $ff.4 $ff.5 $ff.6 $ff.7 $ff.8 ../rules-prac/$ff.3 ../rules-prac/$ff.4 ../rules-prac/$ff.5 ../rules-prac/$ff.6 ../rules-prac/$ff.7 ../rules-prac/$ff.8 ../frazrl-prac/$ff.3 ../frazrl-prac/$ff.4 ../frazrl-prac/$ff.5 ../frazrl-prac/$ff.6 ../frazrl-prac/$ff.7 ../frazrl-prac/$ff.8  ../mdita-prac/$ff.3 ../mdita-prac/$ff.4 ../mdita-prac/$ff.5 ../mdita-prac/$ff.6 ../mdita-prac/$ff.7 ../mdita-prac/$ff.8 $ff.3.9 $ff.4.10 $ff.5.11 $ff.6.12 $ff.7.13 $ff.8.14 | perl -pe 's/^[\t]+$//' | cat -s > ../korpus/$ff; done
</code>
  * Ke korpusu vede link z adresáře ''/store/corp/Etalon.2020'': ''vert-compare -> compare/korpus''
  * Korpus má tento definiční soubor:
<hidden>
<file Etalon.2020-compare>
PATH  /net/chomsky/store/manatee-registry/Etalon.2020-compare-data
ENCODING utf-8
INFO "Etalon.v2020 ve formátu SYN2020 včetně kolokací s porovnáním k 'rules', 'frazrl' a 'mdita', 29.5.2021"
INFOHREF "http://utkl.ff.cuni.cz/corpinfo/Etalon.2020-compare.html"

ATTRIBUTE word {
  TYPE "FD_FGD"
}
ATTRIBUTE sword {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE lemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE sublemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE tag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE verbtag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE col_lemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE col_type {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE rlemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE rsublemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE rtag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE rverbtag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE rcol_lemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE rcol_type {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE flemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE fsublemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE ftag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE fverbtag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE fcol_lemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE fcol_type {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE mlemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE msublemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE mtag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE mverbtag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE mcol_lemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE mcol_type {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE comp_lemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE comp_sublemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE comp_tag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE comp_verbtag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE comp_col_lemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE comp_col_type {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}

STRUCTURE doc {
  ATTRIBUTE file
}

STRUCTURE s
</file>
</hidden>

=== Bez kolokací ===

  * Nejdříve nakopírujeme data do pracovních adresářů:<code>cd ../../start-vert/vert-mdita-sublm-agr
cp -p * ../../compare/mdita-prac
cd ../vert-rules-mdita-sublm-agr
cp -p * ../../compare/rules-prac
cd ../vert-rules0-frazrl-rules-mdita-sublm-agr
cp -p * ../../compare/frazrl-prac</code>a ještě ručně opravíme v adresáři ''compare/mdita-prac'' roztržené //Cos// v souboru ''zassrdvf01'' okolo řádky 31778, //nemohls// v souboru ''o_lasceXX''okolo řádky 34873 a //Neměls// v souboru samanebX01 okolo řádky 48870.
  * Spravíme segmentaci a při tom vytvoříme soubory v základních adresářích:<code>cd ../../compare/etalon
for ff in $(ls -B); do echo $ff; correct_segm.pl $ff ../mdita-prac/$ff > ../mdita/$ff; done
for ff in $(ls -B); do echo $ff; correct_segm.pl $ff ../rules-prac/$ff > ../rules/$ff; done
for ff in $(ls -B); do echo $ff; correct_segm.pl $ff ../frazrl-prac/$ff > ../frazrl/$ff; done
</code>
  * Korpusy rozházíme po sloupcích:<code>cd ../compare/etalon
for ff in $(ls -B); do cut -f1-2 $ff > ../etalon-prac/$ff.1-2; done
for ff in $(ls -B); do for ii in {3..6}; do cut -f$ii $ff > ../etalon-prac/$ff.$ii; done; done
cd ../rules
for ff in $(ls -B); do for ii in {3..6}; do cut -f$ii $ff > ../rules-prac/$ff.$ii; done; done
cd ../frazrl
for ff in $(ls -B); do for ii in {3..6}; do cut -f$ii $ff > ../frazrl-prac/$ff.$ii; done; done
cd ../mdita
for ff in $(ls -B); do for ii in {3..6}; do cut -f$ii $ff > ../mdita-prac/$ff.$ii; done; done</code>
  * Vyrobíme další sloupce s porovnáním atributů:<code>cd ../etalon-prac
for ff in *.3; do paste $ff ../rules-prac/$ff ../frazrl-prac/$ff ../mdita-prac/$ff | add_collumn_to_corp.pl > $ff.9 2>$ff.log; done
for ff in *.4; do paste $ff ../rules-prac/$ff ../frazrl-prac/$ff ../mdita-prac/$ff | add_collumn_to_corp.pl > $ff.10 2>$ff.log; done
for ff in *.5; do paste $ff ../rules-prac/$ff ../frazrl-prac/$ff ../mdita-prac/$ff | add_collumn_to_corp.pl > $ff.11 2>$ff.log; done
for ff in *.6; do paste $ff ../rules-prac/$ff ../frazrl-prac/$ff ../mdita-prac/$ff | add_collumn_to_corp.pl > $ff.12 2>$ff.log; done
</code>
  * Nakonec vytvoříme korpus:<code>cd ../etalon-prac
for ff in $(cat ../list.txt); do echo $ff; paste $ff.1-2 $ff.3 $ff.4 $ff.5 $ff.6 ../rules-prac/$ff.3 ../rules-prac/$ff.4 ../rules-prac/$ff.5 ../rules-prac/$ff.6 ../frazrl-prac/$ff.3 ../frazrl-prac/$ff.4 ../frazrl-prac/$ff.5 ../frazrl-prac/$ff.6  ../mdita-prac/$ff.3 ../mdita-prac/$ff.4 ../mdita-prac/$ff.5 ../mdita-prac/$ff.6 $ff.3.9 $ff.4.10 $ff.5.11 $ff.6.12 | perl -pe 's/^[\t]+$//' | cat -s > ../korpus/$ff; done
</code>
  * Ke korpusu vede link z adresáře ''/store/corp/Etalon.2020'': ''vert-compare -> compare/korpus''
  * Korpus vyrobíme takto:<code>manatee-registry.sh -c . -f vert-compare -p10 -t</code>
  * Korpus má tento definiční soubor:
<hidden>
<file Etalon.2020-compare>
PATH  /net/chomsky/store/manatee-registry/Etalon.2020-compare-data
ENCODING utf-8
INFO "Etalon.v2020 ve formátu SYN2020 včetně kolokací s porovnáním k 'rules', 'frazrl' a 'mdita', 29.5.2021"
INFOHREF "http://utkl.ff.cuni.cz/corpinfo/Etalon.2020-compare.html"

ATTRIBUTE word {
  TYPE "FD_FGD"
}
ATTRIBUTE sword {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE lemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE sublemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE tag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE verbtag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE rlemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE rsublemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE rtag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE rverbtag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE flemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE fsublemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE ftag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE fverbtag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE mlemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE msublemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE mtag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE mverbtag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE comp_lemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE comp_sublemma {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE comp_tag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}
ATTRIBUTE comp_verbtag {
  TYPE "FD_FGD"
  MULTIVALUE y
  MULTISEP "|"
}

STRUCTURE doc {
  ATTRIBUTE file
}

STRUCTURE s
</file>
</hidden>


  * Vyrobíme korpus, vyhledáme chyby a opravy provádíme rovnou v adresáři ''korpus''. Provedené opravy promítneme zpět do adresáře ''etalon''<code>
cd korpus
for ff in *; do echo $ff; cut -f1-8 $ff | perl -pe 's/[\t]+$//' | cat -s > ../etalon/$ff; done</code>a celý korpus vyrobíme znova
  * Nejlepší etalon: <WRAP important 90% round>
Aktuální nejlepší etalon je v adresáři ''compare/etalon''. Pro trénování a kolokace z něj vyrobíme vertikálu takto:<code>
cd compare/etalon
for ff in $(ls -B); do echo $ff; cut -f2-3,5-6 $ff | split-agreg.pl | perl -pe 's/\t([^\t]+)$/$1/' | cat -s > ../../etalon/vert-final/$ff; done</code>
</WRAP>

===== Udržované varianty =====

  - Konečný formát obsahující ''word'', ''synword'', ''lemma'', ''sublemma'', ''tag'' a ''verbtag''. Nachází se v adresáři ''compare/etalon''
  - Verze pro Korpus
  - Verze pro Lindat
  - Verze pro trénování MorphoDiTy a pravidel

==== Texty do Lindatu ====

  * Z hotového korpusu uloupneme prvních 6 sloupců.
  * Nasekáme po 100 slovech programem ''split-text.pl''.
    * Dlouhé soubory nasekáme (i v ''in-utf8'') a zkusíme znovu.
  * Zashufflujeme programem, který vznikne jako výstup z ''make-rename.pl'' a ''shuffle-files.pl'':<code>cd Lindat/Etalon
ls | shuffle-files.pl | make-rename.pl > ../skript.sh
chmod +x ../skript.sh
../skript.sh</code>

==== Texty pro výrobu porovnání a pro trénování MorphoDiTy ====

  * Z hotového korpusu vezmeme 2., 3., 5. a 6. sloupec, rozdělíme agregáty a slepíme tagy a verbtagy:<code>cd compare/etalon
for ff in $(ls -B); do echo $ff; cut -f2-3,5-6 $ff | split-agreg.pl | perl -pe 's/\t([^\t]+)$/$1/' | cat -s > ../../Training/etalon/$ff; done
for ff in $(ls -B); do echo $ff; cut -f2-3,5-6 $ff | split-agreg.pl | perl -pe 's/\t([^\t]+)$/$1/' | cat -s > ../../etalon/vert-final/$ff; done
</code>a vyrobíme novou vertikálu pro testování:<code>for ff in $(ls -B); do echo $ff; cut -f1 $ff > ../../start-vert/vert/$ff; done</code><WRAP important 90% round>
**Toto je třeba udělat po každé opravě Etalonu!**
</WRAP>

==== Kontroly prováděné po ručních opravách Etalonu ====

  * Validita tagů:<code>cd /store/corp/Etalon.2020/compare/etalon
for ff in $(ls -B); do echo $ff; check-vert-tag-v2020.pl -c5 -k -t -V < $ff > /dev/null; done</code>
  * Shoda textů s ''in-utf8'':<code>
for ff in $(ls -B); do echo $ff; no_space_after_token_morphanal.pl ../../start-vert/in-utf8/$ff /dev/null < $ff > /dev/null; done</code>

===== Postup při opravách v klikátku =====

==== Opravy verbtagů ====

  * V Bonitu najdeme problematické jevy v korpusu a vytvoříme seznam souborů ''aux.lst'' v adresáři ''/store/corp/Etalon.2020/compare''.
  * Příslušné soubory zkopírujeme do adresáře ''compare/klikatko/korpus'':<code>cd /store/corp/Etalon.2020/compare
for ff in $(cut -f1 aux.lst); do cp -p korpus/$ff klikatko/korpus/; done</code>
  * Vyrobíme alternativy:<code>cd klikatko/korpus
for ff in *; do echo $ff; cut -f2,3,5,6,10 $ff | perl -pe 's/^([^\t]+\t[^\t]+\t[^\t]+\tA-----)\t(V.....)$/\1 \2\t\2/' \
| cut -f1-4 | split-agreg.pl | glue-verbtag.pl > ../etalon/vert-import/$ff; done</code>
  * Pak postupujeme jako při ručním značkování.
  * V adresáři ''etalon'' máme podadresáře ''vert-import'', ''csts-import'', ''csts-export'' a nakonec vytvoříme ''vert-export''. V něm vyrobíme a zkontrolujeme soubory takto:<code>cd etalon/csts-export
for ff in *; do echo $ff; cat $ff | csts_vert_annot.pl | rem-ent.pl | perl -pe 's/(......)$/\t\1/' \
| restore-aggreg.pl ../korpus/$ff > ../vert-export/$ff; done
cd ../vert-export
for ff in *; do sdiff -s <(cut -f1 $ff) <(cut -f1 ../../../korpus/$ff); done
</code>
  * Vyrobíme opravené soubory v adresáři ''klikatko/corr'':<code>
for ff in *; do echo $ff; paste <(cut -f1-5 ../../korpus/$ff) <(cut -f4 $ff) | perl -pe 's/^\s+$/\n/' > ../corr/$ff; done</code>
  * Můžeme zkontrolovat rozdíly:<code>cd ../corr
for ff in *; do echo $ff; sdiff -s -w200 $ff <(cut -f1-6 ../../../etalon/$ff); done | l</code>
  * Opravené soubory zkopírujeme do ''.../compare/etalon'':<code>cd ../corr
rsync -avz * ../../../etalon/</code>