2018-02-08 01:47:46 +01:00
\chapter { Metody ekstrakcji informacji}
% w kontekście mojego projektu
2018-02-11 22:34:54 +01:00
W tym rozdziale zaprezentowane są wybrane metody,
które brane były pod uwagę lub zostały zastosowane
2018-02-08 01:47:46 +01:00
w końcowym systemie ekstrakcji informacji o godzinach rozpoczęcia mszy świętych.
2018-02-11 22:34:54 +01:00
\section { Algorytmy \textit { bootstraping} }
Niech $ J $ to będzie dowolna reprezentacja języka (wyraz, fraza, wyrażenie
regularne itp.)
W dziedzinie przetwarzania języka naturalnego \textit { bootstraping} to technika
wyszukiwania niezanotowanych $ J $ przy użyciu małego zbioru specjalnie
wyselekcjonowanych $ J $ .
Implementacji algorytmu \textit { bootstraping} jest wiele; wszystkie jednak
oparte są na następującym schemacie \cite { Bootstrap} :
\begin { enumerate}
\item Stwórz pustą listę $ J $ . % pusta lista $J$, pusta lista wyrazów, pusta
% lista fraz
\item Zainicjalizuj listę starannie dobranymi $ J $ .
\item Wykorzystaj elementy listy do znalezienia nowych $ J $ z korpusu treningowego.
\item Oceń nowe $ J $ ; najlepsze $ J $ dodaj do listy.
\item Wróć do 3. i powtarzaj aż do osiągnięcia z góry określonej liczby iteracji lub
spełnienia innego warunku stopu.
\end { enumerate}
\textit { Bootstraping} jest szczególnie przydatny w przypadku, gdy mamy mały
zbiór treningowy, ponieważ z jego pomocą jesteśmy w stanie powiększyć zbiór
treningowy. %todo poprawić
\subsection { Wzorce Hearst}
Jedną z pierwszych implementacji algorytmu \textit { bootstraping} w dziedzinie
ekstrakcji informacji
są wzorce Hearst \textit { (ang. Hearst patterns)} \cite { Hearst} .
2018-02-08 01:47:46 +01:00
\smallskip
2018-02-11 22:34:54 +01:00
\noindent Znajdowanie nowych wzorców za pomocą
następująco:
2018-02-08 01:47:46 +01:00
\begin { enumerate}
2018-02-11 22:34:54 +01:00
\item Wybierz relację leksykalną $ R $ .
\item Zbierz zbiór $ S $ par $ ( x, y ) \in R $ , gdzie $ x $ i $ y $ to słowa lub frazy.
\item Znajdź zdania, które zawierają pary ze zbioru $ S $ .
\item Przyjrzyj się kontekstowi w jakim występują te pary. Załóż, że często powtarzające się wzorce reprezentują relację R.
\item Wykorzystaj nowo odkryte wzorce do znalezienia nowych par słów lub fraz będących w relacji $ R $ .
\item Dodaj nowo znalezione pary słów lub fraz do zbioru $ S $ , wróć do 3. i powtarzaj aż do osiągnięcia z góry określonej liczby iteracji.
2018-02-08 01:47:46 +01:00
\end { enumerate}
2018-02-11 22:34:54 +01:00
\enlargethispage { 6\baselineskip }
\subsubsection { Przykład}
Rozważmy relację R taką, że $ ( x, y ) \in R $ wtedy, gdy $ x $ został pochowany w
$ y $ .
Załóżmy, że zaczynamy z parą \texttt { ('Józef Piłsudski', 'Kraków')} $ \in R $ .
W korpusie treningowym szukamy zdań zawierających w sobie parę \texttt { ('Józef Piłsudski', 'Kraków')} i otrzymujemy:
\centerline { „Józef Piłsudski został pochowany w Krakowie.”}
\centerline { „Miejsce pochówku Józefa Piłsudskiego to Kraków.”}
\centerline { „Grób Józefa Piłsudskiego znajduje się w Krakowie.”}
Ze znalezionych zdań tworzymy następujące wzorce:
\centerline { $ x $ został pochowany w $ y $ .}
\centerline { Miejsce pochówku $ x $ to $ y $ .}
\centerline { Grób $ x $ znajduje się w $ y $ .}
Wykorzystujemy powyższe wzorce do znalezienia nowych par będących w relacji $ R $
i otrzymujemy:
\centerline { \texttt { ('Władysław Araszkiewicz', 'Warszawa')} }
\centerline { \texttt { ('Władysław Kuczewski', 'Częstochowa')} }
Następnie nowe pary używamy do znalezienia nowych wzorców, a potem nowe
wzorce do wyszukania kolejnych par i powtarzamy powyższy
algorytm aż do osiągnięcia określonej liczby iteracji.
\subsection { Miejsce na opis bardziej skomplikowanej metoda implementującej
algorytm \textit { bootstraping} }
2018-02-08 01:47:46 +01:00
\section { Dziel i zwyciężaj algorytmami genetycznymi}
W 2015 Bartoli i in. zaprezentowali efektywny algorytm genetyczny do generowania wzorców w
postaci wyrażeń regularnych przy użyciu niewielkiego zbioru zanotowanych przykładów.
Problem generowania automatycznych wyrażeń regularnych jest ciężki. Warto zauważyć, że
bardzo
czułości (np. wystarczy alternatywa po wszystkich zanotowanych przykładach), ale szczególnie trudno wytrenować system tak, aby generalizował się na przypadki poza
zbiorem treningowym (innymi słowy taki system łatwo przetrenować).
%Bartoli i in. na następujących przykładach
%tabela tekstu do wyekstrachowania
%(otrzymali wyniki bardzo zadowalające wyniki ) tabela wyników
\subsection { Opis problemu}
Niech $ x _ s $ będzie spójnym podciągiem ciągu znaków $ s $ reprezentowanym przez
indeks początkowy i końcowy w $ s $ .
$ x _ s $ nazywa się nadłańcuchem $ x' _ s $ (a $ x' _ s $ jest podłańcuchem $ x _ s $ )
jeśli (i) $ x' _ s $ jest krótszy niż $ x _ s $ , (ii) indeks początkowy $ x' _ s $ jest
większy lub równy niż indeks początkowy $ x _ s $ oraz (iii) indeks końcowy $ x' _ s $
jest mniejszy lub równy niż indeks końcowy $ x _ s $ .
Niech $ ( s,X ) $ to przykład uczący, w którym $ X $ to zbiór
nienachodzących na siebie $ x _ s $ .
Niech $ e ( s,P ) $ to zbiór wszystkich ciągów $ x _ s $
wyekstrahowanych poprzez zbiór wyrażeń regularnych $ P $ , taki że (i)
$ x _ s $
pasuje do jakiegokolwiek wyrażenia regularnego $ p \in P $ , (ii) każdy nadłańcuch
$ x' _ s $ ciągu $ x _ s $ nie pasuje do żadnego wyrażenia regularnego $ p \in P $
oraz (iii) dla każdego innego ciągu $ x'' _ s $ , który nachodzi na
$ x _ s $ , indeks początkowy $ x'' _ s $ albo jest większy od indeksu początkowego $ x _ s $
albo $ x'' _ s $ nie pasuje do żadnego $ p \in P $ .
Mając dwa zbiory zanotowanych przykładów $ ( E, E' ) $ zbiór wyrażeń
regularnych $ P $ generowany jest używając
tylko i wyłącznie $ E $ w taki sposób, że (i) maksymalizowana jest średnia harmoniczna z precyzji i
czułości na $ E' $ oraz (ii) minimalizowana jest $ \sum _ { p \in
P} { l(p)} $ , gdzie $ l(p)$ to długość wyrażenie regularnego $ p$ .
Wtedy precyzja i czułość definiowane są w następujący sposób:
$$ Prec ( P, E' ) : = \frac { \sum _ { ( s,X ) \in E' } { |e ( s,P ) \cup X| } } { \sum _ { ( s,X ) \in E' } { |e ( s,P ) | } } $$
$$ Rec ( P, E' ) : = \frac { \sum _ { ( s,X ) \in E' } { |e ( s,P ) \cup X| } } { \sum _ { ( s,X ) \in E' } { |X| } } $$
\subsection { Algorytm}
\subsubsection { Algorytm genetyczny}
Na wejściu podawany jest zbiór treningowy $ T $ , a na wyjściu pojedyńcze wyrażenie regularne $ p $ .
Zbiór treningowy $ E $ składa się z trójki uporządkowanej $ ( s,X ) = ( s,X _ d,X _ u ) $ ,
gdzie $ X _ d $ to zbiór ciągów $ x _ s $ ekstrahowanych przez $ p $ , a
$ X _ u $ to zbiór niepożądanych ciągów $ x _ s $ ekstrahowanych przez $ p $ . Dodatkowo
żaden podłańcuch $ x' _ s $ ciągu $ x _ s \in X _ d $ nie nachodzi na żaden podłańcuch $ x' _ s $ ciągu $ x _ s \in X _ u $ .
Wyrażenie regularne reprezentowane jest za pomocą drzewa. Liście składają
się
\begin { enumerate}
\item zakresów znaków np. \texttt { a-ż} , \texttt { A-Ż} i \texttt { 0-9} ,
\item klas znaków \texttt { \textbackslash w} i \texttt { \textbackslash d} ,
\item cyfr od 0 do 9,
\item częściowych zakresów, czyli największego zakresu znaków występującego
w $ \bigcup _ { ( s,X _ d,X _ u ) \in T } X _ d $ , np. dla \texttt { \{ pokój, ubierać\} }
otrzymuje się
zakresy \texttt { a-b} , \texttt { j-k} i \texttt { o-r} (przy założeniu, że
korzysta się z polskiego alfabetu),
\item znaków specjalnych takich jak np. \texttt { \textbackslash ., :, @} .
\end { enumerate}
Wierzchołki nie będące liściami składają się z:
\begin { enumerate}
\item konkatenacji $ \bullet \bullet $ ,
\item klasy znaków $ [ \bullet ] $ i jej negacji $ [ \hat { \ } \bullet ] $ ,
\item kwantyfikatorów bez nawrotów (ang. possessive quantifiers) $ \bullet
\ast $ \texttt { + } , $ \bullet $ \texttt { + + } , $ \bullet $ \texttt { ? + } oraz $ \bullet
\{ \bullet , \bullet \} $ \texttt { + } ,
\item nie łapiących grup \texttt { (?:$ \bullet $ )} .
\end { enumerate}
Wyrażenie regularne $ p $ otrzymuje się \newline w którym pod $ \bullet $ w wierzchołkach
niebędących
liściami podstawia się łańcuchy znaków zawarte w dzieciach tego wierzchołka.
\subsubsection { Inicjalizacja populacji}
Dla każdego $ x _ s \in \bigcup _ { ( s,X _ d,X _ u ) \in T } X _ d $ budowane są dwa osobniki
(osobnik to wyrażenie regularne). Pierwszy osobnik tworzony jest z $ x _ s $ , w którym każda cyfra zamieniana
jest na \texttt { \textbackslash d} oraz każda litera zamienia jest na
\texttt { \textbackslash w} . Drugi osobnik tworzony jest identycznie jak pierwszy
z tą różnicą, że wielkrotne wystąpienia \texttt { \textbackslash d} (lub
\texttt { \textbackslash w} ) zastępuje się \texttt { \textbackslash d++} (lub
\texttt { \textbackslash w++} ). %\marginpar{przykład}
\subsubsection { Funkcja przystosowania}
Dla każdego osobnika funkcję przystosowania zdefiniowano jako
$$ f ( p ) : = ( Prec ( p,T ) , Acc ( p,T ) , l ( p ) ) $$
Wprowadzono również dwie nowe operacje $ \sqcap $ i $ \ominus $ , na których oparte są
funkcje $ Prec $ i $ Acc $ .
Załóżono, że $ X _ 1 $ i $ X _ 2 $ to zbiory spójnych podciągów tego samego łańcucha znaków $ s $ .
Wtedy:
\begin { itemize}
\item $ X _ 1 \ominus X _ 2 $ jest zbiorem takich $ x _ s $ , że
(i) są one spójnym podciągiem jakiegoś elementu $ X _ 1 $ , (ii) nie
nachodzą na żaden z elementów $ X _ 2 $ oraz (iii) nie mają nadłańcucha, który spełnia
(i), (ii);
\item $ X _ 1 \sqcap X _ 2 $ jest zbiorem takich $ x _ s $ , że (i) są one
spójnym podciągiem jakiekolwiek elementu $ X _ 1 $ i
jakiekolwiek elementu $ X _ 2 $ oraz (ii) nie mają nadłańcucha, który spełnia (i).
\end { itemize}
W końcu $$ Prec ( p,T ) : = \frac { \sum _ { ( s,X _ d,X _ u ) \in T } |e ( s, \{ p \} ) \cap
X_ d|} { \sum _ { (s,X_ d,X_ u)\in T} |e(s,\{ p\} )\sqcap (X_ d \cup X_ u)|} $$
Drugi element trójki uporządkowanej, czyli $ Acc ( p,T ) $ jest średnią arytmetyczną
czułości na znakach (ang. True Positive Character Rate skr. TPCR) i
specyficzności na znakach (ang. True Negative Character Rate skr. TNCR):
$$ TPCR ( p,T ) : = \frac { \sum _ { ( s,X _ d,X _ u ) \in T } ||e ( s, \{ p \} ) \sqcap X _ d|| } { \sum _ { ( s,X _ d,X _ u ) \in T } ||X _ d|| } $$
$$ TNCR ( p,T ) : = \frac { \sum _ { ( s,X _ d,X _ u ) \in T } ||s \ominus e ( s, \{ p \} ) \sqcap X _ u|| } { \sum _ { ( s,X _ d,X _ u ) \in T } ||X _ u|| } $$
$$ Acc ( p,T ) = \frac { TPCR ( p,T ) + TNCR ( p,T ) } { 2 } , $$
gdzie $ ||X|| = \sum _ { x _ s \in X } l ( x _ s ) $ , a $ l ( x _ s ) $ oznacza długość ciągu $ x _ s $ .
Osobniki porównywane są w pierwszej kolejności na podstawie $ Prec $ , potem
\newline w
przypadku remisu za pomocą $ Acc $ , a w przypadku identycznych
$ Prec $ i $ Acc $ brane jest pod uwagę $ l ( p ) $ .
Populacja $ P $ o liczności $ n $ ewoluuje następująco. W każdej iteracji $ 0 . 1 n $ osobników
generowanych jest losowo za pomocą metody
Ramped half-and-half, kolejne $ 0 . 1 n $ osobników powstaje za pomocą mutacji, a
pozostałe $ 0 . 8 n $ otrzymano z
populacji i zbioru nowo
wygenerowanych osobników wybierane jest $ n $ najlepiej przystosowanych osobników,
które tworzą nową populację. Osobniki wybierane \newline są do mutacji i krzyżowania za
pomocą turnieju (losowanie z $ P $ siedmiu osobników i zostawienie najlepszego).
Wymuszono również różnorodność między fenotypami osobników tzn. jeśli oba
osobniki mają identyczny łańcuch znaków to w populacji zostawiono tylko jednego
z nich. Koniec iteracji następuje, gdy zostanie osiągnięty \newline z góry ustalony limit generacji lub
najlepiej przystosowany osobnik nie zmieni się
Finalne wyrażenie regularne $ p $ to najlepiej przystosowany osobnik po
zakończeniu wszystkich iteracji.
\subsubsection { Dziel i zwyciężaj}
Zbiór wyrażeń regularnych $ P $ generowany jest za pomocą strategii dziel i
zwyciężaj. W każdej iteracji spójne podciągi ciągu znaków $ s $ , które zostały poprawnie
wykryte przez $ P $ są usuwane ze zbioru treningowego.
Oby uniknąć przetrenowania, czyli bardzo wysokiego F-measure na $ E $ , a niskiego na $ E' $
zbiór treningowy $ E $ dzielony jest losowo na dwa zbiory $ E _ { train } $ i $ E _ { validation } $
takie, że $ E = E _ { train } \cup E _ { validation } $ , $ E _ { train } \cap E _ { validation } =
\emptyset $ \newline i
$ \sum _ { ( s,X ) \in E _ { train } } |X| \approx \sum _ { ( s,X ) \in E _ { validation } } |X| $ .
\enlargethispage { 7\baselineskip }
\newpage
Zacznij z $ P = \emptyset $ i z $ T $ utworzonym w taki sposób, że dla
każdego $ ( s,X ) \in E _ t $ , trójka uporządkowana $ ( s, X, \{ s \} \ominus X ) $ jest
dodawana do $ T $ , \newline gdzie $ X _ d: = X $ i $ X _ u: = \{ s \} \ominus X $ .
\noindent Następnie dopóki $ \bigcup _ { ( x,X _ d,X _ u ) \in T } X _ d \ne \emptyset $ powtarzaj:
\begin { enumerate}
\item Wykonaj algorytm genetyczny na $ T $ i otrzymaj finalne $ p $ .
\item Jeśli $ Prec ( p,T ) = 1 $ , to $ P: = P \cup \{ p \} $ , w przeciwnym wypadku przerwij pętlę.
\item Dla każdego $ ( s, X _ d, X _ u ) \in T $ , ustaw $ X _ d: = X _ d \setminus e ( s, \{ p \} ) $ .
\end { enumerate}
Powyższa procedura powtarzana jest wiele razy z różnym zarodkiem generatora
liczb losowych (startowy zbiór trenujący $ T $ pozostaje bez zmian), by otrzymać
wiele różnych zbiorów $ P $ , z których na końcu wybierany jest ten o najwyższej
$ E = E _ { train } \cup E _ { validation } $ .
%\section{Sieci neuronowe}
