5.3.4 Hexagon-Algorithmus

Transkript

1 5.3.4 Hexagon-Algorithmus Der Hexagon-Algorithmus nutzt die Verbandseigenschaften des BTG für eine Optimierung aus. Verwendet dazu den explizit erstellten BTG in Form eines Feldes. Der Algorithmus besteht aus 3 Phasen: 1. Konstruktion des BTG 2. Zuweisung von Eingabe-Tupeln an die Äquivalenzklasse (Knoten im BTG) 3. Entfernen von dominierten Tupeln Prof. Kießling

2 Knotenidentifizierung per Kantengewichte Eine Kante von einem Knoten zu einen anderen zeigt Dominanz: (0,0) (0,1): ist dominiert von (0,0) bezüglich P 2 (0,1) (1,0) (1,0): ist dominiert von (0,0) bezüglich P 1 Kanten können also nach den ihnen zugeordneten Präferenzen unterschieden werden. Für P = (P 1,, P m ) gibt es als m verschiedene Kantentypen. Gewicht einer Kante, die bezüglich P i dominiert wird: weight ( P i ) = m j= i +1 ( max( P j )+1) falls definiert, ansonsten 1. Prof. Kießling

3 Beispiel: (0,0) level 0 weight(p 2 ) = 1 weight(p 1 ) = max(p 2 ) + 1 = 4 (0,1) (1,0) level 1 (0,2) (1,1) (2,0) level 2 (0,3) (1,2) (2,1) level 3 Ziel: Ordne den Knoten mit Hilfe von Kantengewichten eine eindeutige Knoten-ID zu. (1,3) (2,3) (2,2) level 4 level 5 Prof. Kießling

4 Eindeutige Knoten-ID: Eindeutige natürliche Zahl für jeden Knoten: NID( a 1,..., a m ) = ( weight ( P i ) a i ) i = 1 Eigenschaften: Die Summe der Kantengewichte auf jedem beliebigem Pfad vom eindeutigem Top-Element zu irgendeinem Knoten ist identisch und gibt die Knoten-ID an. Alle Zahlen aus dem Intervall [0, BTG -1] sind zulässige Knoten-IDs. m weight(p 2 ) = 1 weight(p1) = 4 2:(0,2) 3:(0,3) 1:(0,1) 7:(1,3) 0:(0,0) 5:(1,1) 6:(1,2) 11:(2,3) 4:(1,0) 10:(2,2) Prof. Kießling :(2,0) 9:(2,1)

5 Konstruktion des BTG Berechne die BTG-Größe BTG 1) Initialisiere die richtig dimensionierten Felder - next[ BTG ] für eine Breitensuche - nodes[ BTG ] als Speicher für Eingabe-Tupeln 1) In einer Laufschleife von [0, BTG -1] über alle Knoten tue: - Berechne das Level des jeweiligen Knotens. - Setze next[knoten-id] des jeweiligen Knotens. 0:(0,0) 1:(0,1) 4:(1,0) 2:(0,2) 5:(1,1) 8:(2,0) 3:(0,3) 6:(1,2) 9:(2,1) 7:(1,3) 10:(2,2) 11:(2,3) Prof. Kießling

6 Zuweisung der Eingabe-Tupeln zu BTG-Knoten 1) In einer Laufschleife über alle Eingabe-Tupeln tue: - Berechne die Knoten-ID - Trage das aktuelle Tupel im Speicher von nodes[knoten-id] ein. 0:(0,0) 1:(0,1) 4:(1,0) 2:(0,2) 5:(1,1) 8:(2,0) 3:(0,3) 6:(1,2) 9:(2,1) 7:(1,3) 10:(2,2) 11:(2,3) Prof. Kießling

