Wiki spuštěna 24. 7. 2025

Table of Contents

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:
    cd /home/skoumal/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/bin
./01_make-vert-Et.sh
  • Nová …/Etalon.v2020/corr-Etalon/MDita a …/Etalon.v2020/corr-Etalon/MDita-plain:
    cd /home/skoumal/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/bin
./02_make-MDita.sh
  • 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:
    cd .../corr-Etalon
ll -rt vert | tail
ll -rtL vert-Et | tail
cmp-lines.sh vert-Et vert
  • MDita — pokud se změní tokenizace a tím pádem i vert:
    cd .../corr-Etalon
ll -rt MDita/vert-morf | tail
ll -rtL vert | tail

    (MDita/vert jsou linky do vert)

  • vert-Et-MDita — pokud se změní vert-Et nebo MDita/vert-morf-simp:
    cd .../corr-Etalon
ll -rtL vert-Et-MDita | tail
ll -rtL vert-Et | tail
ll -rtL MDita/vert-morf-simp | tail
  • Etalon.v2020 — pokud se změní vert-Et-MDita:
    cd .../corr-Etalon
ll -rtL Etalon.v2020/vert-morf-simp | tail
ll -rtL vert-Et-MDita | tail

Automatický převod z Etalonu

Popis na fóru

  • Tabulka je na fóru: 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:
    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

    Podle toho, jaké máme POS, upravíme buď …-Etalon.txt nebo …-NUM.txt: 

    cd ..
perl -i -pe 's/$/-/' Num-NUM.txt

    nebo 

    perl -pe 's/.(..)(.)$/$2$1/' Verb-Etalon.txt | sort -u > qqq.txt
mv qqq.txt Verb-Etalon.txt
  • Potom porovnáváme rozdíly:
    comm ../Verb-Etalon.txt ../Verb-NUM.txt | l
  • 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):
    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

Výroba finálního korpusu

  • Převedeme kompletně opravený Etalon do formátu SYN2020:
    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
  • Vyrobíme korpus:
    cd .../Etalon.v2020
ln -s corr-Etalon/vert-syn2020
manatee-registry.sh -c. -f vert-syn2020 -t

Kontrola

  • Zkontrolujeme i tagy programem check-vert-tag.pl:
    cd .../Etalon.v2020/corr-Etalon/vert-syn2020
cat * | /net/grimm/usr/local/corp/bin/check-vert-tag.pl -t > /dev/null
  • Vyrobíme korpus z převedeného Etalonu a MorphoDity:
    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
  • Zkontrolujeme programem Etalon-cmp-v2020.pl a vyrobíme korpus:
    cd ../vert-syn2020-MDita
for ff in *; do echo $ff; ../../bin/Etalon-cmp-v2020.pl < $ff > ../vert-cmp-MDita/$ff; done
    cd ../..
ln -s corr-Etalon/vert-cmp-MDita
manatee-registry.sh -c. -f vert-cmp-MDita

    config: 

    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

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:
    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

    a výsledek zkontrolujeme: 

    cd .../corr-Etalon
parallel-filter.sh -C "check-vert-tag.pl -t -l16" -s vert-Et -n -p10
  • Do vert z něj uřízneme vertikálu:
    cd vert-Et
for ff in *; do cut -f1 $ff > ../vert/$ff; done

    nebo paralelně: 

    parallel-filter.sh -C "cut -f1" -e -p10 -s vert-Et -t vert -v
  • Provedeme analýzu MDitou:
    cd ../MDita
