Podręcznik
Strona: | SEZAM - System Edukacyjnych Zasobów Akademickich i Multimedialnych |
Kurs: | Minimalizacja funkcji boolowskich |
Książka: | Podręcznik |
Wydrukowane przez użytkownika: | Gość |
Data: | piątek, 4 kwietnia 2025, 20:14 |
Spis treści
- 1. Funkcje boolowskie
- 2. Formy kanoniczne funkcji boolowskich
- 3. Specyfikacje i realizacje funkcji boolowskich
- 4. Metody minimalizacji funkcji boolowskich
- 5. Uzupełnienie (Complement)
- 6. Redukcja argumentów
- 7. Analiza i eksploracja danych
- 8. Redukcja atrybutów
- 9. Indukcja reguł decyzyjnych
- 10. Zadania
- 11. Bibliografia
1. Funkcje boolowskie
Układ kombinacyjny jest podstawowym układem logicznym umożliwiającym realizację funkcji boolowskich. Układ kombinacyjny konstruujemy z elementów logicznych po to, aby realizować funkcje lub ich zespoły opisujące bardziej skomplikowane układy cyfrowe. Dlatego rozważania o układach kombinacyjnych rozpoczynamy od pojęcia funkcji boolowskiej.
Pojęcie funkcji boolowskiej jest pojęciem podstawowym umożliwiającym modelowanie zjawisk fizycznych reprezentowanych jako odwzorowanie ciągów (wektorów) binarnych należących do zbioru X w ciągi binarne (wektory) ze zbioru Y, gdzie zbiory X, (Y) są podzbiorami n-krotnego, (m-krotnego) iloczynu kartezjańskiego zbioru B = {0, 1}.
Formalnie funkcją boolowską zmiennych binarnych x1, …, xn nazywamy odwzorowanie:
f: X ® Y, gdzie X Í Bn, Y Í Bm.
Jeżeli X = Bn, to funkcję taką nazywamy zupełną; w przeciwnym przypadku jest to funkcja niezupełna, zwana również funkcją nie w pełni określoną.
Najczęściej stosowane reprezentacje funkcji boolowskich to tablica prawdy oraz formuła (wyrażenie) boolowskie.
Funkcja f może być przedstawiona w postaci tablicy prawdy. Jest to tablica o n+1 kolumnach i 2n wierszach. W kolejnych wierszach są zapisywane wszystkie wartości ciągu x1, …, xn, czyli wszystkie wektory x. W ostatniej kolumnie podana jest wartość y przyporządkowywana danemu wektorowi lub „–”, jeżeli funkcja dla tego wektora nie jest określona. Kolejne wektory są numerowane, przy czym wartość i podana z lewej strony w dodatkowej kolumnie jest dziesiętnym odpowiednikiem wektora x traktowanego jako liczba w zapisie dwójkowym:
Na przykład przeliczenia liczb binarnych (0101)B oraz (1010)B (podanych w NKB – naturalnym kodzie binarnym) na liczby dziesiętne 5D i 10D dokonujemy następująco:
(0101)B = 0 × 23 + 1 × 22 + 0 × 21 + 1 × 20 = 5D
(1010)B = 1 × 23 + 0 × 22 + 1 × 21 + 0 × 20 = 10D
Przykłady tablicowej reprezentacji funkcji boolowskiej podane są w tabl. 2.1a (funkcja zupełna) i tabl. 2.1b – funkcja niezupełna.
Tablica 2.1
a) |
|
|
|
|
|
|
b) |
|
|
|
|
|
|
|
x1 |
x2 |
x3 |
f |
|
|
|
x1 |
x2 |
x3 |
f |
|
0 |
0 |
0 |
0 |
0 |
|
|
0 |
0 |
0 |
0 |
0 |
|
1 |
0 |
0 |
1 |
1 |
|
|
1 |
0 |
0 |
1 |
1 |
|
2 |
0 |
1 |
0 |
0 |
|
|
2 |
0 |
1 |
0 |
– |
|
3 |
0 |
1 |
1 |
1 |
|
|
3 |
0 |
1 |
1 |
1 |
|
4 |
1 |
0 |
0 |
0 |
|
|
4 |
1 |
0 |
0 |
0 |
|
5 |
1 |
0 |
1 |
1 |
|
|
5 |
1 |
0 |
1 |
1 |
|
6 |
1 |
1 |
0 |
1 |
|
|
6 |
1 |
1 |
0 |
– |
|
7 |
1 |
1 |
1 |
1 |
|
|
7 |
1 |
1 |
1 |
1 |
Tablice te specyfikują funkcje boolowskie, których wektory wejściowe są dodatkowo określone liczbami dziesiętnymi. Stąd pomysł, aby specyfikacje funkcji boolowskich podawać w uproszczonej formie. Dla funkcji z tabl. 2.1a odpowiedni zapis powinien być:
f = S(1, 3, 5, 6, 7)
Natomiast funkcję z tabl. 2.1b zapisać należy z dodatkowym specyfikowaniem wektorów nieokreślonych:
f = S[1, 3, 5, 7, (2, 6)].
Rys. 2.1. Dekoder (a) wskaźnika siedmiosegmentowego (b)
Typowym zastosowaniem tablic prawdy do specyfikacji funkcji boolowskich może być opis dekodera wskaźnika siedmiosegmentowego powszechnie stosowanego do wyświetlania cyfr w urządzeniach pomiarowych i monitorujących. Dekoder taki to układ kombinacyjny o wejściach x3, x2, x1, x0 oraz wyjściach a, b, c, ..., g (rys. 2.1a), odpowiadających segmentom wskaźnika (rys. 2.1b). Na wejścia x podawane są liczby binarne 0000, 0001,...,1000,1001 (dziesiętnie: 0,1,...,8,9). Wyjścia a, b, c, ..., g sterują diodami świecącymi. Dioda zostaje podświetlona, gdy odpowiednie wyjście jest w stanie 1. W rezultacie działanie dekodera jest opisane tablicą prawdy, podaną w tablicy 2.2. W tym przypadku mamy do czynienia z funkcjami niezupełnymi. Jak się później przekonamy, omówiony dekoder nie nastręcza żadnych trudności w syntezie odpowiadającego im układu kombinacyjnego.
Tablica 2.2
|
x3 |
x2 |
x1 |
x0 |
a |
b |
c |
d |
e |
f |
g |
0 |
0 |
0 |
0 |
0 |
1 |
1 |
1 |
1 |
1 |
1 |
0 |
1 |
0 |
0 |
0 |
1 |
0 |
1 |
1 |
0 |
0 |
0 |
0 |
2 |
0 |
0 |
1 |
0 |
1 |
1 |
0 |
1 |
1 |
0 |
1 |
3 |
0 |
0 |
1 |
1 |
1 |
1 |
1 |
1 |
0 |
0 |
1 |
0 |
1 |
1 |
0 |
0 |
0 |
1 |
1 |
0 |
0 |
1 |
1 |
5 |
0 |
1 |
0 |
1 |
1 |
0 |
1 |
1 |
0 |
1 |
1 |
6 |
0 |
1 |
1 |
0 |
1 |
0 |
1 |
1 |
1 |
1 |
1 |
7 |
0 |
1 |
1 |
1 |
1 |
1 |
1 |
0 |
0 |
0 |
0 |
8 |
1 |
0 |
0 |
0 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
9 |
1 |
0 |
0 |
1 |
1 |
1 |
1 |
1 |
0 |
1 |
1 |
Można jednak podać zastosowania bardziej skomplikowane. Na przykład układ kryptograficzny realizujący tzw. algorytm DES (Data Encryption Standard), jest wyposażony w klucze S, których działanie specyfikuje się funkcjami boolowskimi o 6 wejściach i 4 wyjściach. Przykładowa specyfikacja dla klucza S1 jest podana w tablicy 2.3.
Tablica 2.3
14 |
4 |
13 |
1 |
2 |
15 |
11 |
8 |
3 |
10 |
6 |
12 |
5 |
9 |
0 |
7 |
0 |
15 |
7 |
4 |
14 |
2 |
13 |
1 |
10 |
6 |
12 |
11 |
9 |
5 |
3 |
8 |
4 |
1 |
14 |
8 |
13 |
6 |
2 |
11 |
15 |
12 |
9 |
7 |
3 |
10 |
5 |
0 |
15 |
12 |
8 |
2 |
4 |
9 |
1 |
7 |
5 |
11 |
3 |
14 |
10 |
0 |
6 |
13 |
Jeśli wejścia klucza S1 oznaczymy x1,...,x6, a wyjścia y1, y2, y3, y4, to zapis w tablicy 2.3 rozumiemy następująco: dla wektora x = (000000) wyjścia y są liczbą binarną, której zapis dziesiętny jest L = 14 (czyli 1110), dla x = (000001), L = 4, wreszcie dla x = (111111), L = 13.
Funkcje boolowskie reprezentowane odwzorowaniem f, jakkolwiek możliwe do bezpośredniej realizacji technicznej, nie są najlepszą formą do zastosowań w strukturach bramkowych. Znacznie wygodniejsze w tym przypadku są reprezentacje funkcji w postaci wyrażeń boolowskich (formuł boolowskich). Ich zaleta wynika przede wszystkim z łatwej realizacji elementów logicznych zwanych bramkami logicznymi, które to elementy stanowią naturalną realizację wyrażeń boolowskich, gdzie występują w postaci operatorów.
Dla funkcji opisanej tablicą prawdy podaną w tabl. 2.1a odpowiednia formuła boolowska jest następująca:
a jej realizacja na bramkach AND, OR, NOT pokazana jest na rys. 2.2.
W układzie kombinacyjnym z rys. 2.2 funkcja f, realizowana na jego wyjściu f, reprezentuje odwzorowanie z tabelki prawdy, co łatwo sprawdzić wprowadzając na wejścia układu odpowiednie wektory binarne i obliczając wartość uzyskaną na wyjściu y. Na przykład dla x1 = x2 = 0, x3 = 1 na wyjściu bramki AND1 pojawi się sygnał o wartości 1, i w rezultacie wyjście y przyjmie wartość 1.
Natomiast dla x1 = x2 = x3 = 0 na wyjściach wszystkich bramek AND będzie
Rys. 2.2. Realizacja funkcji f: a) bezpośrednio, b) po uproszczeniu wg zasad algebry Boole’a
Niekwestionowaną zaletą formuł boolowskich jest możliwość ich upraszczania, a co zatem idzie możliwość uzyskiwania realizacji oszczędniejszych z punktu widzenia liczby bramek. Zasady formalne upraszczania formuł boolowskich związane są z prawami i własnościami algebry Boole’a. Stosując prawa algebry Boole’a, poprzednio podane wyrażenie na f można uprościć w sposób podany w następującym przykładzie.
Ostatecznie wyrażenie to można zrealizować w układzie kombinacyjnym, którego struktura – znacznie prostsza od poprzedniej realizacji – jest pokazana na rys. 2.2b.
Sens fizyczny minimalizacji i jej ogromne znaczenie praktyczne wynika z faktu, że oba układy: pierwotny i zminimalizowany działają identycznie. Zatem upraszczając wyrażenia boolowskie będziemy mogli jednocześnie uprościć ich realizację, np. zmniejszyć liczbę zastosowanych bramek co decyduje o kosztach realizacji i tym samym jest głównym czynnikiem zwiększającym konkurencyjność naszego produktu na rynku.
Zasygnalizowany tu proces upraszczania wyrażeń boolowskich ma ogromne znaczenie praktyczne i opracowano dla jego potrzeb wiele zaawansowanych metod syntezy, które z technicznego punktu widzenia nazywa się metodami minimalizacji funkcji boolowskich. Wiele z nich doczekało się realizacji w postaci zaawansowanych narzędzi komputerowych i stanowi podstawę nowoczesnej syntezy logicznej.
2. Formy kanoniczne funkcji boolowskich
Niech wektorowi w = (x1, …, xj, …, xn) odpowiada następujące wyrażenie zapisane w formie iloczynu zmiennych prostych i zanegowanych:
Oznacza to, że składowej 0 wektora odpowiada w iloczynie zmienna zanegowana, a składowej 1 – zmienna prosta. Iloczyn taki nazywamy iloczynem pełnym, gdyż zawiera on wszystkie zmienne. Iloczyn pełny przyjmuje wartość 1 tylko dla tych wektorów w tablicy prawdy funkcji, dla których wartość funkcji jest 1; dla innych wektorów wartość jego wynosi 0. Iloczyn pełny będziemy także oznaczać Pi.
Zbiorowi wektorów {<b><i>w</i></b><sub>1</sub>, …, </span></span></span></span><span style="font-size:12.0pt"><span style="line-height:115%"><span style="font-family:"Calibri",sans-serif"><span style="color:black"><b><i>w</i></b><i><sub>i</sub></i></span></span></span></span><span style="font-size:12.0pt"><span style="line-height:115%"><span style="font-family:"Calibri",sans-serif"><span style="color:black">, …, <b><i>w</i></b><i><sub>r</sub></i>} Í {0,1}n, gdzie dla każdego i, f(wi)=1, odpowiada wyrażenie:
Jest to tzw. kanoniczna postać sumy. Stanowi ona sumę wszystkich iloczynów pełnych mnożonych przez wartość funkcji dla kombinacji i. W wyrażeniu tym pozostają w efekcie te iloczyny (tzw. mintermy), którym odpowiada wartość funkcji 1; iloczyny, którym odpowiada wartość funkcji 0, znikają. Kanoniczną postać sumy można utworzyć bezpośrednio z tablicy prawdy przez wybranie wierszy, dla których wartość funkcji wynosi 1, utworzenie dla każdego takiego wiersza iloczynu pełnego, oraz utworzenie sumy iloczynów pełnych.
Kanoniczna postać sumy funkcji z tabl. 2.1a jest zatem następująca:
Postępowanie dualne prowadzi do tzw. kanonicznej postaci iloczynu. Wektorowi wi = (x1, …, xj, …, xn), gdzie f(wi) = 0, odpowiada następujące suma logiczna:
Oznacza to, że składowej 0 wektora odpowiada w sumie zmienna prosta, a składowej 1 – zmienna zanegowana. Suma taka nazywa się sumą pełną, gdyż zawiera ona wszystkie zmienne w postaci prostej lub zanegowanej. Suma pełna przyjmuje wartość 0 dla wektora xi; dla innych wektorów wartość jej wynosi 1. Sumę pełną będziemy także oznaczać Si.
Zbiorowi wektorów {<b><i>x</i></b><sub>1</sub>, …, <b><i>x</i></b><i><sub>i</sub></i>, …, <b><i>x</i></b><i><sub>r</sub></i>} Í {0,1}n, gdzie dla każdego i, f(xi) = 0, odpowiada iloczyn:
Wyrażenie to stanowi iloczyn zawierający wszystkie sumy pełne z dodanymi wartościami funkcji dla kombinacji i. Te sumy Si, dla których f(i) = 1, znikają; zostają sumy (tzw. maxtermy) z f(i) = 0.
Jest to tzw. kanoniczna postać iloczynu, której interpretacja za pomocą funkcji z tabl. 2.1a jest następująca:
W tym przypadku synteza funkcji sprowadza się do wybrania wierszy, dla których wartość funkcji wynosi 0, utworzenia dla każdego takiego wiersza sumy pełnej oraz utworzenia iloczynu sum pełnych.
Należy mieć świadomość, że kanoniczna postać iloczynu może być uproszczona w analogiczny sposób jaki stosowaliśmy przy uproszczeniu kanonicznej postaci sumy tej funkcji. Stosując zasady algebry Boole’a łatwo sprawdzić, że funkcję tę, zapisaną w postaci iloczynu sum reprezentuje następujące wyrażenie:
Tablica 2.4
W tablicy 2.4 zestawiono dla przykładu wszystkie iloczyny pełne i sumy pełne dla trzech zmiennych x1 , x2 , x3.
Dla funkcji f1 = S[0, 1, 2, 5, 8, 9, 10, (4, 12, 13)] podanej w tablicy 2.5 odpowiednie wyrażenie boolowskie wg kanonicznej postaci sumy jest:
Tablica 2.5
i |
x1 |
x2 |
x3 |
x4 |
f1 |
f2 |
0 |
0 |
0 |
0 |
0 |
1 |
1 |
1 |
0 |
0 |
0 |
1 |
1 |
– |
2 |
0 |
0 |
1 |
0 |
1 |
1 |
3 |
0 |
0 |
1 |
1 |
0 |
– |
5 |
0 |
1 |
0 |
1 |
1 |
1 |
6 |
0 |
1 |
1 |
0 |
0 |
0 |
7 |
0 |
1 |
1 |
1 |
0 |
1 |
8 |
1 |
0 |
0 |
0 |
1 |
0 |
9 |
1 |
0 |
0 |
1 |
1 |
– |
10 |
1 |
0 |
1 |
0 |
1 |
0 |
11 |
1 |
0 |
1 |
1 |
0 |
– |
13 |
1 |
1 |
0 |
1 |
– |
1 |
14 |
1 |
1 |
1 |
0 |
0 |
0 |
15 |
1 |
1 |
1 |
1 |
0 |
1 |
Kolejne iloczyny odpowiadają i = 0, 1, 2, 5, 8, 9, 10.
Natomiast dla funkcji f2 = Õ[6, 8, 10, 14, (1, 3, 4, 9, 11, 12)] kanoniczna postać iloczynu jest następująca:
Kolejne sumy odpowiadają i = 6, 8, 10, 14.
3. Specyfikacje i realizacje funkcji boolowskich
Omówione w poprzednich podrozdziałach zasady reprezentacji funkcji boolowskich są w praktyce projektowania układów cyfrowych bardziej sformalizowane. Stosowanie formalnych zasad specyfikacji funkcji boolowskich jest ważne ze względu na coraz powszechniejsze stosowanie komputerowych systemów projektowania. Zasady te – w przypadku języków opisu sprzętu – są mocno rozbudowane i przy założonej tematyce tego podręcznika mało istotne dla omawiania zaawansowanych algorytmów syntezy logicznej.
Z tych powodów ograniczymy się do tzw. standardu berkeley’owskiego stosowanego w komputerowym systemie Espresso [2.1].
Tablica 2.6
type fr .i 4 .o 7 .p 10 0000 1111110 0001 0110000 0010 1101101 0011 1111001 0100 0110011 0101 1011011 0110 1011111 0111 1110000 1000 1111111 1001 1111011 .e |
W tablicy 2.6 jest podana tablica prawdy funkcji boolowskiej reprezentującej działanie dekodera wskaźnika siedmiosegmentowego (por. tabl. 2.2). Istotą takiej reprezentacji (plik typu pla) jest specyficzny zapis nagłówka określającego:
.type fr – typ danych
.i 4 – liczba wejść
.o 7 – liczba wyjść
.p 10 – liczba wektorów (kostek)
Realizacje funkcji boolowskich
Dysponując różnymi bramkami logicznymi możemy realizować funkcje boolowskie w różnych strukturach. Do najbardziej typowych i najczęściej stosowanych należą:
realizacja AND-OR,
realizacja OR-AND.
Na rys. 2.3a pokazano realizację AND-OR funkcji opisanej wyrażeniem:
Rys. 2.3. Realizacja AND-OR (a) i OR-AND (b)
Realizacja AND-OR jest bezpośrednim odwzorowaniem wyrażenia boolowskiego typu SOP (Sum of Product). Z kolei realizację OR-AND uzyskujemy z wyrażenia typu iloczyn sum. Na rys 2.3b pokazano realizację OR-AND funkcji opisanej wyrażeniem
W dwuelementowej algebrze Boole'a wprowadza się też inne działania (operatory). Do najważniejszych z nich należą: zanegowana suma (NOR), zanegowany iloczyn (NAND), oraz suma wyłączająca (tzw. suma modulo 2 lub różnica symetryczna, oznaczana EXOR).
Określenia tych działań podano w tablicy 2.7, a odpowiednie symbole bramek na rys. 2.4.
Rys. 2.4. Symbole bramek NAND, NOR i EXOR
Tablica 2.7
Dysponując bramkami logicznymi NAND, NOR możemy realizować funkcje boolowskie w innych strukturach. Do najbardziej typowych i najczęściej stosowanych należą:
realizacja NAND,
realizacja NOR.
Realizację NAND uzyskujemy z wyrażenia typu suma iloczynów, które przekształcamy zgodnie z prawem De Morgana do postaci:
Rys. 2.5. Realizacja NAND (a) i NOR (b)
Realizację NAND podano na rys. 2.5a.
Z kolei przekształcenie wyrażenia typu iloczyn sum wg prawa De Morgana:
bezpośrednio prowadzi do realizacji NOR, którą podano na rys. 2.5b.
Realizacje takie polegają na konfigurowaniu (programowaniu) matrycy AND-OR, która jest podstawowym elementem konstrukcyjnym układów PLD. Matryca AND-OR może być matrycą typu PAL (Programmable Array Logic), której cechą charakterystyczną jest programowalna matryca AND i stała matryca OR lub typu PLA (Programmable Logic Array), gdzie obie matryce, AND i OR są programowalne. Znaczy to, że PAL jest zespołem bramek iloczynowych dołączonych do oddzielnych bramek OR (rys. 2.6a), a w PLA każda bramka AND może być dołączona do dowolnej bramki OR (rys. 2.6b). Programowanie polega na realizacji połączeń w punktach styku linii poziomych i pionowych.
Całkowicie odmienne możliwości realizacji funkcji boolowskich powstały wraz z wprowadzeniem struktur programowalnych typu FPGA (Field Programmable Gate Array). Wynika to z faktu, że w układach FPGA typową strukturą jest prostokątna macierz elementów logicznych zwanych komórkami, rozmieszczonych w środowisku komutacyjnym kanałów połączeniowych.
Rys. 2.6. Matryca typu PAL (a) i typu PLA (b)
Komórka struktur FPGA jest zbudowana z uniwersalnego układu kombinacyjnego, umożliwiającego realizację dowolnej funkcji logicznej (zadanej tablicą prawdy) o kilku wejściach i jednym lub dwóch wyjściach. Z tych powodów taką komórkę nazywa się komórką typu LUT (Look Up Table), a jednocześnie klasę układów zbudowanych z takich komórek nazywa się układami FPGA typu LUT. Dlatego realizacje w strukturach FPGA mają całkiem odmienne wymagania na struktury układów logicznych. Bezpośrednie odwzorowanie struktur bramkowych na komórki logiczne układów FPGA jest sprzeczne z naturą komórki o tyle, że z punktu widzenia syntezy jest ona przystosowana do realizacji dowolnej funkcji logicznej o argumentach wprowadzonych na jej wejścia. Z tych powodów dla struktur FPGA znacznie skuteczniejszą metodą syntezy okazuje się dekompozycja funkcji boolowskich, której istotą jest synteza funkcji boolowskich w strukturach wielopoziomowych złożonych z komponentów w postaci bloków logicznych typu LUT specyfikowanych pierwotnymi tablicami prawdy.
Tablica 2.8
x1 |
x2 |
x3 |
x4 |
x5 |
f |
|
1 |
0 |
0 |
0 |
0 |
0 |
0 |
2 |
0 |
1 |
0 |
1 |
1 |
0 |
3 |
0 |
0 |
1 |
0 |
1 |
0 |
4 |
0 |
1 |
1 |
1 |
1 |
0 |
5 |
0 |
0 |
1 |
1 |
0 |
0 |
6 |
0 |
1 |
0 |
0 |
1 |
1 |
7 |
0 |
0 |
1 |
0 |
0 |
1 |
8 |
0 |
1 |
1 |
1 |
0 |
1 |
9 |
1 |
0 |
1 |
0 |
1 |
1 |
10 |
1 |
1 |
0 |
0 |
1 |
1 |
11 |
1 |
0 |
0 |
0 |
1 |
1 |
Rys. 2.7. Realizacja funkcji f z tab. 2.8
Na przykład funkcję podaną w tablicy 2.8 można zrealizować w strukturze FPGA, jeśli tylko bloki g i h realizują odwzorowania podane w tablicach 2.9a i 2.9b, co pokazano na rys. 2.7. Można sprawdzić, że dla każdego wektora złożenie funkcji g oraz h wytwarza na wyjściu h = f tę samą wartość.
Tablica 2.9
a) |
|
b) |
|
|
|
|||
x3 |
x4 |
x5 |
g |
|
x1 |
x2 |
g |
h |
0 |
0 |
0 |
0 |
|
0 |
0 |
0 |
0 |
0 |
1 |
1 |
1 |
|
0 |
0 |
1 |
1 |
1 |
0 |
1 |
0 |
|
0 |
1 |
0 |
1 |
1 |
1 |
1 |
1 |
|
0 |
1 |
1 |
0 |
1 |
1 |
0 |
0 |
|
1 |
0 |
0 |
1 |
0 |
0 |
1 |
0 |
|
1 |
1 |
0 |
1 |
1 |
0 |
0 |
1 |
|
|
|
|
|
4. Metody minimalizacji funkcji boolowskich
Minimalizacja funkcji boolowskich jest zagadnieniem intensywnych prac badawczych od początku lat 50. XX wieku. Później, w latach 70. pojawienie się układów scalonych średniej i wielkiej skali integracji spowodowało wyraźne zmniejszenie zainteresowania tym problemem. Ale ponowny wzrost zainteresowania minimalizacją funkcji boolowskich powstał w latach 80. Bezpośrednią przyczyna tej sytuacji stała się możliwość realizacji układów logicznych w strukturach scalonych o złożoności milionów bramek logicznych.
Najbardziej znaną i powszechnie stosowaną metodą graficzną jest metoda tablic Karnaugha. Klasyczną metodą analityczną jest metoda Quine’a – McCluskey’a. Obie metody opracowane zostały w połowie lat 50. XX wieku. Niestety zarówno metoda Karnugha, jak też Quine’a – McCluskey’a nie są przystosowane do wymagań dzisiejszych technologii.
Wadą pierwszej jest graficzny sposób obliczeń ograniczający z natury liczbę zmiennych minimalizowanych funkcji, natomiast w przypadku drugiej barierą ograniczająca jest złożoność obliczeniowa stosowanych algorytmów.
Dlatego powstały nowe, całkowicie odmienne metody syntezy dwupoziomowej. Przede wszystkim znalazły one zastosowanie w klasycznym już algorytmie ESPRESSO opracowanym na Uniwersytecie Kalifornijskim w Berkeley w latach 80. Znajdują one minimalne lub suboptymalne rozwiązania nawet dla bardzo skomplikowanych zadań. Syntezie mogą być poddawane zespoły nie w pełni określonych funkcji boolowskich, o wielowartościowych wejściach i o setkach argumentów, a czas obliczeń jest stosunkowo krótki.
4.1. Metoda Karnaugha
Mimo swoich niedoskonałości metoda Karnaugha jest najczęściej wykładaną metoda minimalizacji funkcji boolowskich. Paradoksalnie to co jest jej wadą – prostota – jest jednocześnie jej zaletą, gdyż można szybko ją „opanować” i stosować w obliczeniach ręcznych. Należy jednak pamiętać, że w praktyce projektowania inżynierskiego metoda tablic Karnaugha jest absolutnie nieprzydatna, gdyż zakres jej zastosowań kończy się na funkcjach 6 – 7 argumentów, a typowe zadania praktyczne operują funkcjami o kilkudziesięciu argumentach.
Rys. 2.8. Zasada sklejania
W metodzie Karnaugha każda kratka odpowiedniej tablicy (zwanej tablicą Karnaugha) odpowiada wektorowi zmiennych binarnych. Można więc powiedzieć, że ciąg wartości tych zmiennych tworzy adres kratki. Kratki są ponumerowane w taki sposób, że numer i jest liczbą dziesiętną odpowiadającą kombinacji zmiennych (wektorowi zero-jedynkowemu) traktowanej jako liczba dwójkowa. W poszczególnych kratkach wpisane są wartości funkcji, tj. 0 lub 1 przyjmowanej przez funkcję dla tej kombinacji lub symbol „–”, jeżeli funkcja nie jest określona (rys. 2.8). W tablicy Karnaugha różniącym się tylko o negację pełnym iloczynom przyporządkowane są leżące obok siebie pola tablicy (sąsiednie kratki), które się łączy (skleja) odpowiednią pętelką. Korzysta się z faktu, że dla dowolnego .
Dla uzyskania efektu sąsiedztwa współrzędne pól opisuje się tzw. kodem Gray’a. Kod Gray’a jest takim ciągiem wektorów binarnych, w którym każde dwa sąsiednie wektory różnią się wyłącznie na jednej pozycji. Przykłady kodu Gray’a dla dwóch i trzech zmiennych podane są w tabl. 2.10.
Tablica 2.10
0 |
0 |
|
0 |
0 |
0 |
0 |
1 |
|
0 |
0 |
1 |
1 |
1 |
|
0 |
1 |
1 |
1 |
0 |
|
0 |
1 |
0 |
|
|
|
1 |
1 |
0 |
|
|
|
1 |
1 |
1 |
|
|
|
1 |
0 |
1 |
|
|
|
1 |
0 |
0 |
Minimalizacja metodą Karnaugha polega na wykonaniu dwóch czynności:
- wpisanie funkcji do tablicy,
- zakreślanie pętelek i kojarzenie z nimi iloczynów zmiennych prostych i zanegowanych.
Wpisywanie funkcji do tablicy Karnaugha ułatwia numeracja kratek. Na rys. 2.9 podajemy przykłady tablic Karnaugha z ponumerowanymi kratkami według naturalnego kodu binarnego (NKB), odpowiednikami. Wzorce tych tablic ułatwiają znajdowanie kratek odpowiadających wektorom w tablicy prawdy.
Rys. 2.9. Przykłady tablic z ponumerowanymi kratkami
Minimalizacja funkcji f z poprzedniego rozdziału, której tablicę prawdy powtarzamy w tabl. 2.11 wymaga zatem wpisania funkcji do tablicy Karnaugha.
Tablica 2.11
|
x1 |
x2 |
x3 |
f |
0 |
0 |
0 |
0 |
0 |
1 |
0 |
0 |
1 |
1 |
2 |
0 |
1 |
0 |
0 |
3 |
0 |
1 |
1 |
1 |
4 |
1 |
0 |
0 |
0 |
5 |
1 |
0 |
1 |
1 |
6 |
1 |
1 |
0 |
1 |
7 |
1 |
1 |
1 |
1 |
Wystarczy w tym celu wyszukiwać kratki tablicy, których współrzędne odpowiadają wektorom tablicy prawdy i do ich wnętrza wpisywać wartość funkcji.
Tablica 2.12
Tablica Karnaugha funkcji f podana jest w tabl. 2.12. Następnie zakreślamy pętelki. Pętelki muszą obejmować kratki wypełnione „1”, których współrzędne reprezentują pełne iloczyny zmiennych podlegające uproszczeniu zasadami algebry Boole’a. Łatwo stwierdzić, że „1” małej pętelki są opisane wyrażeniem:
natomiast dużej:
Stosując zasady algebry Boole’a można wyrażenie 2-1 uprościć do iloczynu x1x2, natomiast wyrażenie 2-2 do jednej zmiennej x3, zatem f = x1x2 + x3.
Niestety zakreślanie pętelek i kojarzenie z nimi odpowiednich iloczynów jest trudniejsze. Omawiamy ten proces na bardziej skomplikowanym przykładzie (rys. 2.10), w którym dla poszczególnych kopii tablicy Karnaugha trzech zmiennych zaznaczamy pola odpowiadające pojedynczym zmiennym (prostym i zanegowanym). Pokrywanie się tych pól określa odpowiedni iloczyn zmiennych prostych
Rys. 2.10. Ilustracja minimalizacji funkcji boolowskiej
Minimalizacja funkcji za pomocą tablic Karnaugha sprowadza się do wykonania czynności opisanych w następującym algorytmie.
Algorytm 2.1
1) Wpisujemy funkcję do tablicy Karnaugha.
2) Zakreślamy pętelki.
a) Pętelki zakreślamy wokół grup sąsiadujących kratek zawierających „1” albo „1” i „–” (kreski).
b) Liczba kratek objętych pętelka musi wynosić: 1, 2, 4, …,2k.
c) Staramy się objąć pętelką jak największą liczbę kratek.
3) Pętelki zakreślamy tak długo, aż każda „1” będzie objęta co najmniej jedną pętelką, pamiętając o tym aby pokryć wszystkie „1” możliwie minimalną liczbą pętelek.
4) Z każdą pętelką kojarzymy iloczyn zmiennych prostych lub zanegowanych. Suma tych iloczynów, to minimalne wyrażenie boolowskie danej funkcji.
Należy zminimalizować funkcję f zapisaną symbolicznie w postaci SOP liczbami dziesiętnymi:
f = S[0, 5, 6, 7, 10, (2, 3, 11, 12)]
Tablica 2.13
Korzystając z odpowiedniego wzoru tablicy z rys. 2.9 znajdujemy kratki o odpowiednich numerach i wpisujemy do nich „1” i ”–„ (kreski). W pozostałe wpisujemy „0”. Po wpisaniu zakreślamy pętelki (tabl. 2.13), z którymi kojarzymy odpowiednie iloczyny, uzyskując w rezultacie minimalne wyrażenie boolowskie w postaci sumy iloczynów:
W podobny sposób postępujemy przy obliczaniu minimalnego wyrażenia w postaci iloczynu sum. Jedyną różnicą jaką w tym przypadku należy wprowadzić do algorytmu 2.1 jest zmiana w punkcie w punkcie 2a, a mianowicie: pętelki zakreślamy wokół grup sąsiadujących kratek zawierających „0” albo „0”
Minimalizacja funkcji z przykładu 2.4 do postaci iloczynu sum przedstawiona jest na tabl. 2.14.
Rozwiązanie
Tablica 2.14
Poszczególnym pętelkom na tej tablicy odpowiadają sumy zmiennych, których iloczyn tworzy następujące wyrażenie:
Uprościć następujące wyrażenie:
Rozwiązanie
Nanosimy wyrażenie Y na tablicę Karnaugha (tab. 2.15) i upraszczamy tworząc pętelki obejmujące zera. Następnie wypisujemy rozwiązanie, dla kanonicznego iloczynu sum argumenty z 0 są proste, argumenty z 1 są zanegowane.
Tablica 2.15
Po minimalizacji uzyskaliśmy następująca funkcję:
Przykład 2.4 posłuży teraz do wprowadzenia jednego z najważniejszych pojęć minimalizacji jakim jest implikant.
Implikant danej funkcji f jest to iloczyn literałów (zmiennych prostych i zanegowanych) taki, że odpowiadający mu zbiór wektorów binarnych nie zawiera wektora „zerowego” funkcji.
Prosty implikant jest to implikant, który zmniejszony o dowolny literał przestaje być implikantem.
Na przykład jest implikantem funkcji f, bo zbiór wektorów reprezentowanych przez ten implikant: 0111 oraz 0011 nie zawiera żadnego wektora (mintermu), dla którego wartość funkcji jest 0. Są to bowiem mintermy, które w naturalnym kodzie binarnym odpowiadają liczbom 7 i 12, i jak widać z zapisu funkcji f = S[0, 5, 6, 7, 10, (2, 3, 11, 12)], nie należną one do zbioru wektorów „zerowych” tej funkcji.
Pojęcie implikantu można zinterpretować na tablicy Karnaugha. W tablicy 2.16 zakreślono dwie pętelki. Mniejsza odpowiada implikantowi . Nie może to być implikant prosty, gdyż pętelkę tę można powiększyć. Większej pętelce odpowiada implikant prosty
, w którym nie można już usunąć żadnego literału.
Tablica 2.16
Zminimalizować metodą Karnaugha następującą funkcję boolowską:
f = S[4,5,10,11,15,18,20,24,26,30,31, (9,12,14,16,19,21,25)]
Po zakreśleniu „pętelek” (tab. 2.17) uzyskujemy następujące wyrażenie boolowskie:
Tablica 2.17
W dotychczasowych przykładach minimalizowane były pojedyncze funkcje boolowskie, dla których – w celu uzyskania rozwiązania z minimalnym kosztem – tworzone były wyłącznie implikanty proste. W ogólnym przypadku minimalizacji zespołów funkcji boolowskich tworzenie minimalnego rozwiązania wyłącznie na podstawie implikantów prostych nie zawsze prowadzi do najlepszego rezultatu końcowego. Problem sygnalizuje przykład 2.8.
Należy zrealizować zespół trzech funkcji czterech argumentów:
f1= S(3,7,11,14,15)
f2 = S(3,7,12,13,14,15)
f3 = S(3,7,11,12,13,15)
Tablica 2.18
Jeśli każdą funkcję zminimalizujemy oddzielnie (tablice Karnaugha poszczególnych funkcji pokazane są w tabl. 2.18), to uzyskamy następujące wyrażenia:
których realizację pokazano na rys. 2.11. Do realizacji tych trzech funkcji potrzebujemy 9 bramek
Rys. 2.11. Realizacja funkcji z tablicy 2.18
Zauważmy jednak, że bramka AND dla f1 może być usunięta przez wykorzystanie bramki AND z f3 (rys. 2.12a). Natomiast bramkę AND z f2 można usunąć przez wykorzystanie faktu , co prowadzi do struktury zbudowanej zaledwie z 7 bramek (rys. 2.12b).
Rys. 2.12. Realizacja funkcji z tablicy 2.18: a) z uproszczoną funkcją f1; b) z uproszczonymi funkcjami f1 i f2
Przykład sugeruje, że w realizacji zespołu funkcji stosowanie minimalnej sumy implikantów prostych nie zawsze prowadzi do rozwiązania z minimalnym kosztem. Kolejny przykład ilustruje w jaki sposób należy dobierać implikanty zespołu funkcji, aby uzyskać rozwiązanie z minimalnym kosztem.
Należy zminimalizować zespół funkcji:
y1 = S(2,3,5,7,8,9,10,11,13,15)
y2 = S(2,3,5,6,7,10,11,14,15)
y3 = S(6,7,8,9,13,14,15)
W tablicach 2.19a, b, c podane są wykresy Karnaugha poszczególnych funkcji, odpowiednio: y1, y2, y3. Po zakreśleniu „pętelek” obejmujących implikanty proste uzyskujemy następujące wyrażenia boolowskie:
Realizacja tych wyrażeń wymaga zastosowania 7 bramek AND i 3 bramek OR.
Tablica 2.19
Znacznie lepszą realizację uzyskamy dokonując minimalizacji w sposób przedstawiony w tablicach 2.20a, b, c.
Tablica 2.20
Pętelki w tych tablicach zakreślamy tak, aby uzyskiwać implikanty wspólne dla co najmniej dwóch spośród trzech funkcji. Spełnienie tego warunku wymusza zakreślanie pętelek wokół grup kratek reprezentujących implikanty, które nie są implikantami prostymi. W rezultacie uzyskujemy następujące wyrażenia:
Realizacja powyższych wyrażeń łącznie, mimo pozornie większego skomplikowania dla poszczególnych funkcji, jest oszczędniejsza niż poprzednio; całość wymaga bowiem zastosowania 5 bramek AND i trzech bramek OR.
4.2. Metoda systematyczna
W metodzie systematycznej zbiór wektorów (w ogólności kostek), dla których funkcja f = 1 oznacza się F. Natomiast zbiór tych wektorów (kostek), dla których funkcja f = 0 oznacza się R.
W tabl. 2.21 przedstawiono tablicę prawdy funkcji boolowskiej 7-argumentowej. Funkcję tę w dalszej części wykładu oznaczać będziemy EXTL. Wektory zbioru F oznaczono symbolami k1, …, k5.
Tablica 2.21
|
x1 |
x2 |
x3 |
x4 |
x5 |
x6 |
x7 |
f |
|
1 |
0 |
0 |
0 |
1 |
0 |
1 |
0 |
|
1 |
0 |
1 |
1 |
1 |
1 |
0 |
0 |
|
1 |
1 |
0 |
1 |
1 |
1 |
0 |
0 |
|
1 |
1 |
1 |
0 |
1 |
1 |
1 |
0 |
k1 |
0 |
1 |
0 |
0 |
1 |
0 |
1 |
1 |
k2 |
1 |
0 |
0 |
0 |
1 |
1 |
0 |
1 |
k3 |
1 |
0 |
1 |
0 |
0 |
0 |
0 |
1 |
k4 |
1 |
0 |
1 |
0 |
1 |
1 |
0 |
1 |
k5 |
1 |
1 |
1 |
0 |
1 |
0 |
1 |
1 |
Metoda systematyczna jest procesem działającym na kostkach zbiorów F i R, a jej celem jest uzyskanie dla danej k Î F kostki k' tak dużej, jak to tylko możliwe (tzn. z możliwie dużą liczbą pozycji o wartości *) i nie pokrywającej żadnego wektora zbioru R. W swoich obliczeniach metoda ta wykorzystuje tzw. macierz blokującą B.
Macierzą blokującą (kostkę k) nazywać będziemy macierz:
B(k,R) = [bij], 1 £ i £ ÷R÷, 1 £ j £ n,
w której każdy element bij Î {0,1} jest definiowany następująco:
bij = 1, jeśli kj = 1 oraz rij = 0 lub kj = 0 oraz rij = 1;
bij = 0, w pozostałych przypadkach.
W przypadku funkcji opisanej wektorami binarnymi macierz blokująca dla danej kostki k Î F powstaje z macierzy R przez zanegowanie tych kolumn R, których pozycje są wyznaczone przez pozycje jedynek w kostce k Î F.
Wyznaczymy macierz blokującą dla f = (F, R) zadanej w tablicy 2.21 i kostki k2. Jak wynika z tej tablicy, zbiory F i R są opisane macierzami:
Skoro k2 = (1000110), to dla uzyskania B wystarczy w macierzy R „zanegować” kolumny pierwszą, piątą i szóstą. Zatem B(k2, R):
Pokryciem kolumnowym macierzy B = [bij], i {1, …, <i>w</i>}, j
{1, …, <i>n</i>} jest zbiór L
{1, …, <i>n</i>} taki, że dla każdego i
{1, …, <i>w</i>} istnieje j
L, dla którego bij = 1.
Pokrycie kolumnowe jest pokryciem, w którym elementami pokrywanymi są wiersze B, a pokrywającymi – kolumny tej macierzy. Jednak brak formalnych elementów pokrywanych i pokrywających skłania do wprowadzenia nazwy „pokrycie kolumnowe”.
Obliczenia pokrycia kolumnowego omówimy na przykładzie macierzy blokującej wyznaczonej dla kostki k2 funkcji z poprzedniego przykładu.
Oznaczając kolumny macierzy B kolejno L1 do L7 zapisujemy poszczególne wiersze tej macierzy oznaczeniami tych kolumn, które w danym wierszu mają „1”. Na przykład wiersz pierwszy zapiszemy L6, L7, drugi L3, L4, itd. Traktując kolumny Li jako zmienne boolowskie tworzymy iloczyn sum kolumn poszczególnych wierszy:
(L6 + L7) (L3 + L4) (L2 + L4) (L2 + L3 + L7)
Następnie iloczyn sum przekształcamy do wyrażenia boolowskiego typu suma iloczynów:
(L4 + L2)(L4 + L3)(L7 + L6)(L7 + L2 + L3) = (L4 + L2L3)(L7 + L6(L2 + L3)) = (L4 + L2L3)(L7 + L2L6 + L3L6) =
= L4L7 + L2L4L6 + L3L4L6 + L2L3L7 + L2L3L6
Składniki tego wyrażenia reprezentują zbiory minimalnego pokrycia kolumnowego:
{<i>L</i><sub>4</sub>, <i>L</i><sub>7</sub>}, {<i>L</i><sub>2</sub>, <i>L</i><sub>4</sub>, <i>L</i><sub>6</sub>}, {<i>L</i><sub>3</sub>, <i>L</i><sub>4</sub>, <i>L</i><sub>6</sub>}, {<i>L</i><sub>2</sub>, <i>L</i><sub>3</sub>, <i>L</i><sub>7</sub>}, {<i>L</i><sub>2</sub>, <i>L</i><sub>3</sub>, <i>L</i><sub>6</sub>}
Macierz blokująca B(k, R) pozwala wyznaczyć uogólnioną kostkę k oznaczaną k+(L, k) w sposób następujący:
Uogólnioną kostkę k+(L, k) nazywa się również ekspansją kostki k, co oznacza, że wszystkie składowe kostki k należące do L nie ulegają zmianie, natomiast składowe nie należące do L przyjmują wartość *.
Można wykazać, że k+(L, k) jest implikantem funkcji f = (F, R). W szczególności k+(L, k) jest implikantem prostym, gdy L jest minimalnym pokryciem kolumnowym macierzy B(k, R). Wykorzystując pojęcie macierzy blokującej można obliczyć implikanty proste dla poszczególnych kostek zbioru F.
Kontynuujemy obliczenia dla macierzy blokującej B = B(k2, R) z przykładu 2.10.
Zbiór L = {4,7} jest pokryciem kolumnowym B, a więc , czyli implikantem F jest
. Natomiast dla L = {2,4,6} (inne pokrycie kolumnowe)
. Postępując podobnie dla pozostałych pokryć kolumnowych można uzyskać następujący zbiór implikantów prostych funkcji f generowanych przez kostkę k2:
Każdy z obliczonych w ten sposób implikantów może zastąpić (często mówimy pokrywa) wiele innych kostek pierwotnych funkcji f, gdzie relację pokrycia definiujemy następująco:
K Í K’ (K’ pokrywa K) wtedy i tylko wtedy, gdy dla każdego i, 1 £ i £ n,
Na przykład obliczony wyżej implikant pokrywa kostki k2, k3, k4, co zapisujemy formalnie:
Relacja pokrycia dla kostek i sposób postępowania omówiony w przykładzie 2.12 nasuwa pomysł systematycznej metody obliczania minimalnych realizacji funkcji boolowskich.
Kolejne etapy takiej metody są następujące.
- Dla każdej ki należącej do zbioru F obliczyć macierz blokującą.
- Wyznaczyć wszystkie minimalne pokrycia kolumnowe tej macierzy.
- Wyznaczyć wszystkie implikanty proste.
- Obliczyć sumę zbiorów implikantów prostych generowanych przez poszczególne kostki.
- Z tak utworzonego zbioru wszystkich implikantów prostych usunąć implikanty powtarzające się.
- Spośród obliczonych implikantów prostych wyselekcjonować minimalny podzbiór implikantów pokrywający wszystkie kostki zbioru F.
Niezależnie jednak od metody ograniczania liczności zbioru implikantów prostych proces ich selekcji wykonuje się za pośrednictwem tzw. tablicy implikantów prostych.
Tablica implikantów prostych jest to tablica elementów binarnych 0 lub 1, o liczbie wierszy równej liczbie kostek zbioru F oraz liczbie kolumn równej liczbie wyznaczonych implikantów prostych funkcji f.
Tablicę implikantów prostych konstruujemy w następujący sposób. Jeśli implikant Ij pokrywa kostkę ki, to na przecięciu wiersza ki z kolumną Ij piszemy 1, w przeciwnym przypadku piszemy 0.
Utworzymy tablicę implikantów prostych dla funkcji f podanej w tabl. 2.21. W tym celu obliczamy minimalne (i o najmniejszej liczności) pokrycia kolumnowe dla każdej kostki zbioru F tej funkcji. Oznaczając przez Ji implikanty generowane przez kostkę ki uzyskujemy kolejno:
Usuwając implikanty powtarzające się ostateczną listę implikantów prostych zapisujemy jak następuje:
Na tej podstawie dla każdego obliczonego wyżej implikanta (ale interpretowanego jako kostka) wyznaczamy wszystkie kostki zbioru F pokrywane przez ten implikant. Przykładowo:
Tablicę implikantów prostych dla funkcji f pokazano w tabl. 2.22.
Tablica 2.22
|
I1 |
I2 |
I3 |
I4 |
I5 |
k1 |
1 |
0 |
0 |
1 |
0 |
k2 |
0 |
1 |
0 |
0 |
0 |
k3 |
0 |
1 |
1 |
0 |
1 |
k4 |
0 |
1 |
0 |
0 |
0 |
k5 |
0 |
0 |
0 |
1 |
1 |
Tablica implikantów prostych umożliwia wybór (selekcję) takiego minimalnego zbioru implikantów, który pokrywa wszystkie kostki funkcji pierwotnej.
Minimalny zbiór implikantów prostych reprezentujących funkcję f można wyznaczyć obliczając minimalne pokrycie kolumnowe tablicy implikantów prostych. W tym celu tworzymy wyrażenie CNF,
I2 (I1 + I4) (I2 + I3 + I5) (I4 + I5), które po oczywistych uproszczeniach zamieniamy na DNF: I2I4 + I1I2I5
Zatem minimalne pokrycie tworzą implikanty I2, I4. Czyli,
Obliczeniem decydującym o eksplozji kombinatorycznej zadania minimalizacji funkcji boolowskiej jest obliczenie wszystkich pokryć kolumnowych tablicy implikantów prostych. O złożoności tego problemu decyduje szybko rosnąca (ze wzrostem liczby argumentów) liczność rodziny tych implikantów.
Otóż w przypadku funkcji z tablicy 2.21 liczba wszystkich implikantów jest 5: tym samym odpowiednia tablica implikantów (tabl. 2.22) ma 5 kolumn. W rezultacie obliczenie minimalnych pokryć kolumnowych tej tablicy można wykonać „ręcznie” – jest widoczne „gołym okiem”. Ale nie zawsze tak musi być. Zjawisko występującej w tym problemie złożoności obliczeniowej lepiej wyjaśni następny przykład, którego wyniki obliczono programem InstantRS.
Dla funkcji podanej w standardzie typu pla (tabl. 2.23) zbiór implikantów jest następujący:
I1 = !x6!x7
I2 = !x7x8
I3 = x2x3
I4 = x3x4
I5 = x3!x5
I6 = x3x6
I7 = x3!x7
I8 = x3!x8
I9 = x1x4
I10 = x2x4
I11 = x4!x5
I12 = x4x6
I13 = x4!x7
I14 = x4!x8
I15 = x2!x7
I16 = x6x8
I17 = !x1x2
I18 = x2x5
I19 = !x6!x8
Tablica 2.23
. type fr .i 8 .o1 .p12 11000110 0 00000100 0 10101011 0 10000100 0 10001110 0 11000011 0 00011011 0 00000001 1 11110100 1 11010111 1 01001111 1 11000010 1 .e |
zatem do obliczenia wszystkich minimalnych pokryć kolumnowych (tabl. 2.24) trzeba formalnie obliczyć wyrażenie typu DNF dla następującego wyrażenia w postaci CNF:
I19(I1 + I2)(I3 + I4 +…..+ I15)(I9 + I10 + I11 + I12 + I16)(I16 + I17 + I18).
Tablica 2.24
# |
I1 |
I2 |
I3 |
I4 |
I5 |
I6 |
I7 |
I8 |
I9 |
I10 |
I11 |
I12 |
I13 |
I14 |
I15 |
I16 |
I17 |
I18 |
I19 |
c1 |
1 |
1 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
c2 |
0 |
0 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
0 |
0 |
0 |
0 |
c3 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
1 |
1 |
1 |
0 |
0 |
0 |
1 |
0 |
0 |
0 |
c4 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
1 |
1 |
0 |
c5 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
Nie jest to zadanie proste i zawiera minimalne pokrycia kolumnowe reprezentujące 42 rozwiązania, czyli 42 minimalne reprezentacje funkcji z Tabl. 2.23, przykładowo:
01] !x6!x7 + x2x3 + x6x8 + !x6!x8
02] !x6!x7 + x3x4 + x6x8 + !x6!x8
03] !x6!x7 + x3!x5 + x6x8 + !x6!x8
04] !x6!x7 + x3x6 + x6x8 + !x6!x8
05] !x6!x7 + x3!x7 + x6x8 + !x6!x8
06] !x6!x7 + x3!x8 + x6x8 + !x6!x8
………………………………………………….
41] !x7x8 + x4!x5 + x2x5 + !x6!x8
42] !x7x8 + x4x6 + x2x5 + !x6!x8
Można się zatem spodziewać eksplozji kombinatorycznej, której rezultat dla funkcji Kaz podanej w Tabl. 2.25 prowadzi do wniosku, że w tym przypadku liczba wszystkich minimalnych implikantów jest 416, co uniemożliwia systematyczne obliczenie minimalnych wyrażeń boolowskich tej funkcji.
Ograniczenia w stosowaniu systematycznego algorytmu obliczania pokrycia kolumnowego spowodowały potrzebę użycia szybkich, heurystycznych algorytmów redukcji tablic boolowskich. Opracowane zostały dwa algorytmy iteracyjne: MaxCol i MinRow.
Algorytm MaxCol wykorzystuje strategię, w której dla uzyskania minimalnego pokrycia kolumnowego najbardziej istotne są kolumny macierzy, które zawierają największą liczbę jedynek.
Postępowanie w algorytmie MaxCol
- Policzenie wystąpień wartości 1 w każdej kolumnie
- Zapisanie kolumny z największą liczbą 1 – jeżeli jest kilka kolumn o tej samej liczbie 1, arbitralnie wybrana zostaje ta z mniejszym indeksem
- Usunięcie wszystkich wierszy, dla których w wybranej kolumnie znajduje się wartość 1
- Jeżeli macierz nie jest pusta (zawiera elementy), następuje powrót do kroku 1.
- Zwrot zapisanych kolumn
Algorytm MinRow opiera swoje iteracyjne działanie analizowaniu wierszy o najmniejszej ilości jedynek.
Tablica 2.25
.type fr .i 21 .o 1 .p 31 100110010110011111101 1 111011111011110111100 1 001010101000111100000 1 001001101100110110001 1 100110010011011001101 1 100101100100110110011 1 001100100111010011011 1 001101100011011011001 1 110110010011001001101 1 100110110011010010011 1 110011011011010001100 1 010001010000001100111 0 100110101011111110100 0 111001111011110011000 0 101101011100010111100 0 110110000001010100000 0 110110110111100010111 0 110000100011110010001 0 001001000101111101101 0 100100011111100110110 0 100011000110011011110 0 110101000110101100001 0 110110001101101100111 0 010000111001000000001 0 001001100101111110000 0 100100111111001110010 0 000010001110001101101 0 101000010100001110000 0 101000110101010011111 0 |
Kroki algorytmu MinRow
- Policzenie wystąpień wartości 1 w każdym wierszu
- Wybranie wierszy z najmniejszą liczbą wystąpień 1
- Policzenie wystąpień wartości 1 w kolumnach, dla których dowolny wybrany w kroku 2. wiersz ma wartość 1
- Zapisanie kolumny z największą liczbą 1 wśród tych z kroku 3. – jeżeli jest kilka kolumn o tej samej liczbie 1, arbitralnie wybrana zostaje ta z mniejszym indeksem
Strategię MinRow do obliczania minimalnego zbioru implikantów zastosowano w programie Hummingbird. Skuteczność tej strategii potwierdza wynik minimalizacji funkcji Kaz (Tabl. 2.25):
F = x4!x13x21 + x7!x15x16 + !x4!x17!x21
Warto zauważyć, że minimalizacja tej funkcji programem Espresso wcale nie jest lepsza:
F = !x2x14!x19x21 + !x8!x11!x12 + x5x8!x20
4.3. Minimalizacja metodą sekwencyjnego pokrywania
Strategia sekwencyjnego pokrywania zakłada uogólnienie pojedynczej kostki zbioru F, usunięcie kostek pokrytych przez kostkę uogólnioną, a następnie powtórzenie procesu dla pozostałych elementów zbioru F. Pozwala to na wyznaczenie zbioru kostek pokrywających wszystkie kostki zbioru F. Celem etapu uogólniania kostki jest zmniejszenie liczby jej zmiennych tak, aby uzyskana kostka pokrywała jak największą liczbę kostek zbioru F, nie pokrywając przy tym żadnej kostki zbioru R:
- Oblicza się ekspansję kostki k1 (ozn. E(k1)) – tylko jedną.
- Wykreśla się z macierzy F wszystkie wektory pokrywane przez E(k1).
- Powstaje nowa macierz F’, w której bierzemy pierwszą kostkę i postępujemy tak samo,
- Proces kończy się, gdy pokryjemy (wykreślimy) wszystkie kostki F,
Wynik (zminimalizowaną funkcję) tworzą kolejno obliczone ekspansje.
Funkcję boolowską opisaną zbiorami F i R zminimalizować metodą sekwencyjnego pokrywania.
F: |
|
R: |
00000 11000 11010 01110 11100 01011 |
|
11101 00010 00110 10001 01100
|
Rozwiązanie
|
k |
|
|
|
F: |
1 2 3 4 5 6 |
00000 11000 11010 01110 11100 01011 |
R: |
11101 00010 00110 10001 01100
|
Liczymy ekspansję k1.
Ponieważ k1 = (00000), to macierz blokująca B1 jest identyczna z macierzą R.
Wypisujemy w każdym wierszu numery kolumn z jedynkami. Następnie wybieramy taki zbiór, który zapewni minimalne pokrycie kolumnowe. Do pokrycia wybieramy L = {3,4,5}; (x3 x4 x5).
dla k 1=00000 będzie --000:
. Pokryta została także kostka k2
k3 |
11010 |
|
|
|
1 2 3 4 5 |
|
|
R: |
11101 00010 00110 10001 01100 |
|
B3: |
|
00111 11000 11100 01011 10110 |
|
3,4,5
2,4,5
|
Minimalne pokrycie zapewnia L={1,5} (x1 x5)
Kostka k 3+ pokrywa także k 5, do dalszych obliczeń zostają kostki k 4, k 6
k 4 |
01110 |
|
|
|
1 2 3 4 5 |
|
|
R: |
11101 00010 00110 10001 01100 |
|
B4: |
|
10011 01100 01000 11111 00010 |
|
2
4 |
Minimalne pokrycie zapewnia L={2,4}; (x2 x4)
Zbierając wszystkie kostki pokrycia otrzymujemy funkcję minimalną:
Funkcja z przykładu 2.15 zminimalizowana programem InstantRS jest reprezentowana następującymi wyrażeniami:
1] !x1!x2!x4 + x1!x5 + x2x4
2] !x1!x3!x4 + x1!x5 + x2x4
3] !x2!x4!x5 + x1!x5 + x2x4
4] !x3!x4!x5 + x1!x5 + x2x4
Taki sam wynik uzyskamy z programu Hummingbird: f = !x2!x4!x5+x1!x5+x2x4. Nie oznacza to jednak, że strategia sekwencyjnego pokrywania jest tak samo skuteczna jak metoda systematyczna z algorytmem MinRow. Świadczy o tym wynik minimalizacji funkcji Kaz, obliczonej programem Blink. Blink reprezentuje dane wyjściowe w postaci tzw. Reguł decyzyjnych omawianych w rozdziale 5. Reguły te – dla funkcji Kaz – są następujące:
(x3=0) & (x4=1) & (x18=1) => (y=1)
(x2=1) & (x3=1) & (x5=1) => (y=1)
(x1=0) & (x3=1) & (x5=1) => (y=1)
(x1=0) & (x6=1) & (x9=1) => (y=1)
(x3=0) & (x6=1) & (x15=0) => (y=1)
(x1=0) & (x3=1) & (x13=0) => (y=1)
(x2=0) & (x5=1) & (x8=1) => (y=1)
Oczywiście możemy te reguły zapisać sumy iloczynów zmiennych boolowskich:
!x3x4x18 + x2x3x5 + !x1x3x5 + !x1x6x9 + !x3x6!x15 + !x1x3!x13 + !x2x5x8
Natomiast Kaz zminimalizowany programem Hummingbird jest wyrażeniem:
f = x4!x13x21 + x7!x15x16 + !x4!x17!x21
nieco prostszym od wyrażenia uzyskanego programem Espresso:
y1 = !x2x14!x19x21 + !x8!x11!x12 + x5x8!x20
5. Uzupełnienie (Complement)
Zadaniem procedury COMPLEMENT (uzupełnienie) jest obliczenie zbioru D, tj. zbioru wszystkich nieokreśloności funkcji opisanej zbiorami F i R. Zbiór ten jest wykorzystywany między innymi w procedurze pokrycia, a jego zwarta specyfikacja jest bardzo istotna z punktu widzenia złożoności obliczeń. Potrzebę obliczania D wyjaśnia dobrze przykład funkcji boolowskiej o 30 argumentach, opisanej tablicą prawdy o 200 wierszach (wektorach). Otóż zbiór wszystkich nieokreśloności takiej funkcji ma liczność 230 – 200, a więc bezpośrednia specyfikacja odpowiedniego D staje się niemal nierealna.
Procedura uzupełniania polega na iteracyjnym rozkładzie zbioru kostek reprezentującego funkcję f na kofaktory. Kofaktory te są obliczane tak długo, aż odpowiadające im zbiory kostek staną się „łatwe” do obliczenia ich uzupełnienia. Proces kończy „scalanie” wyników cząstkowych. Podstawą takiego postępowania jest spostrzeżenie, że uzupełnienie funkcji reprezentowanej rozkładem Shannona:
można wyznaczyć obliczając najpierw ko faktory oraz
, a następnie ich uzupełnienie, czyli [1]:
Zatem powstaje w wyniku „scalenia” wyników cząstkowych, tj.
oraz
.
W przypadku, gdy wynikiem rozkładu Shannona jest jednorodny zbiór kostek, obliczenia przejmuje procedura UNATE_COMPLEMENT, spełniająca rolę procedury wyznaczającej uzupełnienie funkcji jednorodnej. Wynika to z faktu, że dla funkcji monotonicznych, a w szczególności dla:
a) monotonicznie rosnącej w punkcie xj,
b) monotonicznie malejącej w punkcie xj,
uzupełnienie (2-4) upraszcza się do następujących wzorów [1]:
Łatwo to wykazać, gdyż na przykład dla (5-6a) mamy, że a więc, korzystając z implikacji
, uzyskujemy:
czyli:
Obliczenie uzupełnienia funkcji jednorodnej rozpoczynamy od wyznaczania zero-jedynkowej macierzy M funkcji jednorodnej danej macierzy F.
Przeliczenie macierzy F na macierz M przeprowadzamy według następujacego schematu:
M[i, j] = 0, jeżeli F[i, j] = *,
M[i, j] = 1, jeżeli F[i, j] = 1 lub F[i, j] = 0.
Transformacja taka jest jednoznaczna, gdyż macierz F z założenia jest jednorodna (w żadnej z jej kolumn nie występują jednocześnie zera i jedynki). Następnie wyliczany jest wektor V, w którym „zapamiętuje się” polaryzacje zmiennych występujące w każdej kolumnie. Na przykład, zakładając macierz F o postaci:
otrzymamy macierz:
Otrzymaną macierz M będziemy rozkładać rekursywnie (stosując rozkład Shannona), aż do wystąpienia szczególnych postaci uzyskanych kofaktorów.
Obliczenie kofaktorów otrzymanej macierzy M rozpoczynamy od wyboru zmiennej do rozkładu. Odpowiedni wybór zmiennej ma istotne znaczenie dla redukcji obliczeń. Wybór zmiennej przeprowadzamy według następującego algorytmu:
1) wybieramy kostkę (wiersz macierzy M) z największą liczbą zer,
2) w wybranej kostce wybieramy zmienne, które mają jedynkę w tej kostce,
3) spośród wybranych w punkcie 2) zmiennych wybieramy tę, która ma najwięcej jedynek w swojej kolumnie.
Postępowanie to uzasadniamy następująco. Otóż obliczenie kofaktora powoduje ustawienie na zero kolumny odpowiadającej wybranej zmiennej. Zatem wybranie zmiennej według powyższego algorytmu i obliczenie kofaktora ustawi na zero kolumny, które mają największą liczbę jedynek (p. 3). Ułatwi to uzyskanie sytuacji, w której w kofaktorze będzie wiersz samych zer (p. 1), odpowiadający tautologii.
Kofaktory macierzy M obliczamy według następującego schematu.
Kofaktor jedynkowy macierzy M względem zmiennej xj otrzymujemy przez ustawienie wszystkich pozycji j-tej kolumny macierzy M na zera. Inaczej mówiąc, kofaktor jedynkowy jest przepisaniem macierzy M z „ustawieniem j-tej kolumny na zero”.
Kofaktor zerowy macierzy M względem zmiennej xj otrzymujemy przez wypisanie z M tych kostek (wierszy), w których zmienna xj przyjmuje wartość zero.
Powyższy sposób obliczania kofaktorów jest bezpośrednią konsekwencją definicji kofaktora [2.8].
Na przykład dla macierzy M:
wybór zmiennej x3 prowadzi do kofaktorów:
Następnym etapem obliczeń jest próba uzupełnienia otrzymanych kofaktorów. W szczególności, jeżeli którykolwiek z kofaktorów zawiera wiersz samych zer, to należy go usunąć, gdyż uzupełnienie takiego kofaktora jest zbiorem pustym.
Proces rozkładu na kofaktory prowadzimy rekursywnie, tzn. otrzymane kofaktory rozkładamy według tej samej zasady, aż do uzyskania kofaktorów, które zawierają tylko jedną kostkę (wiersz). Warto dodać, że jeżeli na którymś z poziomów rekursji w kolumnie odpowiadającej wybranej zmiennej są tylko jedynki, to kofaktor zerowy takiej macierzy jest pusty.
Dla zilustrowania metody rozważmy przykład jednorodnej funkcji F danej następującą macierzą:
Obliczamy macierz M:
Następnie przeprowadzamy rozkład jak na rys. 2.13. Rozkład jest tu realizowany kolejno według zmiennych xi, tworząc odpowiednie wyniki rozkładu; z lewej strony zapisujemy wynik dla zmiennej xi w postaci prostej, a z prawej dla tej zmiennej w postaci zanegowanej. Wybór zmiennej do rozkładu jest dokonywany według poprzednio podanej zasady: wybieramy wiersz z największą liczbą zer, a spośród kolumn wskazywanych (w tym wierszu) jedynką, wybieramy kolumnę z największą liczbą jedynek. Dlatego do pierwszego rozkładu wybieramy x4 (drugi wiersz, czwarta kolumna w macierzy M).
Możliwe są również inne wybory. Kofaktor dla x4 powstaje przez zamianę wszystkich pozycji kolumny czwartej na zera. Kofaktor dla powstaje przez wypisanie wierszy, które w czwartej kolumnie mają zera. Przechodząc do następnego rozkładu wykreślamy powtarzające się wiersze i wyznaczamy nową zmienną. W tym przypadku będzie to x3 (może być również x1). Decydując się na x3 uzyskujemy odpowiednie macierze: dla x3 jest to macierz z wierszem samych 0, czyli tautologia; a więc kończy to rozkład w tej gałęzi. Dla
musimy rozkładać dalej, względem zmiennej x1. Rezultatem rozkładu jest macierz reprezentująca tautologię (gałąź x1) i macierz reprezentująca pusty zbiór kostek, czyli f.
Podstawą uzupełnienia funkcji jednorodnej jest rozszczepianie macierzy M na podzbiory kostek, których uzupełnienie łatwo można obliczyć. Taką postacią jest kofaktor o jednym wierszu. Uzupełnienie takiego kofaktora (w notacji M) oblicza się według następujących zasad:
1) jeżeli kofaktor zawiera tylko jedną jedynkę, jego uzupełnienie jest identyczne jak ko faktor;
2) jeżeli kofaktor zawiera więcej niż jedną jedynkę, jego uzupełnienie zawiera tyle kostek (wierszy), ile jest jedynek w kofaktorze, przy czym wszystkie wiersze mają jedynkę (pozostałe pozycje zera) na pozycjach odpowiadających kolejnym jedynkom kofaktora.
Stosując te zasady do kofaktora uzyskanego dla :
uzyskujemy:
Uzasadnienie tego zapisu wynika bezpośrednio z prawa De Morgana. Również oczywiste jest uzupełnienie zbioru pustego, który powstał na drodze ; jest nim tautologia.
Rys. 2.13. Rozkład funkcji F z przykładu 2.16
Po obliczeniu uzupełnień na poszczególnych „piętrach” rozkładu możemy przystąpić do scalania poszczególnych wyników. Scalanie przeprowadzamy zgodnie z przetransformowanym do notacji M wzorem (2-5):
F = xj × F0 + F1.
Znaczy to, że jeżeli otrzymany kofaktor był zerowy (ozn. F0), to mnożymy go przez odpowiednie xj i dodajemy, a jeżeli był jedynkowy (ozn. F1), to tylko dodajemy. Czyli (dla ):
oraz dla ; kolejne obliczenia są następujące:
[ 1 0 0 0 ] + f
[ 1 0 0 0 ] · [ 0 0 1 0 ] = 1 0 1 0.
Ostatni wynik należy dodać do wyniku uzyskanego dla ):, czyli:
Łącząc wreszcie wyniki cząstkowe, uzyskujemy , która po transformacji według wektora v prowadzi do
:
Otrzymana macierz jest uzupełnieniem jednorodnej funkcji F. W ten sposób, mając funkcję rozłożoną na funkcje jednorodne, łatwo można obliczyć uzupełnienie każdej z nich.
6. Redukcja argumentów
Redukcja argumentów
6.1. Metoda klasyczna
Z praktycznego punktu widzenia istotne są takie realizacje funkcji boolowskich, w których argumenty , stanowią podzbiór zbioru
, gdyż uzyskuje się wtedy bezpośrednio realizację n-argumentowej funkcji f w układzie kombinacyjnym o t wejściach (t < n), co ma znaczenie w syntezie na typowych modułach PLD i w strukturach FPGA. Istotne jest również to, że (przy dużych n) zmniejszenie liczby argumentów z n do t upraszcza ewentualnie dalsze zabiegi optymalizacyjne, gdyż zmniejsza wymiary zadań dla procesu minimalizacji i dekompozycji. W szczególności redukcja argumentów stanowi podstawę dekompozycji równoległej, którą omówimy pod koniec niniejszego rozdziału.
Realizację funkcji f = f(x1,...,xn) taką, że:
nazywać będziemy minimalno-argumentową realizacją funkcji f wtedy i tylko wtedy, gdy nie istnieje zbiór zmiennych:
Niech a Î Bn, b Î Bn. Utwórzmy dla wektorów a,b wyrażenie boolowskie:
gdzie sumowanie jest po wszystkich i takich, że ai ¹ bi. Inaczej mówiąc, xi jest składnikiem
d(a,b) tylko wtedy, gdy wektory a oraz b mają różne składowe ai,bi. Reprezentacją argumentową funkcji f (oznaczaną dalej przez RAf) nazywać będziemy wyrażenie boolowskie:
gdzie iloczyn logiczny Ù jest brany po wszystkich parach a,b : f(a) ¹ f(b).
Można wykazać, że dla każdego rozwiązania równania RAf = 1:
istnieje funkcja h o argumentach , dla której
Dla dowodu powyższego wystarczy zauważyć, że jeżeli ,to dla każdej pary wektorów a,b : f(a) ¹ f(b), wektory
oraz
różnią się co najmniej jedną składową.
Jeżeli zbiór zmiennych ,spełniających równanie (2-7) jest zbiorem o możliwie najmniejszej liczności, to funkcja h jest nazywana minimalno-argumentową realizacją funkcji f [1].
Z konstrukcji wyrażenia RAf wynika, że jest to koniunkcja czynników o postaci . Rozwiązanie równania RAf = 1 jest więc typowym problemem pokrycia, a odpowiednie obliczenia można uprościć wykorzystując pojęcie elementu zasadniczego, którego rolę w redukcji argumentów spełniać będzie omówione dalej pojęcie zmiennej niezbędnej.
Rozważmy funkcję f z tablicy 2.26a. Postaramy się zmniejszyć liczbę argumentów tej funkcji usuwając z niej po jednej zmiennej. Usuwając z tablicy 2.26a kolumnę odpowiadającą zmiennej x4 uzyskujemy tablicę, w której dwa wiersze, o numerach 2 i 8, (tabl. 2.26b) są identyczne, ale wierszom tym odpowiadają różne wartości funkcji. Tablica jest więc sprzeczna. Stąd wniosek, że argumentu x4 usunąć nie można.
Tablica 2.26
|
a) |
|
b) |
|
|
|
|
|
|
|
|
c) |
|
|
|
|
|
|||||||
|
x1 |
x2 |
x3 |
x4 |
x5 |
x6 |
x7 |
f |
|
|
x1 |
x2 |
x3 |
x5 |
x6 |
x7 |
f |
|
|
x2 |
x4 |
x6 |
x7 |
f |
1 |
1 |
0 |
0 |
0 |
1 |
0 |
1 |
0 |
|
1 |
1 |
0 |
0 |
1 |
0 |
1 |
0 |
|
1 |
0 |
0 |
0 |
1 |
0 |
2 |
1 |
0 |
1 |
1 |
1 |
1 |
0 |
0 |
|
2 |
1 |
0 |
1 |
1 |
1 |
0 |
0 |
|
2 |
0 |
1 |
1 |
0 |
0 |
3 |
1 |
1 |
0 |
1 |
1 |
1 |
0 |
0 |
|
3 |
1 |
1 |
0 |
1 |
1 |
0 |
0 |
|
3 |
1 |
1 |
1 |
0 |
0 |
4 |
1 |
1 |
1 |
0 |
1 |
1 |
1 |
0 |
|
4 |
1 |
1 |
1 |
1 |
1 |
1 |
0 |
|
4 |
1 |
0 |
1 |
1 |
0 |
5 |
0 |
1 |
0 |
0 |
1 |
0 |
1 |
1 |
|
5 |
0 |
1 |
0 |
1 |
0 |
1 |
1 |
|
5 |
1 |
0 |
0 |
1 |
1 |
6 |
1 |
0 |
0 |
0 |
1 |
1 |
0 |
1 |
|
6 |
1 |
0 |
0 |
1 |
1 |
0 |
1 |
|
6 |
0 |
0 |
1 |
0 |
1 |
7 |
1 |
0 |
1 |
0 |
0 |
0 |
0 |
1 |
|
7 |
1 |
0 |
1 |
0 |
0 |
0 |
1 |
|
7 |
0 |
0 |
0 |
0 |
1 |
8 |
1 |
0 |
1 |
0 |
1 |
1 |
0 |
1 |
|
8 |
1 |
0 |
1 |
1 |
1 |
0 |
1 |
|
8 |
0 |
0 |
1 |
0 |
1 |
9 |
1 |
1 |
1 |
0 |
1 |
0 |
1 |
1 |
|
9 |
1 |
1 |
1 |
1 |
0 |
1 |
1 |
|
9 |
1 |
0 |
0 |
1 |
1 |
Natomiast usuwając z tablicy 2.26a zmienną x3 uzyskujemy tablicę, w której wszystkie wiersze są różne.
Można nawet usunąć jeszcze zmienne x1 i x5 (tabl. 2.26c), a łączny rezultat tych usunięć nie spowoduje pojawienia się sprzeczności. Spostrzeżenie powyższe prowadzi do następującej definicji.
Oznaczmy przez Tf (X – {<i>x<sub>i</sub></i>}) tablicę specyfikacji funkcji f uzyskaną z Tf przez usunięcie kolumny xi, gdzie Tf jest tablicą funkcji f.
Zmienną xi nazywamy zmienną niezbędną [2.6], jeżeli tablica specyfikacji Tf (X – {<i>x<sub>i</sub></i>}) jest sprzeczna.
Zmiennymi niezbędnymi funkcji f z tablicy 2.26a są x4 oraz x6, gdyż tablice Tf (X – {<i>x</i><sub>4</sub>}), Tf (X – {<i>x</i><sub>6</sub>}) są sprzeczne.
Można wykazać, że zmienna xi jest zmienną niezbędną funkcji f(x1,...,xn), jeśli istnieją wektory a, b: f(a) ¹ f(b) takie, że ai ¹ bi oraz aj = bj dla każdego j ¹ i.
Przyjmując do opisu funkcji f: Bn ® {0,1,–} podziały na zbiorze K ponumerowanych wektorów z Bn, możemy podane wyżej spostrzeżenia wyrazić analitycznie. Oznaczmy przez P(xi) podział na K realizowany zmienną xi, a przez Pf, podział wyjściowy funkcji f. Wtedy warunek na minimalno-argumentową realizację funkcji f można sprawdzić za pomocą nierówności:
Obliczymy wszystkie realizacje minimalno-argumentowe funkcji f = f(x1,...,x7), której tablica prawdy podana jest w tabl. 2.26a, z odpowiednią numeracją wektorów.
Wektory prawdziwe i fałszywe tej funkcji ponumerowano liczbami naturalnymi 1,...,9, czyli K = {1,...,9}. Mamy wtedy (przy oznaczeniach P(xi) = Pi) następujące podziały na K:
Jak już stwierdziliśmy, zmiennymi niezbędnymi tej funkcji są x4, x6. Dlatego najpierw wyznaczymy iloczyn P = P4×P6:
Blokami iloczynu P = (B1,...,B3) są B1 = {1,5,7,9}, B2 = {4,6,8}, B3 = {2,3}. W dalszych obliczeniach pomijamy blok B3, gdyż B3 jest zawarty w jednym bloku podziału Pf.
Kolejną czynnością jest obliczenie podziału ilorazowego P4×P6| Pf :
Obliczony podział ilorazowy pozwala wyznaczyć czynniki wyrażenia boolowskiego RAf. Wyznaczane są one dla każdej pary mintermów p,q, takiej, że p i q należą do jednego bloku iloczynu P4 × P6, ale do różnych bloków podziału Pf, co łatwo odczytać z podziału ilorazowego biorąc pary p,q z różnych elementów tego podziału. Przez elementy rozumiemy tu podzbiory ograniczone różnymi nawiasami. Dla każdej tak wyznaczonej pary p,q sprawdzamy na jakich pozycjach, czyli dla jakich zmiennych różnią się odpowiadające im wektory w tablicy prawdy. Na przykład, dla pary p = 1, q = 5 mamy, że odpowiednie wektory w tablicy prawdy funkcji f (tabl. 4.17a) różnią się na pozycjach x1, x2, a więc odpowiadający tej parze czynnik RA będzie C1 = x1 Ú x2. Zestawienie zmiennych, dla których różnią się pary p,q nazywać będziemy tablicą porównań. Odczytując z podziału ilorazowego (2-8) pary p,q otrzymujemy następująca listę porównań:
Redukując w zbiorach C każde Ci, dla którego istnieje , otrzymujemy równanie RA = 1 o postaci:
które przekształcamy do postaci sumo-iloczynowej:
x2x3 + x2x5 +x2x7 + x1x3x7
Na tej podstawie wyznaczamy minimalne rozwiązania o najmniejszej liczności: {<i>x</i><sub>2</sub>, <i>x</i><sub>3</sub>,<i> x</i><sub>4</sub>, <i>x</i><sub>6</sub>}, {<i>x</i><sub>2</sub>, <i>x</i><sub>4</sub>,<i> x</i><sub>5</sub>, <i>x</i><sub>6</sub>}, {<i>x</i><sub>2</sub>, <i>x</i><sub>4</sub>,<i> x</i><sub>6</sub>, <i>x</i><sub>7</sub>}. Stąd wniosek, że siedmioargumentowa funkcja f w rzeczywistości jest zależna wyłącznie od czterech argumentów. Zauważmy też, że ostatnie z podanych rozwiązań oznacza usunięcie z tablicy funkcji f kolumn odpowiadających zmiennym x1, x3, x5. Sytuacja taka była już prezentowana w tablicy 2.26c.
Skuteczność redukcji argumentów, a także jej wpływ na inne procedury logicznej pokażemy na bardziej skomplikowanym przykładzie.
Dla funkcji F podanej w tablicy 2.27 obliczyć wszystkie minimalne zbiory argumentów, od których ta funkcja zależy. Zmienne niezbędne tej funkcji to: x1, x3, x7.
Tablica 2.27
|
x1 |
x2 |
x3 |
x4 |
x5 |
x6 |
x7 |
x8 |
x9 |
y1 |
y2 |
1 |
0 |
0 |
0 |
1 |
0 |
0 |
1 |
1 |
0 |
0 |
1 |
2 |
0 |
1 |
1 |
0 |
0 |
0 |
0 |
1 |
0 |
0 |
1 |
3 |
1 |
1 |
1 |
0 |
1 |
1 |
0 |
0 |
0 |
1 |
0 |
4 |
0 |
1 |
0 |
0 |
0 |
1 |
1 |
0 |
1 |
0 |
0 |
5 |
0 |
0 |
1 |
0 |
1 |
1 |
1 |
0 |
0 |
0 |
1 |
6 |
0 |
1 |
1 |
0 |
0 |
0 |
1 |
1 |
0 |
0 |
0 |
7 |
0 |
1 |
1 |
0 |
1 |
1 |
0 |
1 |
1 |
1 |
1 |
8 |
0 |
0 |
0 |
1 |
0 |
0 |
1 |
0 |
1 |
1 |
1 |
9 |
1 |
1 |
1 |
0 |
0 |
0 |
1 |
1 |
0 |
1 |
0 |
10 |
0 |
0 |
1 |
1 |
0 |
0 |
1 |
0 |
1 |
1 |
0 |
W bardziej skomplikowanych przykładach można zaobserwować wpływ redukcji argumentów na proces realizacji funkcji w postaci minimalnych wyrażeń boolowskich. Na przykład dla funkcji TL27 z tabl. 2.28 można obliczyć następujące redukty.
R1 = {<i>x</i><sub>1</sub>,<i> x</i><sub>2</sub>,<i> x</i><sub>4</sub>,<i> x</i><sub>5</sub>,<i> x</i><sub>6</sub>,<i> x</i><sub>7</sub>,<i> x</i><sub>10</sub>}
R2 = {<i>x</i><sub>1</sub>,<i> x</i><sub>2</sub>,<i> x</i><sub>4</sub>,<i> x</i><sub>6</sub>,<i> x</i><sub>7</sub>,<i> x</i><sub>8</sub>,<i> x</i><sub>10</sub>}
R3 = {<i>x</i><sub>1</sub>,<i> x</i><sub>2</sub>,<i> x</i><sub>4</sub>,<i> x</i><sub>6</sub>,<i> x</i><sub>7</sub>,<i> x</i><sub>9</sub>,<i> x</i><sub>10</sub>}
R4 = {<i>x</i><sub>1</sub>,<i> x</i><sub>4</sub>,<i> x</i><sub>5</sub>,<i> x</i><sub>6</sub>,<i> x</i><sub>7</sub>,<i> x</i></span><sub><span lang="PT-BR" style="line-height:150%">9</span></sub><span lang="PT-BR" style="line-height:150%">,<i> x</i><sub>10</sub>}
R5 = {<i>x</i><sub>1</sub>,<i> x</i><sub>4</sub>,<i> x</i><sub>6</sub>,<i> x</i><sub>7</sub>,<i> x</i><sub>8</sub>,<i> x</i><sub>9</sub>,<i> x</i><sub>10</sub>}
R6 = {<i>x</i><sub>1</sub>,<i> x</i><sub>5</sub>,<i> x</i><sub>6</sub>,<i> x</i><sub>7</sub>,<i> x</i><sub>8</sub>,<i> x</i><sub>9</sub>,<i> x</i><sub>10</sub>}
R7 = {<i>x</i><sub>2</sub>,<i> x</i><sub>3</sub>,<i> x</i><sub>4</sub>,<i> x</i><sub>5</sub>,<i> x</i><sub>6</sub>,<i> x</i><sub>7</sub>,<i> x</i><sub>10</sub>}
R8 = {<i>x</i><sub>2</sub>,<i> x</i><sub>3</sub>,<i> x</i><sub>5</sub>,<i> x</i><sub>6</sub>,<i> x</i><sub>7</sub>,<i> x</i><sub>8</sub>,<i> x</i><sub>10</sub>}
R9 = {<i>x</i><sub>3</sub>,<i> x</i><sub>4</sub>,<i> x</i><sub>5</sub>,<i> x</i><sub>6</sub>,<i> x</i><sub>7</sub>,<i> x</i><sub>9</sub>,<i> x</i><sub>10</sub>}
R10 = {<i>x</i><sub>3</sub>,<i> x</i><sub>5</sub>,<i> x</i><sub>6</sub>,<i> x</i><sub>7</sub>,<i> x</i><sub>8</sub>,<i> x</i><sub>9</sub>,<i> x</i><sub>10</sub>}
Tablica 2.28
|
x1 |
x2 |
x3 |
x4 |
x5 |
x6 |
x7 |
x8 |
x9 |
x10 |
y |
1 |
0 |
0 |
1 |
0 |
1 |
1 |
1 |
0 |
1 |
0 |
0 |
2 |
1 |
0 |
1 |
0 |
0 |
1 |
0 |
1 |
0 |
0 |
0 |
3 |
0 |
1 |
0 |
0 |
0 |
1 |
1 |
1 |
1 |
0 |
0 |
4 |
1 |
0 |
1 |
1 |
1 |
0 |
1 |
0 |
1 |
1 |
0 |
5 |
1 |
1 |
0 |
0 |
0 |
1 |
0 |
0 |
1 |
1 |
0 |
6 |
0 |
1 |
0 |
0 |
0 |
1 |
0 |
1 |
1 |
0 |
0 |
7 |
1 |
1 |
1 |
0 |
1 |
0 |
0 |
1 |
1 |
0 |
0 |
8 |
0 |
1 |
0 |
0 |
1 |
1 |
0 |
0 |
0 |
0 |
0 |
9 |
0 |
1 |
0 |
1 |
0 |
0 |
0 |
0 |
1 |
0 |
0 |
10 |
0 |
1 |
1 |
1 |
1 |
1 |
1 |
0 |
1 |
1 |
1 |
11 |
0 |
0 |
0 |
0 |
0 |
1 |
0 |
1 |
0 |
0 |
1 |
12 |
1 |
1 |
0 |
1 |
1 |
1 |
0 |
0 |
1 |
1 |
1 |
13 |
0 |
1 |
0 |
0 |
1 |
0 |
0 |
0 |
0 |
0 |
1 |
14 |
0 |
1 |
0 |
0 |
0 |
1 |
1 |
1 |
1 |
1 |
1 |
15 |
0 |
0 |
1 |
0 |
0 |
0 |
0 |
1 |
1 |
0 |
1 |
16 |
1 |
1 |
1 |
1 |
0 |
1 |
0 |
0 |
0 |
1 |
1 |
17 |
1 |
1 |
1 |
1 |
1 |
0 |
1 |
0 |
0 |
1 |
1 |
18 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
19 |
0 |
0 |
1 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
20 |
1 |
1 |
0 |
1 |
1 |
0 |
0 |
1 |
1 |
1 |
1 |
21 |
0 |
0 |
1 |
0 |
0 |
0 |
1 |
1 |
1 |
1 |
1 |
22 |
1 |
1 |
1 |
1 |
1 |
0 |
0 |
0 |
1 |
0 |
1 |
23 |
1 |
0 |
1 |
0 |
1 |
1 |
1 |
1 |
0 |
1 |
1 |
24 |
0 |
1 |
1 |
0 |
0 |
0 |
0 |
1 |
1 |
0 |
1 |
25 |
0 |
1 |
0 |
0 |
1 |
1 |
1 |
0 |
0 |
0 |
1 |
Wybierając jeden z tych zbiorów (np. R3) możemy dla zredukowanej w ten sposób funkcji zastosować inne procedury optymalizacji np. minimalizację. Uzyskamy wtedy następujące wyrażenie:
Warto podkreślić, że rozwiązanie wyznaczone za pomocą programu ESPRESSO [2.1] prowadzi do wyrażenia
zawierającego 9 argumentów. Jak widać, nie prowadzi ono do realizacji minimalno-argumentowej. Jeśli jednak procedurę minimalizacji zastosujemy do funkcji o zredukowanych argumentach, to uzyskamy wyrażenie o mniejszej liczbie składników iloczynowych.
[1] Zbiór Xt jest również nazywany reduktem [2.10].
6.2. Redukcja argumentów metodą uzupełniania
Wyjątkowo skuteczna w redukcji argumentów okazała się metoda zaproponowana w [2.6], w której klasyczne rozwiązanie problemu transformacji CNF na DNF zostało zredukowane do obliczenia uzupełnienia CNF tej funkcji, gdzie uzupełnienie redukuje się do obliczenia pokrycia kolumnowego macierzy binarnej [??]. Zaproponowane podejście bardzo przyspiesza obliczenia, a wydajna reprezentacja algorytmu w pamięci operacyjnej maszyny obliczeniowej pozwala na osiągnięcie wyników, które nie mogą być osiągnięte przy użyciu innych publikowanych metod i systemów [2.1]. Z tych powodów, jak też ze względu na niezbędność stosowania algorytmu redukcji w realizacjach sprzętowych układów dystrybucji adresów IP, skanowania wirusów, itp., wykonano praktycznie użyteczne oprogramowanie Lightning, wykorzystujące zasadę uzupełniania. Zasadę tę wyjaśnimy posługując się funkcją z Przykładu 2.17 (tabl. 2.26a).
Obliczoną w Przykładzie 2.17 zredukowaną tablicę porównań:
Obliczanie uzupełnienia funkcji jednorodnej polega na rozkładzie macierzy M na podzbiory kostek, których uzupełnienie można łatwo obliczyć. Taką postacią jest kofaktor o jednym wierszu. Uzupełnienie takiego kofaktora oblicza się według następujących zasad:
- Jeżeli kofaktor zawiera tylko jedną jedynkę, jego uzupełnienie jest identyczne jak kofaktor.
- Jeżeli kofaktor zawiera więcej niż jedną jedynkę, jego uzupełnienie zawiera tyle kostek (wierszy), ile jest jedynek w kofaktorze, przy czym wszystkie wiersze uzupełnienia mają jedynkę tylko na pozycjach odpowiadających kolejnym jedynkom kofaktora. Takie postępowanie wynika z prawa de Morgana. Przykładowo, dla kofaktora [0 0 1 0 1 0 1] uzupełnieniem będzie macierz:
- Jeżeli kofaktor zawiera wiersz samych zer (tautologia), to jego uzupełnieniem jest zbiór pusty.
- Jeżeli ko faktor jest zbiorem pustym, to jego uzupełnieniem jest wiersz samych zer (tautologia).
Po obliczeniu uzupełnień na poszczególnych poziomach rozkładu należy scalić wyniki cząstkowe zgodnie ze wzorem:
Realizowany według powyższych zasad rozkład macierzy M podany jest na rys. 2.14 (linia ciągła). Linią przerywaną oznaczono kolejne etapy scalania wyników dopełnienia.
Rys. 2.14. Przykład obliczania uzupełnienia funkcji monotonicznej
Na rys. 2.14 podano również wyniki scalania macierzy cząstkowych uzyskanych na poszczególnych etapach:
C7 = x7 [0 0 1 0 0 0 0] + Æ = [0 0 1 0 0 0 1]
C1 = x1 [0 0 1 0 0 0 1] + Æ = [1 0 1 0 0 0 1]
Macierz uzyskana na najwyższym piętrze rozkładu, która została utworzona ze scalenia macierzy cząstkowych dla zmiennej x2, reprezentuje – pozycją jedynek w poszczególnych wierszach – redukty funkcji z Przykładu 2.19. Obliczone uzupełnienie należy interpretować w następujący sposób: jedynka w j-tej kolumnie oznacza, że minimalny redukt uwzględnia zmienną xj. Do uzupełnienia należy dodać zmienne niezbędne x4 oraz x6. Minimalne redukty funkcji F są następujące i takie same jak w rozwiązaniu metodą klasyczną.
{<i>x</i><sub>2</sub>,<i>x</i><sub>3</sub>,<i>x</i><sub>4</sub>,<i>x</i><sub>6</sub>}
{<i>x</i><sub>2</sub>,<i>x</i><sub>4</sub>,<i>x</i><sub>5</sub>,<i>x</i><sub>6</sub>}
{<i>x</i><sub>2</sub>,<i>x</i><sub>4</sub>,<i>x</i><sub>6</sub>,<i>x</i><sub>7</sub>}
{<i>x</i><sub>1</sub>,<i>x</i><sub>3</sub>,<i>x</i><sub>4</sub>,<i>x</i><sub>6</sub>,<i>x</i><sub>7</sub>}
Redukcja argumentów oraz dekompozycja, to – zgodnie z opinią prof. Sasao wyrażoną w referacie [2.14] prezentowanym na konferencji EPFL Workshop on Logic Synthesis & Verification, Dec. 2015 – jedno z najpilniejszych zadań syntezy logicznej.
W przypadku implementacji funkcji boolowskich w układach FPGA (Field Progammable Gate Array) redukcja argumentów, umożliwia realizację funkcji w układzie kombinacyjnym o mniejszej liczbie wejść. Jest to szczególnie istotne dla struktur FPGA z wbudowanymi pamięciami, dla których liczba zmiennych wejściowych jest głównym czynnikiem decydującym o złożoności implementacji. Jeszcze większe znaczenie redukcji argumentów dotyczy syntezy funkcji generowania indeksów. Funkcje generowania indeksów to silnie nieokreślone funkcje boolowskie:
f : Dn ® {1,2,…,<i>k</i>}, gdzie Dn Í {0,1}n , oraz |Dn| = k.
Wektory należące do zbioru Dn nazywa się wektorami rejestrowanymi. Cechą charakterystyczną tych funkcji jest duża liczba zmiennych wejściowych, przy stosunkowo małej liczności zbioru Dn . Konsekwencją tej własności jest skuteczne redukowanie zmiennych wejściowych, umożliwiające realizację generatora indeksów w strukturze zaproponowanej przez Sasao (rys. 2.15). W tak zbudowanym generatorze indeksów wyróżnia się dwie pamięci: pamięć główną i pamięć pomocniczą, komparator i bramę AND.
Rys. 2.15. Generator indeksów
Blok selekcji zmiennych wybiera spośród wszystkich zmiennych podzbiór X1, reprezentujący minimalną liczbę zmiennych (tzw. redukt) realizowanej Funkcji Generowania Indeksów (FGI). Liczność reduktu jest r. Jest to jednocześnie liczba wejść do pamięci głównej. Na wyjściach pamięci głównej pojawia się indeks wektora wejściowego X = X1 + X2. Jest on reprezentowany wektorem binarnym o liczbie bitów . Indeks ten jest poprawnym indeksem wektora wejściowego wtedy, jeżeli jest to wektor rejestrowany. I tylko wtedy indeks ten pojawi się na wyjściach generatora. W przypadku, gdy wektor wejściowy nie jest wektorem rejestrowanym na wyjściach generator pojawi się 0. Sprawdzenie, czy wyjścia pamięci głównej reprezentują poprawny indeks jest realizowane w pamięci pomocniczej i komparatorze. W pamięci pomocniczej są zapisane wektory reprezentowane zmiennymi należącymi do zbioru X2. Wektory te są podawane na wejście komparatora i porównywane z rzeczywistym wektorem X2 podawanym na drugie wejście komparatora. Oczywiście wektor pobrany z pamięci pomocniczej będzie różny od rzeczywistego wektora X2 w przypadku, gdy nie należy on do wektora rejestrowanego. Wtedy komparator sygnałem wyjściowym o 0 zablokuje pojawienie się na wyjściach bramy AND wektora wytworzonego w pamięci głównej.
Działanie tak skonstruowanego generatora indeksów można zaprezentować na przykładzie funkcji generowania indeksów analizowanej w referacie Sasao – tab. 2.29a. Dla funkcji tej wyznaczono 5-argumentowy redukt – tab. 2.29b.
Tablica 2.29
a) |
|
|
b) |
|
c) |
0110000100010000101001100001000100001010 |
1 |
|
01100 |
|
0000 |
0101111101101010001101011111011010100011 |
2 |
|
01011 |
|
1011 |
1111010101110111000011110101011101110001 |
3 |
|
11110 |
|
1111 |
0001111000010001011100011110000100010111 |
4 |
|
00011 |
|
1110 |
0011110000000100010100111100000001000101 |
5 |
|
00111 |
|
1010 |
0111001001000100100101110010010001001001 |
6 |
|
01110 |
|
0010 |
0010001110001111001000100011100011110010 |
7 |
|
00100 |
|
0100 |
1111111111010001111000100011100011110010 |
8 |
|
11111 |
|
1100 |
1110111000110001011011101110001100010110 |
9 |
|
11101 |
|
1101 |
1010000110100100001110100001101001000011 |
10 |
|
10100 |
|
0001 |
Nietrudno zauważyć, że o skuteczności tak skonstruowanego generatora indeksów decyduje skuteczność obliczania reduktów. Stosując program Lightning można obliczyć całą serię reduktów 4-argumentowych. Jedno z tych rozwiązań podano w tab. 2.29c.
7. Analiza i eksploracja danych
Analiza i eksploracja danych
7.1. Wprowadzenie
W praktyce, metody syntezy logicznej są wykorzystywane głównie do optymalizacji systemów cyfrowych, które przetwarzają sygnały binarne. Podstawowym zadaniem tych metod jest poprawa implementacji oraz odwzorowania systemów w różnej technologii. Jednakże można wykazać, że wiele metod syntezy logicznej, a w szczególności te wykorzystywane do optymalizacji kombinacyjnych układów logicznych, może być z powodzeniem zastosowanych w typowych zadaniach przetwarzania i wyszukiwania informacji, eksploracji danych, a także w dziedzinie systemów ekspertowych, maszynowego uczenia, czy sztucznej inteligencji [2.21], [2.22].
Przez eksplorację danych, znaną również pod nazwą odkrywania wiedzy w bazach danych, jest rozumiany proces automatycznego pozyskiwania znaczących, ale dotychczas nieznanych informacji z baz danych. Dlatego te informacje określa się jako „ukryte”, a celem jest te informacje wyekstrahować. W wyniku eksploracji danych można na pewnym poziomie abstrakcji: zdiagnozować pacjenta, przeprowadzić sondaż, np. przed wyborami prezydenckimi, klasyfikować dane internetowe, czy podjąć decyzję o przyznaniu bądź odrzuceniu kredytu.
W większości zastosowań głównym zadaniem eksploracji danych jest indukcja reguł decyzyjnych, które są obliczane na podstawie wyników badań i pomiarów zgromadzonych w bazie danych. Wygenerowane reguły (zwane również klasyfikatorami) umożliwiają podjęcie decyzji. Typowym przykładem bazy danych oraz jej analizy jest Wisconsin Breast Cancer Database (źródło: Dr William H. Wolberg, University of Wisconsin Hospital, Madison, Wisconsin, USA), w której diagnoza raka piersi jest realizowana za pomocą bazy danych o dziewięciu atrybutach, zgromadzonej dla 699 pacjentek [2.29].
Systemy decyzyjne i kombinacyjne układy logiczne są bardzo podobne. System decyzyjny jest zwykle opisany przez tablicę decyzyjną, natomiast kombinacyjny układ logiczny przez tablicę prawdy. Atrybuty warunkowe systemu decyzyjnego odpowiadają zmiennym wejściowym układu logicznego, a atrybuty decyzyjne – zmiennym wyjściowym. Stąd wiele pojęć z tych obydwu obszarów może być wzajemnie na siebie odwzorowanych, a podobieństwo systemów decyzyjnych oraz układów logicznych pozwala na wykorzystanie specjalistycznych metod syntezy logicznej w dziedzinie eksploracji danych.
Na przykład zadanie redukcji danych w systemach informacyjnych jest rozwiązywane przez minimalizację liczby cech (atrybutów/parametrów), a następnie usunięcie nadmiarowych obiektów. Podobnym zadaniem w dziedzinie syntezy logicznej jest redukcja argumentów.
Innym zagadnieniem eksploracji danych jest podejmowanie decyzji na podstawie wcześniej zgromadzonych danych. Polega ono na uogólnianiu wiedzy oraz indukowaniu reguł decyzyjnych. W wyniku indukcji otrzymuje się zbiór reguł logicznych, który pozwala podejmować decyzje nie tylko dla obiektów należących do bazy pierwotnej, dla której przeprowadzono obliczenia, ale przede wszystkim dla nowych obiektów do niej nie należących. Jest to bardzo ważne w przypadku zadań maszynowego uczenia. Analogicznym zagadnieniem do indukcji reguł z dziedziny eksploracji danych jest zagadnienie minimalizacji funkcji logicznych z dziedziny syntezy logicznej. Z uwagi na inne interpretacje i aplikacje te zagadnienia wydają się być zupełnie różne, aczkolwiek jest to stwierdzenie błędne.
Celem rozdziału jest wskazanie i omówienie możliwości zastosowania zaawansowanych algorytmów syntezy logicznej w typowych zadaniach eksploracji danych, takich jak: ekstrakcja cech, indukcja reguł decyzyjnych i wielu innych.
7.2. Systemy informacyjne oraz systemy decyzyjne
Wiele rzeczywistych problemów oraz zdarzeń może zostać opisanych przy użyciu baz danych (tablic danych), czyli tak zwanych systemów informacyjnych. Na przykład, za pomocą tych tablic możemy opisywać wybrane parametry i stan pacjentów w czasie badań medycznych. Wtedy poszczególne instancje zapisane w wierszach tablicy charakteryzują pacjenta przez odpowiednie wartości parametrów (atrybutów). Na przykład, jeżeli obiektem jest KOWALSKI, atrybutem zaś wiek, to wartością tego atrybutu dla obiektu KOWALSKI może być np. MŁODY. Rozważania dotyczące algorytmów eksploracji danych ograniczymy w większości przypadków do systemów informacyjnych o specyficznej strukturze, a mianowicie do tablic decyzyjnych, których zastosowania w systemach podejmowania i wspomagania decyzji, a także w wielu zadaniach maszynowego uczenia, są coraz powszechniejsze.
Formalnie, parę A = (U, A) nazywamy systemem informacyjnym, gdzie U – jest niepustym, skończonym zbiorem obiektów, A – jest niepustym, skończonym zbiorem atrybutów, tj. każdy element a Î A jest funkcją z U w Va, gdzie zbiór Va jest dziedziną parametru a i jest nazywany zbiorem wartości dla parametru a. Wtedy funkcja r odwzorowuje produkt U oraz A w zbiór wszystkich wartości. Przez r(ut, ai), gdzie ut Î U, ai ÎA, oznaczamy wartość atrybutu dla danego obiektu.
Często zbiór atrybutów A ma jeden lub więcej atrybutów wyróżnionych lub jest o taki atrybut rozbudowywany. Celem tych atrybutów jest podejmowanie decyzji na podstawie informacji zawartej w bazie danych. Formalnie, systemem decyzyjnym jest system informacyjny postaci A = (U, A È D), gdzie A Ç D = Æ. Atrybuty w zbiorze A nazywamy atrybutami warunkowymi, natomiast atrybuty w zbiorze D nazywamy atrybutami decyzyjnymi. Systemy decyzyjne są z reguły opisywane za pomocą tablic decyzyjnych. Wtedy, funkcja r odwzorowuje U × (A È D) w zbiór wszystkich wartości atrybutów. Przykładowy system decyzyjny dany jest w tab. 2.30. Można zauważyć, że tablica decyzyjna klasyfikuje obiekty {u1 ,..., u8} do czterech różnych klas, tj. d Î{1, 2, 3, 4}.
Tablica 2.30
A |
a1 |
a2 |
a3 |
a4 |
a5 |
a6 |
d |
1 |
0 |
0 |
1 |
1 |
0 |
0 |
1 |
2 |
1 |
* |
2 |
0 |
1 |
1 |
2 |
3 |
0 |
1 |
1 |
0 |
0 |
1 |
2 |
4 |
1 |
2 |
2 |
* |
2 |
0 |
2 |
5 |
* |
2 |
2 |
2 |
0 |
1 |
1 |
6 |
0 |
0 |
1 |
1 |
0 |
1 |
3 |
7 |
0 |
1 |
0 |
3 |
2 |
|
4 |
8 |
2 |
2 |
2 |
3 |
2 |
0 |
4 |
W obydwu przypadkach, tj. kiedy tablica opisująca system informacyjny oraz system decyzyjny ma w pełni określoną funkcję r, system nazywamy w pełni określonym. Jednakże w praktyce, dane wejściowe algorytmów eksploracji danych są często zaburzone przez brakujące wartości atrybutów [2.18]. Wtedy odpowiadająca funkcja r jest nie w pełni zdefiniowana, a systemy nazywamy nie w pełni określonymi. W [2.8] definiuje się cztery przypadki wartości atrybutów dla nie w pełni określonych tablic decyzyjnych, tj. brakujące wartości oznacza przez „?”, wartości „do not care” (bez znaczenia) przez „”, zastrzeżone wartości „do not care” przez „+”, koncepcyjne wartości atrybutów przez „–”. Dodatkowo zakłada się, że dla każdego obiektu przynajmniej jedna wartość atrybutu jest określona [2.24], [2.25]. W naszych rozważaniach dla uproszczenia przyjmujemy, że będziemy uwzględniali tablice tylko z ewentualnymi wartościami „do not care” dla niektórych atrybutów.
7.3. Relacja zgodności i relacja nierozróżnialności
W podrozdziale przedstawiamy notację relacji nierozróżnialności, która jest podstawowym pojęciem w dziedzinie eksploracji danych. Podobne pojęcie nazywane relacją zgodności (tolerancji) jest stosowane w dziedzinie układów logicznych. Jest używane głównie do celów dekompozycji układów kombinacyjnych [2.17], oraz logiki sekwencyjnej [2.22]. Na bazie tej relacji skonstruowano pojęcie
r-podziału, które znajduje zastosowanie w syntezie logiki wielowartościowej, a tym samym może być zastosowane do reprezentacji zarówno systemów informacyjnych jak i systemów decyzyjnych.
Niech , będzie systemem decyzyjnym, wtedy z każdym podzbiorem
kojarzymy relację równoważności
:
nazywamy B-relacją nierozróżnialności [2.24].
Jednakże, dla systemu decyzyjnego przedstawionego w tablicy 2.30, symbol „*” dla obiektu może wyrażać wartość 0 lub 1. W rezultacie, obiekt przedstawia wiele wierszy tablicy. Stąd, klasyfikacja z użyciem relacji nierozróżnialności nie znajduje zastosowania. Aby rozwiązać ten problem wprowadzamy relację zgodności.
Wartości atrybutów ai, tj. rpi = r(up,ai) oraz rqi = r(uq,ai) nazywamy zgodnymi (rpi ~ rqi) wtedy i tylko wtedy, gdy rpi = rqi lub rpi = * lub rqi = *, gdzie „*” oznacza przypadek, dla którego wartość atrybutu jest „do not care”. Z drugiej strony, jeżeli rpi oraz rqi są zdefiniowane i są różne mówimy, że rpi jest nie zgodne z rqi i tę relację oznaczamy przez rp rqi.
Na podstawie tej definicji mówimy o relacji zgodności COMA(B) określonej dla każdego zbioru B Í A:
COMA(B) = {(<i>u</i></span></span></span></span></span></span><span class="Teksttreci66ptOdstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><sub><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">p</span></span></span></sub></span></span></span><span class="Teksttreci66ptOdstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">,</span></span></span></span></span></span><span class="Teksttreci6Odstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><i><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">u</span></span></span></i></span></span></span><span class="Teksttreci66ptOdstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><sub><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">q</span></span></span></sub></span></span></span><span class="Teksttreci6Bezkursywy" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="font-style:italic"><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">)</span></span></span></span></span></span> <span class="PogrubienieTeksttreci6SimSun95ptBezkursywyOdstpy2pt" style="background:white"><span style="font-family:SimSun"><span style="letter-spacing:2.5pt"><span style="font-weight:bold"><span style="font-style:italic"><span lang="EN-US" style="font-size:9.5pt"><span style="line-height:150%"><span style="font-family:Symbol">Î</span></span></span></span></span></span></span></span><span class="Teksttreci6Odstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><i><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif"> U</span></span></span></i></span></span></span><span class="Teksttreci6Odstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><i> </i></span></span></span><span class="PogrubienieTeksttreci6SimSun95ptBezkursywyOdstpy2pt" style="background:white"><span style="font-family:SimSun"><span style="letter-spacing:2.5pt"><span style="font-weight:bold"><span style="font-style:italic"><sup><span style="font-size:9.5pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">2</span></span></span></sup></span></span></span></span></span><span class="Teksttreci6Bezkursywy" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="font-style:italic"><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">: </span></span></span></span></span></span><span class="Teksttreci6Bezkursywy" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="font-style:italic"><span lang="EN-US" style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:Symbol">"</span></span></span></span></span></span><span class="Teksttreci6Odstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><i><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif"> a<sub>i</sub></span></span></span></i></span></span></span><span class="Teksttreci695pt" style="font-family:"Times New Roman",serif"><span style="letter-spacing:0pt"><span style="font-weight:normal"><span style="font-style:normal"><span style="text-decoration:none"><span style="font-variant:normal !important"><span lang="EN-US" style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:Symbol"> Î</span></span></span></span></span></span></span></span></span> <span class="Teksttreci6Odstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><i><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">B</span></span></span></i></span></span></span><span class="Teksttreci6Odstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">,</span></span></span></span></span></span><span class="Teksttreci695pt" style="font-family:"Times New Roman",serif"><span style="letter-spacing:0pt"><span style="font-weight:normal"><span style="font-style:normal"><span style="text-decoration:none"><span style="font-variant:normal !important"><i> </i></span></span></span></span></span></span><span class="Teksttreci695pt" style="font-family:"Times New Roman",serif"><span style="letter-spacing:0pt"><span style="font-weight:normal"><span style="font-style:normal"><span style="text-decoration:none"><span style="font-variant:normal !important"><span lang="EN-US" style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:Symbol">r</span></span></span></span></span></span></span></span></span><span class="Teksttreci6Odstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">(<i>u</i></span></span></span></span></span></span><span class="Teksttreci66ptOdstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><sub><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">p</span></span></span></sub></span></span></span><span class="Teksttreci66ptOdstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">,</span></span></span></span></span></span><span class="Teksttreci6Odstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><i><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">a<sub>i</sub></span></span></span></i></span></span></span><span class="Teksttreci6Odstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">)<i> </i></span></span></span></span></span></span><span class="Teksttreci95ptKursywa" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:0pt"><span style="font-weight:normal"><span style="font-style:italic"><span style="text-decoration:none"><span style="font-variant:normal !important"><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">~</span></span></span></span></span></span></span></span></span></span><span class="Teksttreci695pt" style="font-family:"Times New Roman",serif"><span style="letter-spacing:0pt"><span style="font-weight:normal"><span style="font-style:normal"><span style="text-decoration:none"><span style="font-variant:normal !important"><i> </i></span></span></span></span></span></span><span class="Teksttreci695pt" style="font-family:"Times New Roman",serif"><span style="letter-spacing:0pt"><span style="font-weight:normal"><span style="font-style:normal"><span style="text-decoration:none"><span style="font-variant:normal !important"><span lang="EN-US" style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:Symbol">r</span></span></span></span></span></span></span></span></span><span class="Teksttreci6Odstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">(<i>u</i></span></span></span></span></span></span><span class="Teksttreci66ptOdstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><sub><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">q</span></span></span></sub></span></span></span><span class="Teksttreci66ptOdstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">,</span></span></span></span></span></span><span class="Teksttreci6Odstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><i><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">a<sub>i</sub></span></span></span></i></span></span></span><span class="Teksttreci6Odstpy1pt" style="background:white"><span style="font-family:"Times New Roman",serif"><span style="letter-spacing:1.5pt"><span style="font-size:12.0pt"><span style="line-height:150%"><span style="font-family:"Calibri",sans-serif">)},
gdzie o obiektach p oraz q, które spełniają relację COMA(B) mówimy, że są zgodne w zbiorze B. Obiekty zgodne w zbiorze B = A nazywamy po prostu zgodnymi.
Relacja zgodności, nazywana również relacją tolerancji, jest zwrotna i symetryczna, a stąd generuje klasy zgodności na zbiorze obiektów U. Relacja zgodności pozwala na klasyfikowanie obiektów, ale klasy obiektów nie tworzą podziałów na zbiorze U, jak to jest w przypadku relacji nierozróżnialności. COMA(B) klasyfikuje obiekty grupując je w klasy zgodności, tj. U|COMA(B) gdzie B Í A.
Stąd, dowolny zbiór obiektów U reprezentujący system informacyjny lub system decyzyjny może zostać przypisany wielokrotnie i do różnych klas dla danego podzbioru atrybutów A. Taką rodzinę klas nazywamy r-podziałem i oznaczamy przez P(B), gdzie B jest wybranym podzbiorem zbioru A = {a<sub>1 </sub>,..., a<sub>m</sub>}.
r-podział na zbiorze U może być postrzegany jako zbiór nierozłącznych podzbiorów U, których suma jest równa U. Wszystkie symbole i operacje dla algebry podziałów [2.22], mogą zostać bezpośrednio zastosowane do algebry r-podziałów. W szczególności relacja mniejszy lub równy dla dwóch r-podziałów P1 oraz P2 (P1 £ P2) zachodzi wtedy i tylko wtedy, gdy dla każdej klasy z r-podziału P1, oznaczanej w skrócie przez Ki(P1) istnieje Kj(P2) taka, że Ki(P1) Í Kj(P2).
r-podział na jednoelementowym zbiorze B = {a<sub>i</sub>} oznaczamy przez P(ai) lub po prostu .
r-podział indukowany przez zbiór B jest iloczynem r-podziałów indukowanych przez pojedyncze atrybuty ai Î B.
8. Redukcja atrybutów
Redukcja atrybutów
8.1. Wprowadzenie
Redukcja atrybutów (argumentów) jest algorytmem stosowanym w dwóch odrębnych dziedzinach wiedzy, a mianowicie w zagadnieniach związanych z klasyfikacją danych – maszynowe uczenie, eksploracja danych itd. [2.23], [2.24] oraz w zagadnieniach związanych z optymalizacją i syntezą logiczną układów cyfrowych (por. rozdz. 2.6). W obu przypadkach jest to problem polegający na redukowaniu nadmiarowych specyfikacji w tablicach danych (tablicach prawdy układów logicznych) za pośrednictwem usuwania zbędnych atrybutów (argumentów). Uzyskiwane w wyniku takiego procesu tablice są wykorzystywane do generowania uogólnionych reguł decyzyjnych albo do kolejnych etapów optymalizacji logicznej (w przypadku układów cyfrowych). Oczywiście dane wejściowe algorytmów redukcji są w obu przypadkach zasadniczo różne. Dla tablic danych mamy do czynienia z wielowartościowymi atrybutami warunkowymi i wielowartościowymi atrybutami decyzyjnymi. Dla tablic prawdy wartości argumentów i wartości funkcji są binarne. Jednocześnie całkowicie inaczej są interpretowane tzw. wartości nieokreślone. W tablicy danych wartość nieokreślona atrybutu warunkowego oznacza, że wartość tego atrybutu nie została ustalona [2.18], a w przypadku tablic funkcji logicznych nieokreśloność argumentu wektora wejściowego oznacza występowanie w specyfikacji wektorów o wszystkich możliwych wartościach danego argumentu.
W rezultacie stosowane w praktyce algorytmy redukcji argumentów oraz atrybutów znacznie się różnią, a jak pokazują przeprowadzone eksperymenty – stosowane w syntezie logicznej metody i algorytmy redukcji argumentów okazują się skuteczniejsze niż analogiczne algorytmy redukcji atrybutów stosowane w analizie danych.
W układach logicznych i ich realizacjach sprzętowych istotnym zagadnieniem jest obliczenie minimalnych zbiorów argumentów o najmniejszej liczności. W przypadku redukcji atrybutów ważniejsze jest obliczenie wszystkich minimalnych zbiorów atrybutów. Taka potrzeba może się zdarzyć, gdy wyliczony zbiór atrybutów mniejszy pod względem liczności niż inny może być trudny do realizacji lub bardziej kosztowny. Na przykład, gdy rozważamy obliczenia redukcji atrybutów dla potrzeb diagnozy medycznej dany parametr może wyrażać skomplikowane lub kosztowne badanie, lub wyrażać badanie, które ma negatywny wpływ na zdrowie pacjenta, lub badanie, które nie jest możliwe do przeprowadzenia. Natomiast inne rozwiązanie – o większej liczności – może być łatwiejsze do realizacji w praktyce. Dlatego opracowanie odpowiednich do zastosowań, skutecznych i szybkich algorytmów redukcji atrybutów jest szczególnie istotne w systemach eksploracji danych.
8.2. Algorytm redukcji atrybutów
Systemy informacyjne i systemy decyzyjne są redukowalne co najmniej na dwa sposoby, tj. te same lub nierozróżnialne obiekty mogą być reprezentowane przez tablice wielokrotnie lub – niektóre atrybuty mogą być nadmiarowe [2.19]. Omówione w poprzednim podrozdziale relacje nierozróżnialności oraz zgodności mogą zostać wykorzystane do realizacji zadania redukcji. Nie należy ich traktować jako konkurencyjne techniki, lecz wręcz przeciwnie – jak pokazano w tym rozdziale – techniki, które wzajemnie się uzupełniają.
Niech A = (U, A È D), gdzie A Ç D = Æ, będzie systemem decyzyjnym, gdzie zbiory A, D są odpowiednio zbiorami atrybutów warunkowych oraz decyzyjnych.
Każdy system informacyjny A generuje r-podziały P(A), P(D), gdzie atrybuty ai generują poszczególne r-podziały . r-podziały reprezentują klasy zgodności COM na zbiorze U. Niech B Í A będzie podzbiorem atrybutów oraz up, uq Î U. Para (up, uq) Î COM(B) wtedy i tylko wtedy gdy ρ(up, ai) ~ ρ(uq, ai) dla każdego ai Î B. Jeśli zapiszemy klasy zgodności COM(B) jako P(B),wtedy:
Używając r-podziałów generowanych zbiorem atrybutów możemy wprowadzić pojęcie zależności funkcjonalnej pomiędzy rozłącznymi podzbiorami A oraz D. Mówimy, że D jest funkcjonalnie zależny od A (symbolicznie A Þ D), wtedy i tylko wtedy gdy P(A) jest nie większy niż P(D), (tzn. P(A) £ P(D)). W terminach systemów informacyjnych znaczy to, że zbiór atrybutów D zależy od zbioru atrybutów A. Inaczej mówiąc, jeśli tylko para obiektów nie może być rozróżniona atrybutami ze zbioru A, to również nie można tych obiektów rozróżnić atrybutami ze zbioru D.
Uproszczenie systemu decyzyjnego z punktu widzenia minimalnego zbioru atrybutów zachowujących zdolności klasyfikacyjne systemu (lub zależność funkcjonalną A Þ D) należy do zadań określanych mianem redukcji wiedzy. Redukcja wiedzy w systemach decyzyjnych polega na redukcji liczby atrybutów warunkowych, czyli wyznaczaniu tak zwanych reduktów oraz usuwaniu nadmiarowych obiektów/reguł.
Tablica 2.31
A |
a1 |
a2 |
a3 |
a4 |
a5 |
a6 |
D |
1 |
0 |
1 |
0 |
1 |
0 |
0 |
1 |
2 |
1 |
0 |
0 |
0 |
1 |
3 |
2 |
3 |
1 |
1 |
0 |
2 |
2 |
3 |
3 |
4 |
1 |
1 |
0 |
2 |
3 |
3 |
2 |
5 |
1 |
1 |
1 |
0 |
2 |
3 |
4 |
6 |
0 |
0 |
2 |
0 |
2 |
3 |
1 |
7 |
1 |
1 |
2 |
0 |
2 |
2 |
5 |
8 |
1 |
1 |
2 |
0 |
2 |
3 |
6 |
9 |
1 |
0 |
2 |
2 |
1 |
3 |
6 |
10 |
1 |
1 |
2 |
2 |
3 |
1 |
7 |
Zbiór B Í A jest reduktem systemu decyzyjnego A = (U, A È D) wtedy i tylko wtedy, gdy P(B) £ P(D) oraz nie istnieje podzbiór właściwy B’ zbioru B taki, że P(B’) £ P(D). Inaczej mówiąc, reduktem systemu decyzyjnego A = (U, A È D), w którym A Þ D, jest zbiór B Í A taki, że B Þ D oraz nie istnieje podzbiór właściwy B’ zbioru B, gdzie B’ Þ D. Atrybut a Î A nazywamy atrybutem zbędnym w systemie decyzyjnym A wtedy i tylko wtedy, gdy P(A \ {<i>a</i>}) £ P(D), w przeciwnym przypadku a jest atrybutem niezbędnym. Zbiór wszystkich atrybutów niezbędnych nazywamy rdzeniem systemu decyzyjnego lub po prostu rdzeniem.
Obliczymy niezbędność atrybutów dla tablicy decyzyjnej z tabl. 2.31. Skoro P(A \ {<i>a</i><sub>1</sub>}) £ P(D), a1 jest zbędny dla zależności funkcjonalnej A Þ D. W przeciwieństwie, a3 jest atrybutem niezbędnym, gdyż P(A \ {<i>a</i><sub>3</sub>})
Tablica 2.32
A‘ |
a1 |
a3 |
a5 |
a6 |
D |
1 |
0 |
0 |
0 |
0 |
1 |
2 |
1 |
0 |
1 |
3 |
2 |
3 |
1 |
0 |
2 |
3 |
3 |
4 |
1 |
0 |
3 |
3 |
2 |
5 |
1 |
1 |
2 |
3 |
4 |
6 |
0 |
2 |
2 |
3 |
1 |
7 |
1 |
2 |
2 |
2 |
5 |
8 |
1 |
2 |
2 |
3 |
6 |
9 |
1 |
2 |
1 |
3 |
6 |
10 |
1 |
2 |
3 |
1 |
7 |
Pojęciami podstawowymi w algorytmie redukcji atrybutów są: macierz porównań oraz funkcja rozróżnialności. Można wtedy wykazać, że między reduktami systemu decyzyjnego A, a implikantami funkcji rozróżnialności fA , która w rzeczywistości jest monotoniczną funkcją boolowską, zachodzi następujący związek:
, wtedy i tylko wtedy, gdy
jest implikantem prostym
Natomiast, wyznaczenie implikantów prostych odbywa się – na przykład – za pomocą przekształcenia monotonicznej funkcji rozróżnialności w postaci iloczynu sum boolowskich do postaci sumy iloczynów. Zgodnie z podrozdziałem 2.6.2, można do tych obliczeń zastosować efektywny algorytm uzupełnienia funkcji boolowskiej.
Funkcja rozróżnialności dla systemu decyzyjnego z tabl. 2.31 jest następująca:
Wtedy macierz porównań powstaje w wyniku rozróżnienia par obiektów wskazanych w r-podziale ilorazowym (tabl. 2.34).
Tablica 2.34
p, q |
atrybuty rozróżniające |
1,7 |
{<i>a</i><sub>2</sub>,<i>a</i><sub>3</sub>,<i>a</i><sub>4</sub>,<i>a</i><sub>5</sub>} |
3,5 |
{<i>a</i><sub>2</sub>,<i>a</i><sub>3</sub>,<i>a</i><sub>4</sub>} |
3,6 |
{<i>a</i><sub>2</sub>,<i>a</i><sub>4</sub>} |
3,7 |
{<i>a</i><sub>3</sub>,<i>a</i><sub>4</sub>,<i>a</i><sub>5</sub>} |
5,6 |
{<i>a</i><sub>2</sub>,<i>a</i><sub>3</sub>,<i>a</i><sub>4</sub>} |
5,7 |
{<i>a</i><sub>2</sub>,<i>a</i><sub>3</sub>,<i>a</i><sub>4</sub>,<i>a</i><sub>5</sub>} |
6,7 |
{<i>a</i><sub>2</sub>,<i>a</i><sub>3</sub>,<i>a</i><sub>4</sub>,<i>a</i><sub>5</sub>} |
2,5 |
{<i>a</i><sub>4</sub>,<i>a</i><sub>5</sub>} |
Zapisując macierz porównań w postaci funkcji rozróżnialności otrzymujemy: fA = (a2+a4)(a4+a5), ponieważ wiele czynników tego wyrażenia upraszcza się ze względu na własność pochłaniania. Ostatecznie po przekształceniu iloczynu sum do sumy iloczynów otrzymujemy: fA = a4 + a2a5.
Stąd, łącząc poszczególne składniki fA z rdzeniem R = {<i>a</i><sub>1</sub>, <i>a</i><sub>6</sub>} otrzymujemy wszystkie redukty systemu decyzyjnego z tabl. 5.4: {<i>a</i><sub>1</sub>,<i>a</i><sub>4</sub>,<i>a</i><sub>6</sub>}, {<i>a</i><sub>1</sub>,<i>a</i><sub>2</sub>,<i>a</i><sub>5</sub>,<i>a</i><sub>6</sub>}.
oraz , następujący r-podział ilorazowy:
Zgodnie z metodą omawianą w podrozdz. 2.6.1 w celu obliczenia reduktów należy obliczyć zmienne niezbędne, a następnie obliczyć podział ilorazowy PN|PD, gdzie PN reprezentuje iloczyn podziałów indukowanych zmiennymi niezbędnymi. Podział PN|PD stanowi punkt wyjścia do obliczenia tablicy porównań.
Zgodnie z metodą omawianą w podrozdz. 2.6.1 w celu obliczenia reduktów należy obliczyć zmienne niezbędne, a następnie obliczyć podział ilorazowy PN|PD, gdzie PN reprezentuje iloczyn podziałów indukowanych zmiennymi niezbędnymi. Podział PN|PD stanowi punkt wyjścia do obliczenia tablicy porównań.
Dla funkcji z tabl. 2.35 zmiennymi niezbędnymi są a4 i a6.
Tablica 2.35
|
a1 |
a2 |
a3 |
a4 |
a5 |
a6 |
a7 |
d |
1 |
1 |
0 |
0 |
0 |
1 |
0 |
1 |
0 |
2 |
1 |
0 |
1 |
1 |
1 |
1 |
0 |
0 |
3 |
1 |
1 |
0 |
1 |
1 |
1 |
0 |
0 |
4 |
1 |
1 |
1 |
0 |
1 |
1 |
1 |
0 |
5 |
0 |
1 |
0 |
0 |
1 |
0 |
1 |
1 |
6 |
1 |
0 |
0 |
0 |
1 |
1 |
0 |
1 |
7 |
1 |
0 |
1 |
0 |
0 |
0 |
0 |
1 |
8 |
1 |
0 |
1 |
0 |
1 |
1 |
0 |
1 |
9 |
1 |
1 |
1 |
0 |
1 |
0 |
1 |
1 |
Odpowiednie obliczenia prowadzące do uzyskania podziału ilorazowego są następujące:
Na tej podstawie tworzymy tablicę porównań (tabl. 2.36), której ostateczna postać nie zawiera nadmiarowego wiersza oznaczonego 4,6.
Tablica 2.36
p, q |
Zmienne rozróżniające |
1,5 |
{<i>a</i><sub>1</sub>,<i>a</i><sub>2</sub>} |
1,7 |
{<i>a</i><sub>3</sub>,<i>a</i><sub>5</sub>,<i>a</i><sub>7</sub>} |
1,9 |
{<i>a</i><sub>2</sub>,<i>a</i><sub>3</sub>} |
4,6 |
{<i>a</i><sub>2</sub>,<i>a</i><sub>3</sub>,<i>a</i><sub>7</sub>} |
4,8 |
{<i>a</i><sub>2</sub>,<i>a</i><sub>7</sub>} |
Zbiory atrybutów w poszczególnych wierszach tablicy porównań reprezentują czynniki wyrażenia boolowskiego typu iloczyn sum, które następnie jest przekształcane do postaci typu suma iloczynów. Po uwzględnieniu atrybutów niezbędnych z wyrażenia typu suma iloczynów uzyskujemy wszystkie redukty funkcji z tabl. 2.35:
{<i>a</i><sub>2</sub>,<i>a</i><sub>3,</sub><i>a</i><sub>4</sub>,<i>a</i><sub>6</sub>}
{<i>a</i><sub>2</sub>,<i>a</i><sub>4</sub>,<i>a</i><sub>5</sub>,<i>a</i><sub>6</sub>}
{<i>a</i><sub>2</sub>,<i>a</i><sub>4</sub>,<i>a</i><sub>6</sub>,<i>a</i><sub>7</sub>}
{<i>a</i><sub>1</sub>,<i>a</i><sub>3,</sub><i>a</i><sub>4,</sub><i>a</i><sub>6</sub>,<i>a</i><sub>7</sub>}
Nietrudno zauważyć, że redukcja atrybutów jest takim samym zadaniem z jakim mieliśmy do czynienia w zagadnieniach redukcji argumentów. Można zatem skorzystać z doświadczeń i metod syntezy logicznej wypracowanych w technice cyfrowej. Godnym polecenia wydaje się algorytm uzupełniania funkcji boolowskich zastosowany do obliczania transformacji CNF na DNF. Jest to istotne o tyle, że transformacja ta jest wykorzystywana w modelowym systemie eksploracji danych jakim jest RSES [5.25]. Równoważność tych dwóch procesów najłatwiej wyjaśnić na przykładzie tablicy funkcji boolowskiej (tabl. 2.35) omawianej w rozdz. 2.6. Interpretując czynniki wyrażenia CNF tej funkcji
jako kostki funkcji boolowskiej, nietrudno zauważyć, że uzupełnienie tej funkcji reprezentowane jest kostkami: a2a3; a2a5; a2a7; a1a3a7.
Taki sam wynik uzyskuje się dokonując transformacji CNF na DNF (por. rozdz.2.6).
Z dokonanego przeglądu systemów klasyfikacji danych wynika, że stosowane w nich algorytmy redukcji atrybutów są mało skuteczne. Potwierdzeniem tego przypuszczenia są eksperymenty przeprowadzone ze znanym i powszechnie stosowanym do tych obliczeń systemem RSES [2.28]. Wykazano, że system ten nie radzi sobie z tablicami danych o dużej liczbie nieokreśloności. Wymownym przykładem jest często cytowana logistyczna baza danych trains (tabl. 2.37).
Tablica 2.37
.type fr .i 32 .o 1 .p 10 23016320081311611006100100010010 0 12009130071200020-----0101000000 0 11006100041311013-----0000101000 0 21007130011300212006121100100000 0 12001131101200010-----0101000000 0 010103000613----------0000001000 1 1100110009130150------0000001000 1 011101200910----------0001000000 1 21007100151200612007101001000000 1 000091201622----------1000000000 1 .end |
Dla bazy trains program opracowany z zastosowaniem metody uzupełnienia funkcji boolowskiej generuje 689 reduktów, natomiast RSES zaledwie 333 (z pominięciem opcji Don’t discern with missing values). Natomiast uruchomienie RSES dla opcji Don’t discern with missing values kończy się (po kilku godzinach obliczeń) komunikatem Not enough memory. Istotnym jest, że pominięcie opcji Don’t discern with missing values skutkuje uwzględnianiem brakujących wartości podczas tworzenia macierzy porównań. Inaczej mówiąc, w czasie wyznaczania zbioru atrybutów na których różnią się dwa wybrane obiekty, odróżniane są te o wartości NULL. W rezultacie takiego postępowania otrzymujemy wynik, który jest różny od zbioru wszystkich minimalnych zbiorów atrybutów.
Innym przykładem potwierdzającym bezwzględną przewagę metody uzupełnienia funkcji boolowskiej w metodzie redukcji atrybutów jest funkcja KAZ (tabl. 2.38). Jest to funkcja 21 argumentów binarnych, często stosowana w testowaniu zaawansowanych narzędzi syntezy logicznej. Otóż program RSES oblicza wszystkie 5574 redukty tej funkcji w ciągu 39 minut, natomiast opracowana i zaimplementowana procedura z zastosowaniem algorytmu uzupełnienia tworzy zbiór wszystkich 5574 reduktów w czasie 2.5 s.
Tablica 2.38
type fr .i 21 .o 1 .p 31 100110010110011111101 1 111011111011110111100 1 001010101000111100000 1 001001101100110110001 1 100110010011011001101 1 100101100100110110011 1 001100100111010011011 1 001101100011011011001 1 110110010011001001101 1 100110110011010010011 1 110011011011010001100 1 010001010000001100111 0 100110101011111110100 0 111001111011110011000 0 101101011100010111100 0 110110000001010100000 0 110110110111100010111 0 110000100011110010001 0 001001000101111101101 0 100100011111100110110 0 100011000110011011110 0 110101000110101100001 0 110110001101101100111 0 010000111001000000001 0 001001100101111110000 0 100100111111001110010 0 000010001110001101101 0 101000010100001110000 0 101000110101010011111 0 101010000001100011001 0 011100111110111101111 0 .end |
9. Indukcja reguł decyzyjnych
Celem indukcji reguł decyzyjnych jest wygenerowanie z danych zbioru reguł, które będą użyte do klasyfikowania nowych obiektów. Należy podkreślić, że zarówno rozwój algorytmów indukcji reguł, jak i sposób ich oceny ukierunkowany jest przede wszystkim na perspektywę klasyfikowania nowych obiektów. Ponieważ zbiór reguł traktowany jest wtedy jako klasyfikator, poprawność klasyfikowania jak największej liczby obiektów jest główną miarą oceny.
Ze względu na znaczenie algorytmów redukcji reguł w klasyfikacji danych rozważa się różne strategie obliczeniowe. W strategiach tych wyróżnikiem jest stopień uogólniania reguł, co wpływa na precyzję klasyfikacji obiektów spoza zbioru treningowego.
9.1. Strategia dwustopniowej selekcji reguł
Naturalną strategią indukcji reguł jest strategia dwustopniowej selekcji reguł. W strategii tej dla każdego obiektu ui klasy K tworzy się zbiór wszystkich minimalnych reguł pozytywnych (ozn. R(ui )). Suma zbiorów R(ui ) dla wszystkich obiektów klasy K tworzy rodzinę minimalnych reguł tej klasy. Rodzina ta jest następnie poddawana procesowi selekcji, którego celem jest wyznaczenie minimalnej rodziny minimalnych reguł. Zarówno w procesie uogólniania pojedynczego obiektu, jak też w procesie selekcji korzysta się z pojęcia pokrycia kolumnowego binarnej macierzy M, omawianym już w rozdz. 1.2.
Obliczanie pokrycia kolumnowego jest standardowym zadaniem polegającym na transformacji wyrażenia boolowskiego typu CNF (Conjunctive Normal Form) na wyrażenie DNF (Disjunctive Normal Form). W wyrażeniu CNF czynniki koniunkcji są dysjunkcjami zmiennych boolowskich etykietujących te kolumny M dla których w danym wierszu
Zastosowanie pokrycia kolumnowego do uogólnienia reguły decyzyjnej obiektu ui dotyczy tzw. macierzy rozróżnialności.
Macierz rozróżnialności tworzymy przez porównanie obiektu ui z każdym obiektem uj należącym do innej klasy decyzyjnej. Porównanie polega na utworzeniu binarnego wektora w, w którym na pozycja k jest wartość zero, jeśli wartość atrybut Ak(ui) obiektu ui jest taka sama jak wartość atrybutu Ak(uj) obiektu uj lub co najmniej jedna z tych wartości jest nieokreślona. W przeciwnym przypadku wartość składowej k wektora w jest równa jeden. Zbiór wektorów w tworzy macierz rozróżnialności.
Z definicji macierzy rozróżnialności wynika, że aby uogólniona reguła obiektu ui nie pokrywała zdanego obiektu innej klasy decyzyjnej, to w odpowiedniej R(ui) należy zostawić atrybuty, które odróżniają R(ui) od każdego obiektu innej klasy decyzyjnej.
Istotę zjawiska możemy zaobserwować na hipotetycznym przykładzie reprezentującym wyniki sondażu przed wyborami prezydenckimi w pewnej republice.
Sondaż przed wyborami prezydenckimi w pewnej republice przeprowadzono wg reguł decyzyjnych uzyskanych z danych (tabl. 2.39) reprezentujących odpowiedzi na pytania (tak, nie) uzyskane od 9 respondentów. W tablicy tej odpowiedziom tak przyporządkowano wartość 1, odp. nie – 0, przy jednoczesnym wyróżnieniu zwolenników ocenianego kandydata na prezydenta atrybutem TAK, a przeciwników, atrybutem NIE. Celem jest obliczenie uogólnionych reguł decyzyjnych określających zwolenników tego kandydata dla respondentów o dowolnych odpowiedziach na pytania sondażowe.
Tablica 2.39
|
a1 |
a2 |
a3 |
a4 |
a5 |
a6 |
a7 |
d |
1 |
1 |
0 |
0 |
0 |
1 |
1 |
0 |
1 |
2 |
0 |
1 |
0 |
0 |
1 |
0 |
1 |
1 |
3 |
1 |
0 |
1 |
0 |
0 |
0 |
0 |
1 |
4 |
1 |
0 |
1 |
0 |
1 |
1 |
0 |
1 |
5 |
1 |
1 |
1 |
0 |
1 |
0 |
1 |
1 |
6 |
1 |
0 |
0 |
0 |
1 |
0 |
1 |
0 |
7 |
1 |
0 |
1 |
1 |
1 |
1 |
0 |
0 |
8 |
1 |
1 |
0 |
1 |
1 |
1 |
0 |
0 |
9 |
1 |
1 |
1 |
0 |
1 |
1 |
1 |
0 |
Na przykład dla obiektu u1 systemu decyzyjnego z tablicy 2.39 odpowiednia macierz rozróżnialności będzie:
czyli dla zapewnienia „pełnego rozróżnienia” w regule R(u1) należy zostawić atrybuty: a6 lub a7 i a3 lub a4 i a2 lub a4 i a2 lub a3 lub a6. Zapisując te warunki w postaci wyrażenia CNF:
(a6 + a7) (a3 + a4) (a2 + a4) (a2 + a3 + a7)
dochodzimy do wniosku, że w celu obliczenia wszystkich uogólnionych reguł obiektu u2 (o minimalnej liczbie atrybutów) należy dokonać transformacji wyrażenia CNF do postaci DNF. Wtedy składniki DNF reprezentują minimalne zbiory atrybutów R(u2). Wynik takiej transformacji jest następujący:
a4a7 + a2a4a6 + a3a4a6 + a2a3a7 + a2a3a6
Oczywiście najlepsza reguła będzie dla a4a7, czyli R(u2) = (a4,0) & (a7,0) i jak łatwo sprawdzić żaden obiekt klasy d = 0 nie spełnia tej reguły.
Podstawowe znaczenie w metodzie ma procedura obliczająca pokrycie kolumnowe macierzy M. Ze względu na złożoność obliczeniową, zadanie generowania reguł nie jest zwykle możliwe do rozwiązania w czasie wielomianowym. W szczególności zbiór pokryć macierzy M może zawierać zbyt wiele elementów, aby program mógł znaleźć rozwiązanie w rozsądnym czasie. W związku z tym zaproponowano zastosowanie algorytmu uzupełnienia funkcji boolowskiej.
Możliwość zastosowania uzupełnienia funkcji boolowskiej do obliczenia wszystkich minimalnych pokryć kolumnowych macierzy binarnej M omówiona była w rozdz. 2.6.2. Na tej podstawie stwierdzamy: zamiast stosować transformację CNF na DNF wystarczy obliczyć uzupełnienie funkcji boolowskiej reprezentowanej macierzą M. Metoda jest dokładnie przedstawiona w rozdz. 2.6.2, dlatego ograniczymy jej omówienie jedynie do obliczenia uzupełnienia macierzy M. Funkcja boolowska macierzy M oraz jej uzupełnienie podane są w tablicy 2.40.
Tablica 2.40
|
|
x1 |
x2 |
x3 |
x4 |
x5 |
x6 |
x7 |
f |
1 |
|
– |
– |
– |
– |
– |
1 |
1 |
1 |
2 |
|
– |
– |
1 |
1 |
– |
– |
– |
1 |
3 |
|
– |
1 |
– |
1 |
– |
– |
– |
1 |
4 |
|
– |
1 |
1 |
– |
– |
– |
1 |
1 |
5 |
|
– |
0 |
– |
0 |
– |
0 |
– |
0 |
6 |
|
– |
0 |
0 |
– |
– |
0 |
– |
0 |
7 |
|
– |
– |
0 |
0 |
– |
0 |
– |
0 |
8 |
|
– |
0 |
0 |
– |
– |
– |
0 |
0 |
9 |
|
– |
– |
– |
0 |
– |
– |
0 |
0 |
Procedura uzupełniania – jak wykazano w [2.17],[2.18] – jest bardzo szybka, zatem jej zastosowanie do indukcji reguł jest wskazane. Dysponując szybkim algorytmem indukcji reguł dla pojedynczych obiektów możemy pokusić się o indukcję dla wszystkich reguł danej klasy decyzyjnej i wybrać z nich reguły najogólniejsze, przeznaczone do następnego etapu selekcji. Przy takiej organizacji trzeba będzie jednak wprowadzić heurystyczne algorytmy selekcji.
Dla binarnego systemu decyzyjnego podanego w tabl. 2.39 obliczamy minimalne reguły decyzyjne dla obiektów u1 do u5. Oznaczając przez Ri reguły generowane przez obiekt ui uzyskujemy kolejno:
r1 = (a4,0) & (a7,0) r2 = (a1,0) r3 = (a5,0)
r4 = (a4,1) & (a7,0) r5 = (a2,1) & (a6,0) oraz (a3,1) & (a6,0)
Usuwając reguły powtarzające się ostateczną listę reguł minimalnych zapisujemy jak następuje:
R1 = (a1,0) R2 = (a4,0) & (a7,0) R3 = (a5,0)
R4 = (a2,1) & (a6,0) R5 = (a3,1) & (a6,0)
Na tej podstawie dla każdej obliczonej wyżej reguły Ri wyznaczamy wszystkie obiekty decyzji d = 1 pokrywane przez Ri.
Przykładowo:
R1 Ê u1
R2 Ê u2, u3, u4
R4 Ê u1, u5
Tabelę pokryć pokazano w tabl. 2.41.
Tablica 2.41
|
R1 |
R2 |
R3 |
R4 |
R5 |
u1 |
1 |
0 |
0 |
1 |
0 |
u2 |
0 |
1 |
0 |
0 |
0 |
u3 |
0 |
1 |
1 |
0 |
1 |
u4 |
0 |
1 |
0 |
0 |
0 |
u5 |
0 |
0 |
0 |
1 |
1 |
Tablica pokryć umożliwia wybór (selekcję) takiego minimalnego zbioru reguł, który pokrywa wszystkie obiekty ustalonej klasy decyzyjnej. Minimalny zbiór reguł klasy decyzyjnej d = 1 można wyznaczyć obliczając minimalne pokrycie kolumnowe tablicy pokryć. W tym celu zapisujemy wiersze tablicy w postaci zbiorów kolumn wskazywanych przez pozycje jedynek w danym wierszu. Metoda selekcji pokryć zastosowana w proponowanym algorytmie indukcji oblicza wszystkie minimalne pokrycia kolumnowe metodą uzupełnienia funkcji boolowskiej, której specyfikacja (również jej uzupełnienia) jest podana w tabl. 2.42.
Tablica 2.42
|
x1 |
x2 |
|
x3 |
x4 |
x5 |
f |
1 |
1 |
– |
|
– |
1 |
– |
1 |
2 |
– |
1 |
|
– |
– |
– |
1 |
3 |
– |
1 |
|
1 |
– |
1 |
1 |
4 |
– |
– |
|
– |
1 |
1 |
1 |
5 |
0 |
0 |
|
– |
– |
0 |
0 |
9 |
– |
0 |
|
– |
0 |
– |
0 |
Z zapisu uzupełnienia wynika, że wszystkie minimalne pokrycia kolumnowe są: R2, R4 oraz R1, R2, R5. Oczywiście taki sam wyniki uzyskamy dokonując transformacji wyrażenia typu CNF na DNF:
r2(r1 + r4) (r2 + r3 + r5) (r4 + r5) = r2r4 + r1 r2r5
Z powyższych rozważań wynika, że zadanie uogólnienia reguł decyzyjnych ustalonej klasy Dk jest analogiczne do zadania minimalizacji funkcji boolowskiej f= (F, R), w której wektory zbioru F odpowiadają obiektom klasy Dk, a zbiór R jest macierzą rozróżniającą. Złożoność obliczeniową tego problemu można oszacować złożonością obliczeniową zadania minimalizacji funkcji boolowskiej. Obliczeniem decydującym o eksplozji kombinatorycznej tego problemu jest zatem obliczenie wszystkich pokryć kolumnowych Tablicy Pokryć. O złożoności tego problemu decyduje szybko rosnąca (ze wzrostem liczby atrybutów) liczność rodziny minimalnych reguł klasy Dk.
Otóż w przypadku systemu decyzyjnego z tablicy 2.39 liczba wszystkich minimalnych reguł jest 5: tym samym odpowiednia tablica pokryć (tabl. 2.41) ma 5 kolumn. W rezultacie obliczenie minimalnych pokryć kolumnowych tej tablicy można wykonać „ręcznie” – jest widoczne „gołym okiem”. Zjawisko występującej w tym problemie eksplozji kombinatorycznej dobrze wyjaśnia przykład tablicy decyzyjnej podanej w tablicy 2.43. W tym przypadku liczba wszystkich minimalnych reguł jest 68. Zatem odpowiednia tablica pokryć ma aż 68 kolumn, co znacznie utrudnia obliczenie uzupełnienia.
Tablica 2.43
|
x1 |
x2 |
x3 |
x4 |
x5 |
x6 |
x7 |
x8 |
x9 |
x10 |
y |
1 |
0 |
0 |
1 |
0 |
1 |
1 |
1 |
0 |
1 |
0 |
0 |
2 |
1 |
0 |
1 |
0 |
0 |
1 |
0 |
1 |
0 |
0 |
0 |
3 |
0 |
1 |
0 |
0 |
0 |
1 |
1 |
1 |
1 |
0 |
0 |
4 |
1 |
0 |
1 |
1 |
1 |
0 |
1 |
0 |
1 |
1 |
0 |
5 |
1 |
1 |
0 |
0 |
0 |
1 |
0 |
0 |
1 |
1 |
0 |
6 |
0 |
1 |
0 |
0 |
0 |
1 |
0 |
1 |
1 |
0 |
0 |
7 |
1 |
1 |
1 |
0 |
1 |
0 |
0 |
1 |
1 |
0 |
0 |
8 |
0 |
1 |
0 |
0 |
1 |
1 |
0 |
0 |
0 |
0 |
0 |
9 |
0 |
1 |
0 |
1 |
0 |
0 |
0 |
0 |
1 |
0 |
0 |
10 |
0 |
1 |
1 |
1 |
1 |
1 |
1 |
0 |
1 |
1 |
1 |
11 |
0 |
0 |
0 |
0 |
0 |
1 |
0 |
1 |
0 |
0 |
1 |
12 |
1 |
1 |
0 |
1 |
1 |
1 |
0 |
0 |
1 |
1 |
1 |
13 |
0 |
1 |
0 |
0 |
1 |
0 |
0 |
0 |
0 |
0 |
1 |
14 |
0 |
1 |
0 |
0 |
0 |
1 |
1 |
1 |
1 |
1 |
1 |
15 |
0 |
0 |
1 |
0 |
0 |
0 |
0 |
1 |
1 |
0 |
1 |
16 |
1 |
1 |
1 |
1 |
0 |
1 |
0 |
0 |
0 |
1 |
1 |
17 |
1 |
1 |
1 |
1 |
1 |
0 |
1 |
0 |
0 |
1 |
1 |
18 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
19 |
0 |
0 |
1 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
20 |
1 |
1 |
0 |
1 |
1 |
0 |
0 |
1 |
1 |
1 |
1 |
21 |
0 |
0 |
1 |
0 |
0 |
0 |
1 |
1 |
1 |
1 |
1 |
22 |
1 |
1 |
1 |
1 |
1 |
0 |
0 |
0 |
1 |
0 |
1 |
23 |
1 |
0 |
1 |
0 |
1 |
1 |
1 |
1 |
0 |
1 |
1 |
24 |
0 |
1 |
1 |
0 |
0 |
0 |
0 |
1 |
1 |
0 |
1 |
25 |
0 |
1 |
0 |
0 |
1 |
1 |
1 |
0 |
0 |
0 |
1 |
Z powyższych rozważań wynika, że obliczenie uogólnionych reguł decyzyjnych dla rzeczywistych baz danych muszą być – przynajmniej dla tablicy pokrycia – realizowane algorytmami heurystycznymi. Natomiast rewelacyjna procedura uzupełniania (Complement) może być zastosowana wyłącznie do obliczania minimalnych pokryć kolumnowych macierzy rozróżnialności.
Należy pamiętać, że algorytm uzupełnienia funkcji boolowskiej (complement) jest algorytmem systematycznym. Uzyskuje najlepsze wyniki pokrycia, a co ważne dla generacji reguł, tworzy wszystkie rozwiązania problemu. Zalet tego algorytmu niestety nie da się zawsze wykorzystać, szczególnie dla bardziej złożonych problemów. Algorytm uzupełniania jest szczególnie wrażliwy na ilość kolumn w tablicy rozróżnialności. Praktyka pokazuje, że tablice rozróżnialności podczas uogólniania reguł zawierają zazwyczaj więcej obiektów (wierszy), niż kolumn (atrybutów), dlatego dla małych i średnich baz w rozumieniu ilości atrybutów (od 1 do 30 atrybutów) z powodzeniem używamy uzupełnienia. Niestety odwrotną strukturę posiadają tablice rozróżnialności reguł. Ilość kolumn jest zawsze niemniejsza niż ilość wierszy. Wynika to z faktu, że z każdego obiektu (wiersza) indukowana jest minimalnie jedna reguła.
Ograniczenia w stosowaniu algorytmu uzupełniania funkcji boolowskich spowodowały potrzebę użycia szybkich, heurystycznych algorytmów minimalizacji tablic boolowskich. Możliwe do zastosowania są dwa algorytmy iteracyjne: MaxCol i MinRow, omawiane poprzednio w rozdz. 2.4.2.
Algorytmy Complement, MaxCol, MinRow stanowią strategię indukcji reguł decyzyjnych, którą nazywać będziemy strategią dwustopniowej selekcji.
Regułowy system decyzyjny
Procedura dwustopniowej selekcji reguł składa się z następujących etapów.
- Wyznaczenie macierzy rozróżnialności dla obiektu ui ustalonej klasy decyzyjnej
- Obliczenie wszystkich uogólnionych reguł obiektu ui
Macierz rozróżnialności jest wykorzystywana do obliczenia wszystkich uogólnionych reguł obiektu ui. Obliczenie zbiory wszystkich minimalnych reguł sprowadzić można do problemu obliczenia pokryć kolumnowych macierzy rozróżnialności.
Załóżmy, że kolumny macierzy rozróżnialności są indeksowane kolejnymi atrybutami warunkowymi tablicy decyzyjnej. Wtedy każde minimalne pokrycie kolumnowe tej macierzy jest zbiorem atrybutów warunkowych uogólnionej i minimalnej reguły decyzyjnej obiektu ui. W celu utworzenia tej reguły atrybutom zbioru reprezentującego pokrycie kolumnowe przyporządkowuje się odpowiednie wartości obiektu ui, czyli jeśli minimalny zbiór atrybutów jest {<i>a<sub>i</sub>, a<sub>j</sub>,…,a<sub>k</sub></i>} oraz obiekt ui ma wartości atrybutów odpowiednio {<i>w<sub>i</sub>, w<sub>j</sub>,…,w<sub>k</sub></i>} to ugólnioną regułą jest:
( ai = wi ) & ( aj = wj ) & ( ak = wk ) = dk
- Obliczenie rodziny minimalnych ugólnionych reguł klasy decyzyjnej Dk
Powtarzając obliczenia z punków 1 i 2 dla każdego obiektu ui ustalonej klasy decyzyjnej Dk uzyskuje się rodzinę minimalnych uogólnionych reguł klasy Dk:
R(Dk) = (r1,..., rmax)
Reguły wchodzące w skład tej rodziny stanowią zbiór najlepszych reguł reprezentujących wszystkie obiekty klasy Dk.
- Wyznaczenie tablicy pokryć klasy Dk
Chcąc uzyskać minimalny zbiór reguł (niekoniecznie o najmniejszej liczności) reprezentujących klasę Dk należy utworzyć tablicę pokryć (TP). Tablicą pokryć jest binarna tablica o liczbie kolumn n (n jest licznością rodziny R(Dk)) i liczbie wierszy równej k ( k – liczba obiektów klasy klasy Dk). Element TP(i,j) tej tablicy przyjmuje wartość 1, gdy reguła rj pokrywa obiekt ui, w przeciwnym przypadku 0.
- Obliczenie minimalnego zbioru uogólnionych reguł klasy Dk.
Minimalny zbiór uogólnionych reguł reprezentujących (pokrywających) klasę Dk można wyznaczyć obliczając minimalne pokrycie kolumnowe TP.
Ze względu na złożoność obliczeniową, zadanie generowania reguł nie jest zwykle możliwe do rozwiązania w czasie wielomianowym. W szczególności zbiór pokryć macierzy Mp może zawierać zbyt wiele elementów, aby program mógł znaleźć rozwiązanie w rozsądnym czasie.
9.2. Sekwencyjne pokrywanie
Najprostszym algorytmem heurystycznym indukcji reguł jest sekwencyjne pokrywanie (sequential covering). W algorytmie tym tworzona jest reguła pokrywająca część obiektów bazowego zbioru treningowego danej klasy decyzyjnej, a obiekty spełniające tę regułę są usuwane. Proces jest powtarzany dla pozostałych obiektów, aż do pokrycia wszystkich obiektów tej klasy. Taką samą procedurę stosuje się dla wszystkich pozostałych klas decyzyjnych.
Tablica 2.44
A |
a |
b |
c |
d |
e |
1 |
1 |
0 |
0 |
1 |
1 |
2 |
1 |
0 |
0 |
0 |
1 |
3 |
0 |
0 |
0 |
0 |
0 |
4 |
1 |
1 |
0 |
1 |
0 |
5 |
1 |
1 |
0 |
2 |
2 |
6 |
2 |
2 |
0 |
2 |
2 |
7 |
2 |
2 |
2 |
2 |
2 |
Dla systemu decyzyjnego A podanego w tabl. 2.44, w którym a, b, c, d są atrybutami warunkowymi, natomiast e jest atrybutem decyzyjnym, obliczymy reguły decyzyjne dla klasy e = 1.
Najpierw obliczymy macierz M1 generowaną obiektem u1 (pierwszy wiersz tablicy). Porównując u1 z każdym obiektem z klasy nie należącym do klasy decyzyjnej e = 1, otrzymujemy następującą macierz porównań M1:
Łatwo wykazać, że minimalne pokrycia kolumnowe dla M1, to: {<i>a</i>, <i>b</i>} oraz {<i>b</i>, <i>d</i>}, tzn.
(a + d)(b)(b + d)(a + b + d)(a + b + c + d) = ab + bd
Pokrycia te można obliczyć wykorzystując również algorytm uzupełnienia funkcji boolowskiej przedstawiony w podrozdziale 2.5. Wyznaczone w ten sposób minimalne reguły wynoszą odpowiednio:
(a,1) & (b,0) ® (e,1)
(b,0) & (d,1) ® (e,1)
Podobnie dla obiektu u2 mamy:
czyli minimalne reguły to:
(a,1) & (b,0) ® (e,1)
(a,1) & (d,0) ® (e,1)
Łatwo zauważyć, że reguła (a,1) & (b,0) ® (e,1), podobnie jak w metodzie ekspansji funkcji boolowskiej, pokrywa wszystkie reguły pierwotne systemu decyzyjnego A i klasy e = 1.
Postępując analogicznie dla pozostałych klas decyzyjnych, tzn. e = 0 oraz dla e = 2, otrzymujemy następujące reguły uogólnione (jedno z możliwych rozwiązań):
(a,1) & (b,0) ® (e,1)
(a,0) ® (e,0)
(b,1) & (d,1) ® (e,0)
(d,2) ® (e,2)
lub w innym zapisie:
(a,1) & (b,0) ® (e,1)
(a,0) Ú (b,1) & (d,1) ® (e,0)
(d,2) ® (e,2)
Tablicowy zapis powyższych reguł podano w tablicy 2.45. Można również zauważyć, że w wyniku indukcji reguł uległ redukcji argument c, co oznacza, że jest on atrybutem zbędnym.
Tablica 2.45
a |
b |
c |
d |
e |
1 |
0 |
– |
– |
1 |
0 |
– |
– |
– |
0 |
– |
1 |
– |
1 |
0 |
– |
– |
– |
2 |
2 |
10. Zadania
Zminimalizować metodą tablic Karnaugha funkcje boolowskie reprezentujące wyjścia c, e, f dekodera wskaźnika siedmiosegmentowego z tablicy 2.2.
Dla funkcji F opisanej podziałami P1 do P8 oraz PF zmienne niezbędne są x6 oraz x8. Należy wyznaczyć wszystkie realizacje minimalno argumentowe tej funkcji.
Dla podanej tablicy decyzyjnej (tabl. 2.46) obliczyć wszystkie minimalne zbiory atrybutów. Przyjąć, że atrybutem „niezbędnym” jest f
Tablica 2.46
U |
a |
b |
d |
c |
e |
f |
g |
1 |
2 |
2 |
1 |
2 |
1 |
1 |
3 |
2 |
2 |
2 |
1 |
1 |
1 |
1 |
3 |
3 |
2 |
1 |
1 |
3 |
1 |
2 |
1 |
4 |
3 |
3 |
2 |
4 |
3 |
1 |
2 |
5 |
3 |
3 |
2 |
3 |
1 |
2 |
3 |
6 |
2 |
2 |
1 |
1 |
1 |
2 |
1 |
7 |
2 |
1 |
1 |
4 |
3 |
1 |
2 |
8 |
1 |
3 |
2 |
4 |
3 |
1 |
2 |
Dla danych zapisanych w tabl. 2.47 obliczyć zbiór minimalnych reguł decyzyjnych dla decyzji e.
Tablica 2.47
U |
a |
b |
c |
d |
e |
1 |
2 |
2 |
2 |
2 |
0 |
2 |
2 |
2 |
0 |
2 |
0 |
3 |
1 |
1 |
0 |
2 |
0 |
4 |
1 |
1 |
0 |
1 |
1 |
5 |
0 |
0 |
0 |
0 |
1 |
6 |
1 |
1 |
1 |
1 |
2 |
7 |
0 |
1 |
0 |
0 |
2 |
8 |
0 |
1 |
0 |
1 |
2 |
11. Bibliografia
[2.1] Brayton R.K., Hachtel G.D., McMullen C.T., Sangiovanni-Vincentelli A.: Logic Minimization Algorithms for VLSI Synthesis, Kluwer Academic Publishers, 1984.
[2.2] De Micheli G.: Synteza i optymalizacja układów cyfrowych. WNT, Warszawa 1998.
[2.3] Kamionka-Mikuła H., Małysiak H., Pochopień B.: Praktyczna teoria układów cyfrowych, Wydawnictwo Politechniki Śląskiej, Gliwice 2011.
[2.4] Kamionka-Mikuła H., Małysiak H., Pochopień B.: Synteza i analiza układów cyfrowych. Wydawnictwo Pracowni Komputerowej Jacka Skalmierskiego, 2011.
[2.5] Lala P. K.: Practical Digital Logic Desing and Testing. Prentice-Hall, 1996.
[2.6] Łuba T., Rybnik J.: Rough Sets and Some Aspects in Logic synthesis. In: Słowiński R. (ed.): Intelligent Decision Support – Handbook of Application and Advances of the Rough Sets Theory, Kluwer Academic Publishers, 1992.
[2.7] Łuba T., Ojrzeńska-Wójter D.: Układy logiczne w zadaniach. Oficyna Wydawnicza Politechniki Warszawskiej, 2011.
[2.8] Łuba T., Borowik G.: Synteza logiczna. Oficyna Wydawnicza Politechniki Warszawskiej, 2015.
[2.9] Łuba T.(red.), Rawski M., Tomaszewicz P., Zbierzchowski B.: Programowalne układy przetwarzania sygnałów i informacji, WKŁ, Warszawa 2008.
[2.10] Pawlak Z.: Rough Sets: Theoretical Aspects of Reasoning about Data. Kluwer Academic Publishers, 1991.
[2.11] Pochopień B.: Podstawy techniki cyfrowej. Wydawnictwo Wyższej Szkoły Biznesu w Dąbrowie Górniczej, 2011.
[2.12] Stańczyk U., Cyran K., Pochopień B.: Theory of logic Circuits. Vol. 1. – Fundamental issues. Publishers of the Silesian University of Technology, Gliwice 2007.
[2.13] Stańczyk U., Cyran K., Pochopień B.: Theory of logic circuits – Vol. 2 – Fundamental issues. Publishers of the Silesian University of Technology, Gliwice 2007.
[2.14] Sasao T.: Index Generation Functions, Logic Synthesis for Pattern Matching, EPFL Workshop on Logic Synthesis & Verification, Dec. 2015.
[2.15] Zieliński C.: Podstawy projektowania układów cyfrowych. Wydawnictwo Naukowe PWN, Warszawa 2003.
[2.16] Borowik G., Łuba T., Fast Algorithm of Attribute Reduction Based on the Complementation of Boolean Function, in Advanced Methods and Applications in Computational Intelligence, s. Topics in Intelligent Engineering and Informatics, Eds. R. Klempous, J. Nikodem, W. Jacak, Z. Chaczko, Ch. 2, pp. 25-41, Springer International Publishing, 2014, DOI: 10.1007/978-3-319-01436-4_2.
[2.17] Brayton R.K., Hachtel G.D., McMullen C.T., Sangiovanni-Vincentelli A.: Logic Minimization Algorithms for VLSI Synthesis, Kluwer Academic Publishers, 1984.
[2.18] Grzymala-Busse J.W., Hu M.: A Comparison of Several Approaches to Missing Attribute Values in Data Mining. In: Ziarko W., Yao Y. (eds.): Rough Sets and Current Trends in Computing 2000, LNAI 2005, pp. 378−385, Springer-Verlag, Berlin, 2001.
[2.19] Komorowski J., Pawlak Z., Polkowski L., Skowron A.: Rough sets: A tutorial (1999).
[2.20] Kryszkiewicz M., Lasek P.: FUN: Fast Discovery of Minimal Sets of Attributes Functionally Determining a Decision Attribute. In: Peters J.F. et al. (eds.): Transactions on Rough Sets IX, LNCS 5390, pp. 76–95, Springer-Verlag, Berlin, 2008.
[2.21] Łuba T. (et al.): Rola i znaczenie syntezy logicznej w eksploracji danych dla potrzeb telekomunikacji i medycyny. Przegląd Telekomunikacyjny i Wiadomości Telekomunikacyjne, Nr. 5, 2014.
[2.22] Łuba T., Borowik G.: Synteza logiczna, Oficyna Wydawnicza PW, Warszawa 2015.
[2.23] Pawlak Z.: Rough Sets: Theoretical Aspects of Reasoning about Data. Kluwer Academic Publishers, 1991.
[2.24] Skowron A., Rauszer C.: The Discernibility Matrices and Functions in Information Systems. In: Słowiński R. (ed.): Intelligent Decision Support – Handbook of Application and Advances of the Rough Sets Theory, Kluwer Academic Publishers, 1992.
[2.25] Stefanowski J.: Algorytmy indukcji reguł decyzyjnych w odkrywaniu wiedzy. Rozprawa habilitacyjna, wersja z 8 lutego 2001, Wydawnictwo Politechniki Poznańskiej, Seria Rozprawy nr 361, 2001.
[2.26] 26 ROSE2 – Rough Sets Data Explorer, http://idss.cs.put.poznan.pl/site/rose.html
[2.27] ROSETTA – A Rough Set Toolkit for Analysis of Data, http://www.lcb.uu.se/tools/rosetta/
[2.28] RSES – Rough Set Exploration System, http://logic.mimuw.edu.pl/~rses/
[2.29] UC Irvine Machine Learning Repository, http://archive.ics.uci.edu/ml/