7 Entfernen von dominierten Tupeln 1) In einer Laufschleife über alle Knoten eines Levels mit aufsteigendem Level (folge next[ ]: Breitensuche) tue: a) Entferne alle Knoten aus next[ ], die von keinem Eingabe-Tupel belegt sind bzw. b) Entferne alle Knoten die von dominanten Knoten beherrscht werden (Tiefensuche): Folge dazu allen Kanten des aktuellen Knotens, wobei das Gewicht der rekursiv besuchten ausgehenden Kanten immer kleiner gleich dem Gewicht der eingehenden Kante sein muss. Die Reihenfolge der Startkanten ist aufsteigend gemäß Gewicht. 0:(0,0) 1:(0,1) 4:(1,0) 2:(0,2) 5:(1,1) 8:(2,0) 3:(0,3) 6:(1,2) 9:(2,1) 7:(1,3) 10:(2,2) 11:(2,3) Prof. Kießling

8 Zwischenergebnis: 0:(0,0) 1:(0,1) 4:(1,0) 2:(0,2) 5:(1,1) 8:(2,0) 3:(0,3) 6:(1,2) 9:(2,1) 7:(1,3) 10:(2,2) 11:(2,3) Prof. Kießling

9 1) In einer Laufschleife tue: a) Entferne alle Knoten aus next[ ], die von keinem Eingabe-Tupel belegt sind bzw. b) Entferne alle Knoten aus next[ ], die von dominanten Knoten beherrscht werden (Tiefensuche): Folge dazu allen Kanten des aktuellen Knotens, wobei das Gewicht der rekursiv besuchten ausgehenden Kanten immer kleiner gleich dem Gewicht der eingehenden Kante sein muss. Die Reihenfolge der Startkanten ist aufsteigend gemäß Gewicht. 5:(1,1) 8:(2,0) 3:(0,3) 6:(1,2) 9:(2,1) 7:(1,3) 10:(2,2) 1. Startkante: weight(p 2 ) = 1 11:(2,3) Prof. Kießling

10 1) In einer Laufschleife tue: a) Entferne alle Knoten aus next[ ], die von keinem Eingabe-Tupel belegt sind bzw. b) Entferne alle Knoten aus next[ ], die von dominanten Knoten beherrscht werden (Tiefensuche): Folge dazu allen Kanten des aktuellen Knotens, wobei das Gewicht der rekursiv besuchten ausgehenden Kanten immer kleiner gleich dem Gewicht der eingehenden Kante sein muss. Die Reihenfolge der Startkanten ist aufsteigend gemäß Gewicht. 3:(0,3) 5:(1,1) 8:(2,0) 9:(2,1) 10:(2,2) 2. Startkante: weight(p 1 ) = 4 11:(2,3) Prof. Kießling

11 Zwischenergebnis: 5:(1,1) 8:(2,0) 3:(0,3) 9:(2,1) 5:(1,1) 8:(2,0) 10:(2,2) 11:(2,3) 3:(0,3) Über link[5] und link[8] endet der Algorithmus, ohne dass 1a) oder 1b) angewendet werden können. Prof. Kießling

12 Beispiel zu Hexagon: ID color hp level P1 level P2 t 1 green t 2 white t 3 yellow t 4 blue t 5 red t 6 black t 7 silver t 8 red P 1 = POS/POS(color,{black, silver}; {red}, ~ P1 )) P 2 = BETWEEN 20 (hp, [120, 150], ~ P1 )) P = P 1 P 2 max(p 1 ) = 2 max(p 2 ) = 3 BTG = (2+1) * (3+1) = 12 weight(p 2 ) = 1 weight(p 1 ) = 4 next[12], nodes[12] Prof. Kießling

13 I. Konstruktion des BTG: 0:(0,0) max(p 1 ) = 2 max(p 2 ) = 3 1:(0,1) 4:(1,0) BTG = (2+1) * (3+1) = 12 2:(0,2) 5:(1,1) 8:(2,0) weight(p 2 ) = 1 weight(p 1 ) = 4 3:(0,3) 6:(1,2) 9:(2,1) Felder für Verwaltung: next[12], nodes[12] 7:(1,3) 11:(2,3) 10:(2,2) Prof. Kießling