mkdir vert
cd vert
for ff in ../../vert/*; do ln -s $ff; done
cd ..
process_vert.sh -v -p10 -s vert

    a omrkneme tokenizaci: 

     cd ..
cmp-lines.sh vert-Et MDita-plain/vert-morf-simp-nosp-sgcr-con-sublm/ | l
  • Sloučíme Etalon s takto vyrobeným korpusem:
    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
  • Zkontrolujeme, zda nedošlo k posunu:
    cd ../vert-Et-MDita
tail * | l -S

    nebo 

    grep -P "^[\t\ ]" *
grep -P "[\t\ ]$" *
  • Můžeme vyrobit korpus Etalon.v2020-Et-MDita:
    cd .../Etalon.v2020
ln -s corr-Etalon/vert-Et-MDita
manatee-registry.sh -c. -f vert-Et-MDita

    config: 

    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

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:
    cd .../Etalon.v2020/corr-Etalon/vert-Et-MDita
(cat * | ../../bin/Etalon2v2020.pl -f4 > /dev/null) 2> ../errors.txt

    Chceme-li dostat i převedený Etalon, spustíme program takto: 

    (for ff in *; do echo $ff; ../../bin/Etalon2v2020.pl -f4 < $ff > ../Etalon.v2020/vert-morf-simp/$ff; done) 2> ../errors-200611.txt
  • Dorazíme Etalon.v2020 do konce:
    cd ../Etalon.v2020
/usr/local/syn2020/bin/process_vert.sh -v -p10 -s vert-morf-simp
  • Sloučíme s MDitou a přitom provedeme porovnání:
    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
  • Vyrobíme si korpus:
    cd .../Etalon.v2020
ln -s corr-Etalon/vert-cmp-v2020-MDita
manatee-registry.sh -c. -f vert-cmp-v2020-MDita

    config: 

    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

Dodatečné opravy

  • V Etalonu:
    • Entity &url; a &email; mají tag <html>NN————8-</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>AAXXX—-1A—-</html>)
      • džiu-džitsu, tai-či, Sado-maso, go-go, sci-fi (<html>NNNXX—–A—-</html>)
      • pop-music (<html>NNFXX—–A—-</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ů:
    parallel-filter.sh -C "add_verbtag_and_clsep.pl -l | bin/remove-person.pl" -s final -t vrbtg8 -v -p10
  • Přidání verbtagů a odstranění nesprávných osob u participií:
    parallel-filter.sh -C "add_verbtag_and_clsep.pl -l | bin/prune-vrbtg.pl" -s final -t vrbtg8-prune -v -p10

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
    <p>
forma<TAB>space<TAB>lemma<SPACE>tag
  • Vyrobí se vrbtg8, ale jenom u sloves:
    parallel-filter.sh -C "add_verbtag_and_clsep.pl -l | ../../bin/remove-person.pl" -s final -t vrbtg8 -v -p45
  • Spustí se pravidla (celý root): 
    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
  • Vyrobí se korpus tímto příkazem:
    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

Porovnání s všemi pravidly

Click to display ⇲

Click to hide ⇱

  • 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
    forma<TAB>lemma<SPACE>tag

    tímto příkazem: 

    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
  • Vyrobíme i vertikálu, ve které slepíme zpátky agregáty:
    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
  • Spustíme process_text.sh od vert:
    cd .../Rules
process_text.sh -l -p45 -s vert -v

    a zkontrolujeme zarovnání: 

    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

    Pokud vlevo nebo vpravo přebývají volné řádky, spustíme opravu: 

    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

    A můžeme znovu zkontrolovat: 

    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
  • Pracujeme v adresáři ~/PROJEKTY/INFRASTRUKTURA/Etalon.v2020/MorphoDiTa-training.

Click to display ⇲

Click to hide ⇱

  • Vytvoříme adresář Etalon-final, ve kterém vyrobíme Etalon ve tvaru
    forma<TAB>lemma<SPACE>tag

    tímto příkazem: 

    cd vert-korpus
for ff in $(ls -B); do echo $ff; cut -f1,3- $ff > ../Rules/Etalon-final/$ff; done
  • Spustíme process_text.sh na plain text:
    process_text.sh -l -v -p45

    a spravíme segmentaci: 

    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

    a zkontrolujeme zarovnání: 

    cd ../vert-segcor-vrbtg8
for ff in *; do echo $ff; sdiff -s <(cut -f1 $ff) <(cut -f1 ../vert-korpus/$ff); done
  • Spustíme pravidla:
    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
  • Nakonec vyrobíme korpus:
    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
  • Program manatee-registry.sh spouštíme s přepínačem -t:
    manatee-registry.sh -c. -f vert-cmp-rules -t

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:
    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
  • Opravíme osoby podle Etalonu:
    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
  • Připravíme data pro ruční opravy:
    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
  • Po ruční opravě připravíme vertikálu pro dokončení oprav:
    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

    a připravíme finální vertikálu, kterou budeme ručně opravovat: 

    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
  • Pro Bonito vyrobíme vertikálu, ve které budou oddělené verbtagy:
    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
  • Korpus pro Bonito bude mít název Etalon.v2020-verbtags a vyrobí se v adresáři Etalon.v2020 příkazem
    manatee-registry.sh -c. -f vert-verbtags -t

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:
    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
  • 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:
    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
  • Podobně zkontrolujeme in-utf8 a final:
    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

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:
    cd /data/syn2020/Etalon
process_text.sh -l -v -p45
  • Oprava segmentace:
    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
  • Trénovací data:
    cd ../Tools
./train_data_for_MDita.sh
  • 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í:
    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

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:
    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
  • Vytvoříme adresář vert-cmp-MorphoDiTa a v něm vyrobíme texty pro korpus:
    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

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:
      cd start-vert
process_text.sh -s vert -m -v -p45
    • V adresáři etalon vyrobíme vert-mdita-sublm-agr (:!: pozor, ať nesmažeme soubory ve vert-final :!:):
      cd etalon
process_text.sh -s vert-mdita -v -p45
    • Porovnáme vyrobený etalon s vert:
      cd etalon/vert-mdita-sublm-agr
for ff in *; do echo "FILE: $ff"; sdiff -s <(cut -f1 $ff) ../vert/$ff; done | l

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:
    cd etalon
process_text.sh -s vert -t vrbtg8 -v -p45
  • Soubory ve vert-morf-simp-nosp-sgcr-con zarovnáme s těmi z vert-final pomocí correct_segm.pl:
    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

    cd vert-morf-simp-nosp-sgcr-con for ff in *; do split-sufixoid.pl < $ff > ../vert-morf-simp-nosp-sgcr-con.prac/$ff; done 

    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
  • Vyrobíme vert-mdita-correct:
    ln -s vert-final vert-mdita
process_text.sh -s vert-mdita -t in -v -p45
  • Vyrobíme kolokace:
    process_kolok.sh -s vert-mdita-correct -v -p45

    a zkontrolujeme: 

    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

Zpracování třemi metodami

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

S kolokacemi

  • Vyrobíme vertikály z vert:
    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
  • Opravíme slepená adjektiva s kolokacemi ve vert-mdita-correct:
    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

    a přesuneme opravené soubory zpět do -correct: 

    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/
  • Vyrobíme kolokace:
    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

Bez kolokací

  • Vyrobíme vertikály z vert:
    process_text.sh -s vert -m -v -p45
process_text.sh -s vert -v -p45
process_text.sh -s vrbtg8 -f -v -p45
  • Opravíme slepená adjektiva ve vert-mdita-sublm-agr:
    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
  • Přesuneme opravené soubory zpět do -sublm-agr:
    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/
  • Zkontrolujeme vůči in-utf8 ve všech adresářích:
    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

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ářů: cd ../etalon/vert-mdita-kolok-sublm-agr cp -p * ../../compare/etalon
    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

    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_lasceXXokolo řá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:
    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
  • Korpusy rozházíme po sloupcích:
    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
  • Vyrobíme další sloupce s porovnáním atributů:
    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
  • Nakonec vytvoříme korpus:
    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
  • Ke korpusu vede link z adresáře /store/corp/Etalon.2020: vert-compare → compare/korpus
  • Korpus má tento definiční soubor:

Click to display ⇲

Click to hide ⇱ 

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

Bez kolokací

  • Nejdříve nakopírujeme data do pracovních adresářů:
    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

    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_lasceXXokolo řá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:
    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
  • Korpusy rozházíme po sloupcích:
    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
  • Vyrobíme další sloupce s porovnáním atributů:
    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
  • Nakonec vytvoříme korpus:
    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
  • Ke korpusu vede link z adresáře /store/corp/Etalon.2020: vert-compare → compare/korpus
  • Korpus vyrobíme takto:
    manatee-registry.sh -c . -f vert-compare -p10 -t
  • Korpus má tento definiční soubor:

Click to display ⇲

Click to hide ⇱ 

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
  • 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
    cd korpus
for ff in *; do echo $ff; cut -f1-8 $ff | perl -pe 's/[\t]+$//' | cat -s > ../etalon/$ff; done

    a celý korpus vyrobíme znova

  • Nejlepší etalon:

    Aktuální nejlepší etalon je v adresáři compare/etalon. Pro trénování a kolokace z něj vyrobíme vertikálu takto: 

    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

Udržované varianty

  1. Konečný formát obsahující word, synword, lemma, sublemma, tag a verbtag. Nachází se v adresáři compare/etalon
  2. Verze pro Korpus
  3. Verze pro Lindat
  4. 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:
    cd Lindat/Etalon
ls | shuffle-files.pl | make-rename.pl > ../skript.sh
chmod +x ../skript.sh
../skript.sh

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:
    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

    a vyrobíme novou vertikálu pro testování: 

    for ff in $(ls -B); do echo $ff; cut -f1 $ff > ../../start-vert/vert/$ff; done

    Toto je třeba udělat po každé opravě Etalonu!

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

  • Validita tagů:
    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
  • Shoda textů s in-utf8:
    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

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:
    cd /store/corp/Etalon.2020/compare
for ff in $(cut -f1 aux.lst); do cp -p korpus/$ff klikatko/korpus/; done
  • Vyrobíme alternativy:
    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
  • 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:
    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
  • Vyrobíme opravené soubory v adresáři klikatko/corr:
    for ff in *; do echo $ff; paste <(cut -f1-5 ../../korpus/$ff) <(cut -f4 $ff) | perl -pe 's/^\s+$/\n/' > ../corr/$ff; done
  • Můžeme zkontrolovat rozdíly:
    cd ../corr
for ff in *; do echo $ff; sdiff -s -w200 $ff <(cut -f1-6 ../../../etalon/$ff); done | l
  • Opravené soubory zkopírujeme do …/compare/etalon:
    cd ../corr
rsync -avz * ../../../etalon/

Trace: • navod_k_anotaci • rychlost • korpusy • taggers • syn • etalon.v2020

QR Code
QR Code wiki:user:skoumal:infra:etalon.v2020 (generated for current page)