Etalon.v2020

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

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:

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/
```

Table of Contents

Etalon.v2020

Postup práce

Rychlý návod

Adresáře

Závislosti na verzi

Automatický převod z Etalonu

Popis na fóru

Program pro převod

Výroba finálního korpusu

Kontrola

Vývoj převodního programu

Morfologická analýza Etalonu MDitou

Převod Etalonu do formátu SYN2020 a porovnání s MDitou

Dodatečné opravy

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

Přidání verbtagů

Porovnání osob s Etalonem

Porovnání s všemi pravidly

Definitivní Etalon s dlouhými tagy

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

Data pro Tomáše

Porovnávání s výsledky z natrénované MorphoDiTy

Zarovnání obou korpusů

Výroba korpusu pro porovnání

Výroba korpusu pro porovnání s vert

Porovnání Etalonu s rules, frazrl a mditou

Kolokace z Etalonu

Zpracování třemi metodami

S kolokacemi

Bez kolokací

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

S kolokacemi

Bez kolokací

Udržované varianty

Texty do Lindatu

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

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

Postup při opravách v klikátku

Opravy verbtagů