14 II. Einfügen: ID color hp level P1 level P2 nid t 1 green t 2 white t 3 yellow t 4 blue t 5 red t 6 black :(0,0) 1:(0,1) 4:(1,0) 2:(0,2) 5:(1,1) 8:(2,0) 3:(0,3) 6:(1,2) 9:(2,1) t 7 silver :(1,3) 10:(2,2) t 8 red :(2,3) Prof. Kießling

15 Hexagon Beispiel: Löschen III. Löschen: a) Kein Eintrag in nodes[0] 0:(0,0) 1:(0,1) 4:(1,0) 2:(0,2) 5:(1,1) 8:(2,0) 3:(0,3) 6:(1,2) 9:(2,1) 7:(1,3) 10:(2,2) 11:(2,3) Prof. Kießling

16 weight(p 2 ) = 1 weight(p 1 ) = 4 0:(0,0) b) Eintrag t 7 (0,1) in nodes[1] 1:(0,1) 4:(1,0) a) kein Eintrag in nodes[2], gelöscht 2:(0,2) 5:(1,1) 8:(2,0) b) Eintrag t 6 (0,3) in nodes[3] wird dominiert, daher gelöscht. b) terminiert. 3:(0,3) 6:(1,2) 9:(2,1) 7:(1,3) 10:(2,2) 11:(2,3) Prof. Kießling

17 weight(p 2 ) = 1 weight(p 1 ) = 4 0:(0,0) b) Eintrag t 7 (0,1) in nodes[1] 1:(0,1) 4:(1,0) a) kein Eintrag in nodes[5], gelöscht weight(p 2 ) = 1 b) Eintrag t 8 (1,2) in nodes[6] wird dominiert, daher gelöscht. 2:(0,2) 3:(0,3) 5:(1,1) 6:(1,2) 8:(2,0) 9:(2,1) b) Eintrag t 5 (1,3) in nodes[7] wird dominiert, daher gelöscht. 7:(1,3) 10:(2,2) Terminiert. 11:(2,3) Prof. Kießling

18 b) Eintrag t 7 (0,1) in nodes[1] weight(p 2 ) = 1 weight(p 1 ) = 4 1:(0,1) 0:(0,0) 4:(1,0) b) Einträge t 1 (2,1) und t 2 (2,1) in nodes[9] werden dominiert, daher gelöscht. weight(p 1 ) = 4 5:(1,1) 6:(1,2) 8:(2,0) 9:(2,1) a) kein Eintrag in nodes[10], gelöscht 7:(1,3) 10:(2,2) b) Eintrag t 4 (2,3) in nodes[11] wird dominiert, daher gelöscht. 11:(2,3) b) Terminiert. Prof. Kießling

19 0:(0,0) a) Kein Eintrag in nodes[4], daher gelöscht. 4:(1,0) 1:(0,1) 4:(1,0) 8:(2,0) 9:(2,1) 10:(2,2) 11:(2,3) Prof. Kießling

20 4:(1,0) 1:(0,1) III terminiert: 4:(1,0) 1:(0,1) 4:(1,0) 8:(2,0) 8:(2,0) Die BMO-Menge gesteht aus {t 3, t 7 }. 0:(0,0) ID color hp level P1 level P2 nid t 1 green t 2 white t 3 yellow t 4 blue t 5 red t 6 black t 7 silver t 8 red Prof. Kießling

21 Leistungsfähigkeit von Hexagon Die Beurteilung der Leistungsfähigkeit eines Algorithmus lässt sich einerseits durch sein Komplexitätsmaß oder andrerseits durch einen Benchmark über Daten mit unterschiedlichen Verteilungen im Wettbewerb mit vergleichbaren Algorithmen bestimmen. Prof. Kießling

22 Komplexität Zur Bestimmung der Komplexität von σ[p](r) mittels Hexagon sei bekannt: Pareto-Präferenz P = P 1 P m, wobei alle P i reguläre WOPs sind. Die Anzahl der Tupel der Relation R sei gegeben als R = n. Prof. Kießling

23 Dann ist die Komplexität (worst-case = best-case) gegeben durch: Speicherbedarf in DB-Cache (unabhängig von n): Beachte: Hexagon ist nur anwendbar, falls der DB-Cache groß genug ist für den BTG! Zeit-Bedarf: Lesen und Einfügen der Tupel in den BTG: O(n) // IO-Kosten Löschen durch Tiefensuche: O( BTG ) // CPU-Kosten Prof. Kießling

24 Benchmark Mit Hilfe verschiedener Testmengen als Input für einen Benchmark kann die Leistungsfähigkeit von Algorithmen für die Berechnung der Ergebnismenge des Pareto- Konstruktors miteinander verglichen werden. LESS: LESS ++ : Hexagon: basiert auf einen BNL-Algorithmus. basiert auf LESS-Algorithmus, erweitert um Pruning-Methoden, wie sie auch von BNL ++ benutzt werden. BTG-basierter Algorithmus Prof. Kießling

25 Unter der Voraussetzung, dass die Daten der Algorithmen vollständig im Hauptspeicher gehalten werden können, ergibt sich in Abhängigkeit von der Anzahl der mit Pareto verknüpften Präferenzen folgendes Laufzeitverhalten: Prof. Kießling

26 Eine weiterer Benchmark vergleicht die Abhängigkeit von der Tupelanzahl von Testmengen mit folgenden statistischen Eigenschaften: Korrelierte Daten: Daten, die in einer Dimension als gut betrachtet werden, sind auch in einer anderen Dimension gut. Beispiel: Studierende: kurze Studiendauer gute Abschlussnote Antikorrelierte Daten: Daten, die in einer Dimension als gut betrachtet werden, sind in einer oder in allen anderen Dimensionen schlecht. Beispiel: Hotels: hohe Qualität niedriger Preis Statistisch unabhängige Daten Hinweis: Es wird ein logarithmischer Maßstab in den nachfolgenden Abbildungen verwendet. Prof. Kießling

27 Laufzeit in Abhängigkeit von der Anzahl der Eingabetupel bei korrelierten Daten: Prof. Kießling

28 Laufzeit in Abhängigkeit von der Anzahl der Eingabetupel bei antikorrelierten Daten: Prof. Kießling

29 Laufzeit in Abhängigkeit von der Anzahl der Eingabetupel bei statistisch unabhängigen Daten: Prof. Kießling

30 5.3.6 Scalagon Algorithmus Scalagon: Kombination von Hexagon und BNL (M. Endres, P. Roocks and W. Kießling Scalagon: An Efficient Skyline Algorithm for All Seasons. Database Systems for Advanced Application (DASFAA) 2015) Prof. Kießling

31 Diskretisiere Wertebereich auf [1,...,S 1 ] x [1,...,S 2 ] Beispiel: Domäne D = [1,...,30] x [1,...,40] Beispiel für Skalierungsfaktor s = 10: D / s = [1,...,3] x [1,...,4] Verbandsstruktur bleibt erhalten (0, 0) (S1, 0) (0, S2) (S1, S2) Prof. Kießling

32 Phase 1: Entferne dominierte Kacheln - Pareto-Ordnung P auf Tupeln induziert Produktordnung P* auf Kacheln: (0, 0) (1, 0) (0, 1) (x 1, x 2 ) < P* (y 1, y 2 ) <=> x 1 < P1 y 1 x 2 < P2 y 2 (0, 2) Beispiel: Kachel (0,1) dominiert Kachel (1,2). Kachel (0,2) dominiert Kachel (1,3). Kachel (1,1) dominiert Kachel (2,2). (2, 0) (0, 3) Kachel (1,0) dominiert nicht Kachel (2,0) bezüglich der Produktordnung P*. - ähnlich wie Standard-Hexagon (2, 2) (2, 3) (1, 3) Prof. Kießling

33 Ergebnis der Phase 1 nicht dominierte Kacheln nicht dominierte Kacheln Prof. Kießling

34 Phase 2: Standard-BNL gemäß Pareto-Ordnung P über alle übrig gebliebenen Tupel - finde die besten Tupel aus allen nicht-dominierten Kacheln. Prof. Kießling

35 Kritischer Punkt: Wahl des Skalierungsfaktors α s 1 := := s d := ( N / α) 1/d (N ist die Grundmenge der Tupel) Beispiel: N = 10000, d = 2 α = 0,1 : s 1 := := s d := ( / 0,1) 1/2 = 316 α = 1 : s 1 := := s d := ( / 1) 1/2 = 100 α = 10 : s 1 := := s d := ( / 10) 1/2 = 31 α = 100 : s 1 := := s d := ( / 100) 1/2 = 10 α = 9900: s 1 := := s d := ( / 9900) 1/2 = 1 lim α 0 : jedes Tupel auf eigener Kachel (ähnlich Hexagon) lim α : alle Tupel auf einer Kachel (ähnlich BNL) α -Werte zwischen 10 und 50 sind meist zutreffend. Prof. Kießling

36 Performance in 2 Dimensionen (10 7 Tupel, Korrelation von -0,7) Prof. Kießling

37 - Vergleich BNL / Hexagon / Scalagon mit α = 2 => bringt keinen Vorteil Prof. Kießling

38 - Vergleich BNL / Hexagon / Scalagon mit α = 10 => deutlicher Geschwindigkeitsvorteil vor Hexagon. BNL und Scalagon sind fast gleich gut ( Tupel sind für BNL kein Problem) Prof. Kießling

39 - Vergleich BNL / Hexagon / Scalagon mit α = 10 => deutliche Geschwindigkeitsvorteil vor BNL und Hexagon! Prof. Kießling

40 5.3.7 Zusammenfassung Datenbank-Technologie bietet eine exzellente Unterstützung für Präferenzen und Personalisierung mit Hinblick auf: Leichte Modellierung (Präferenzen durch Konstruktoren für strikte partielle Ordnungen) Hohe Effizienz (Transformationen in Preference Relational Algebra, Optimierung der Join-Reihenfolge mit Präferenzen, BNL ++, Hexagon) Hinweis: Transitivität ist essentiell! Ansonsten wird die Berechnung der Präferenz-Selektion ineffizient. Weitere Optimierungsmöglichkeiten: Speicheroptimierung bei dünn besetzten BTGs Durch d-parameter kann bereits in der Modellierung Einfluss auf die Größe des BTGs genommen werden. Prof. Kießling

41 5.3.8 Weiterführende Literatur S. Borzsonyi, D. Kossmann and K. Stocker: The Skyline Operator IEEE Conf. on Data Engineering pp , Heidelberg, Germany, BNL P. Godfrey, R. Shipley and J. Gryz: Algorithms and Analyses for Maximal Vector Computation VLDB Journal, 16(1): 5 28, LESS M. Endres, P. Roocks, W. Kießling: Scalagon: An Efficient Skyline Algorithm for All Seasons Database Systems for Advanced Application (DASFAA) 2015 Prof. Kießling

42 T. Preisinger: Graph-based Algorithms for Pareto Preference Query Evaluation Dissertation, Universität Augsburg, Juli T. Preisinger, W. Kießling and M. Endres: The BNL++ Algorithm for Evaluating Pareto Preference Queries Proceedings of the ECAI 2006 Multidisciplinary Workshop on Advances in Preference Handling Riva del Garda, Italy, August T. Preisinger, W. Kießling: The Hexagon Algorithm for Pareto Preference Queries Proceedings of the 3rd Multidisciplinary Workshop on Advances in Preference Handling in conjunction with VLDB 2007, Vienna, Austria, September Prof. Kießling

43 S. Mandl, O. Kozachuk (EXASOL AG), M. Endres, W. Kießling (Universität Augsburg): Preference Analytics in EXASolution Datenbanksysteme für Business, Technologie und Web (BTW), 16 Hamburg, Germany, March Prof. Kießling