15 research outputs found
Improving Expressivity of Graph Neural Networks using Localization
In this paper, we propose localized versions of Weisfeiler-Leman (WL)
algorithms in an effort to both increase the expressivity, as well as decrease
the computational overhead. We focus on the specific problem of subgraph
counting and give localized versions of WL for any . We analyze the
power of Local WL and prove that it is more expressive than WL and at
most as expressive as WL. We give a characterization of patterns whose
count as a subgraph and induced subgraph are invariant if two graphs are Local
WL equivalent. We also introduce two variants of WL: Layer WL and
recursive WL. These methods are more time and space efficient than applying
WL on the whole graph. We also propose a fragmentation technique that
guarantees the exact count of all induced subgraphs of size at most 4 using
just WL. The same idea can be extended further for larger patterns using
. We also compare the expressive power of Local WL with other GNN
hierarchies and show that given a bound on the time-complexity, our methods are
more expressive than the ones mentioned in Papp and Wattenhofer[2022a]
Efficient Frequent Subtree Mining Beyond Forests
A common paradigm in distance-based learning is to embed the instance space into some appropriately chosen feature space equipped with a metric and to define the dissimilarity between instances by the distance of their images in the feature space. If the instances are graphs, then frequent connected subgraphs are a well-suited pattern language to define such feature spaces. Identifying the set of frequent connected subgraphs and subsequently computing embeddings for graph instances, however, is computationally intractable. As a result, existing frequent subgraph mining algorithms either restrict the structural complexity of the instance graphs or require exponential delay between the output of subsequent patterns. Hence distance-based learners lack an efficient way to operate on arbitrary graph data. To resolve this problem, in this thesis we present a mining system that gives up the demand on the completeness of the pattern set to instead guarantee a polynomial delay between subsequent patterns. Complementing this, we devise efficient methods to compute the embedding of arbitrary graphs into the Hamming space spanned by our pattern set. As a result, we present a system that allows to efficiently apply distance-based learning methods to arbitrary graph databases. To overcome the computational intractability of the mining step, we consider only frequent subtrees for arbitrary graph databases. This restriction alone, however, does not suffice to make the problem tractable. We reduce the mining problem from arbitrary graphs to forests by replacing each graph by a polynomially sized forest obtained from a random sample of its spanning trees. This results in an incomplete mining algorithm. However, we prove that the probability of missing a frequent subtree pattern is low. We show empirically that this is true in practice even for very small sized forests. As a result, our algorithm is able to mine frequent subtrees in a range of graph databases where state-of-the-art exact frequent subgraph mining systems fail to produce patterns in reasonable time or even at all. Furthermore, the predictive performance of our patterns is comparable to that of exact frequent connected subgraphs, where available. The above method considers polynomially many spanning trees for the forest, while many graphs have exponentially many spanning trees. The number of patterns found by our mining algorithm can be negatively influenced by this exponential gap. We hence propose a method that can (implicitly) consider forests of exponential size, while remaining computationally tractable. This results in a higher recall for our incomplete mining algorithm. Furthermore, the methods extend the known positive results on the tractability of exact frequent subtree mining to a novel class of transaction graphs. We conjecture that the next natural extension of our results to a larger transaction graph class is at least as difficult as proving whether P = NP, or not. Regarding the graph embedding step, we apply a similar strategy as in the mining step. We represent a novel graph by a forest of its spanning trees and decide whether the frequent trees from the mining step are subgraph isomorphic to this forest. As a result, the embedding computation has one-sided error with respect to the exact subgraph isomorphism test but is computationally tractable. Furthermore, we show that we can leverage a partial order on the pattern set. This structure can be used to reduce the runtime of the embedding computation dramatically. For the special case of Jaccard-similarity between graph embeddings, a further substantial reduction of runtime can be achieved using min-hashing. The Jaccard-distance can be approximated using small sketch vectors that can be computed fast, again using the partial order on the tree patterns
Eine empirische Studie zur strukturellen Komplexität konzeptioneller Modelle – Grundlegung eines effizienten Ansatzes zur strukturellen Modellanalyse
Für die Analyse konzeptioneller Informationsmodelle existiert eine Vielzahl von Verfahren, die für eine bestimmte Modellierungssprache oder Anwendungsdomäne entwickelt wurden und abgegrenzte Analysezwecke unterstützen. Häufig besteht eine Teilaufgabe der Analyseverfahren in der Identifikation struktureller Modellmuster. Für dieses als Subgraphisomorphie bekannte Problem existieren effiziente, allgemein anwendbare Algorithmen, die bestimmte topologische Eigenschaften der zugrundeliegenden Graphen voraussetzen. Dieser Beitrag präsentiert die Ergebnisse der Untersuchung von 3000 Informationsmodellen und demonstriert, dass die meisten dieser Modelle entsprechende Eigenschaften aufweisen. Er präsentiert eine empirische Studie für die Entwicklung einer allgemein anwendbaren Analysemethode, die in viele Spezialentwicklungen integriert werden kann
Eine empirische Studie zur strukturellen Komplexität konzeptioneller Modelle – Grundlegung eines effizienten Ansatzes zur strukturellen Modellanalyse
Für die Analyse konzeptioneller Informationsmodelle existiert eine Vielzahl von Verfahren, die für eine bestimmte Modellierungssprache oder Anwendungsdomäne entwickelt wurden und abgegrenzte Analysezwecke unterstützen. Häufig besteht eine Teilaufgabe der Analyseverfahren in der Identifikation struktureller Modellmuster. Für dieses als Subgraphisomorphie bekannte Problem existieren effiziente, allgemein anwendbare Algorithmen, die bestimmte topologische Eigenschaften der zugrundeliegenden Graphen voraussetzen. Dieser Beitrag präsentiert die Ergebnisse der Untersuchung von 3000 Informationsmodellen und demonstriert, dass die meisten dieser Modelle entsprechende Eigenschaften aufweisen. Er präsentiert eine empirische Studie für die Entwicklung einer allgemein anwendbaren Analysemethode, die in viele Spezialentwicklungen integriert werden kann
Algorithms for graphs of small treewidth
Veel problemen uit de praktijk kunnen worden gemodelleerd als optimaliserings- of beslis-singsproblemen
op grafen. Denk bijvoorbeeld aan het probleem waarbij een koerier een
aantal pakketjes moet afleveren op verschillende adressen in het land. De manager van de
koerier wil dat hij een zo kort mogelijke route aflegt die begint en eindigt bij het koeriers-bedrijf,
en die alle adressen aandoet. Het probleem om zo n kortste route te vinden is het
zogenaamde handelsreizigersprobleem. De invoer kan worden gemodelleerd als een graaf,
waarbij elke knoop in de graaf een adres vertegenwoordigt en elke kant tussen twee knopen
de weg tussen de corresponderende adressen. Elke kant heeft een gewicht dat aangeeft hoe
lang de corresponderende weg is. Het probleem is dan om een cykel in de graaf te vinden die
alle knopen bevat en waarvoor de som van de gewichten van alle kanten in de cykel minimaal
is.
Helaas is het zo dat de meeste problemen op grafen die praktische problemen modelleren
lastig zijn in die zin, dat er waarschijnlijk geen effici¨ ente algoritmen zijn die deze problemen
oplossen. Formeel gezegd zijn deze problemen NP-lastig. Het handelsreizigersprobleem is
een voorbeeld hiervan. Een manier om hiermee om te gaan is om te kijken of er in het
probleem uit de praktijk een structuur zit die maakt dat het probleem effici¨ enter is op te
lossen. Het kan bijvoorbeeld zo zijn dat het gegeven probleem in het algemeen lastig is, maar
dat de grafen die in de praktijk voorkomen een dusdanige structuur hebben dat er wel een
effici¨ ent algoritme voor het probleem bestaat.
Een voorbeeld van een prettige graafstructuur is de boomstructuur: het blijkt dat veel
graafproblemen die in het algemeen lastig zijn, een effici¨ ent algoritme hebben wanneer de
graaf een boom is. Helaas is de boomstructuur erg beperkt: er zijn maar weinig praktische
problemen die kunnen worden gemodelleerd als problemen op bomen. In dit proefschrift kij-ken
we daarom naar een generalisatie van deze structuur, en dat is de boomachtige structuur:
we kijken naar grafen met boombreedte hooguit k of padbreedte hooguit k, waarbij k een
positief geheel getal is.
Intu¨itief gezien geeft de boombreedte van een graaf de mate aan waarin de graaf op een
boom lijkt: hoe groter de gelijkenis, hoe kleiner de boombreedte. Met een graaf van boom-breedte
k kan een boom worden geassocieerd waarbij elke knoop van de boom correspondeert
met een deelgraaf van de graaf op een zodanige manier dat
elke knoop en elke kant van de graaf in tenminste een knoop van de boom voorkomt, en
voor elke knoop v in de graaf geldt dat de knopen in de boom die v bevatten een verbonden
deelboom vormen.
Zo n boom bestaande uit deelgrafen wordt een boomdecompositie van de graaf genoemd.
De breedte van de boomdecompositie is het maximaal aantal knopen van de graaf dat in ´ e´ en
233?Samenvatting
knoop van de boomdecompositie voorkomt, min ´ e´ en. De boombreedte van een graaf is de
minimale breedte over alle boomdecomposities van de graaf (een boom heeft boombreedte
´ e´ en). Een paddecompositie van een graaf is een boomdecompositie die de vorm heeft van
een pad. De padbreedte van een graaf is de minimale breedte over alle paddecomposities van
de graaf. Dus de boombreedte van een graaf is altijd ten hoogste gelijk aan z n padbreedte.
Voor veel problemen zoals het handelsreizigersprobleem is er een effici¨ ent algoritme op
grafen met kleine boombreedte. Het blijkt dat er veel praktische graafproblemen zijn waar-voor
de invoergraaf een kleine boombreedte heeft. Bij al deze problemen helpt dit gegeven
bij het vinden van een effici¨ enter algoritme. Deze algoritmen maken meestal gebruik van
een boomdecompositie van de graaf met kleine breedte. Daarom is het nodig om eerst zo n
boomdecompositie van de graaf te vinden. Hiervoor zijn effici¨ ente algoritmen beschikbaar,
zowel sequentieel als parallel.
Helaas is het zo dat veel algoritmen op grafen met een kleine boombreedte alleen in
theorie efficient zijn: de looptijd van de algoritmen is vaak exponentieel in de boombreedte
van de graaf. Dit geldt bijvoorbeeld voor de algoritmen voor het vinden van een boom- of
paddecompositie van breedte hooguit k van een graaf, waarbij k constant is.
Het doel van dit proefschrift is om effici¨ ente sequenti¨ ele en parallelle algoritmen te ont-werpen
voor problemen op grafen met een kleine boom- of padbreedte. Het doel is om
algoritmen te ontwerpen die niet alleen theoretisch effici¨ ent zijn, maar die ook in praktische
toepassingen effici¨ ent kunnen zijn.
Het proefschrift is als volgt georganiseerd. Hoofdstuk 1 geeft een inleiding. In hoofd-stuk
2 worden formele definities van boom- en padbreedte gegeven, en wordt een aantal ei-genschappen
en bekende resultaten over grafen met een kleine boom- en padbreedte gegeven.
Verder worden definities gegeven die worden gebruikt in de rest van het proefschrift.
In hoofdstuk 3 geven we een volledige karakterisatie van grafen met padbreedte twee.
Deze karakterisatie wordt vervolgens gebruikt voor een effici¨ ent sequentieel algoritme dat
beslist of een graaf padbreedte ten hoogste twee heeft en, als dat zo is, een paddecompositie
van minimale breedte vindt. De karakterisatie wordt ook gebruikt in de algoritmen die zijn
beschreven in hoofdstuk 4.
Hoofdstuk 4 gaat over twee problemen welke hun oorsprong vinden in de moleculaire
biologie. In beide problemen bestaat de invoer uit een aantal copie¨ en van een DNA string
welke in fragmenten zijn opgedeeld. Voor elk paar van fragmenten is informatie beschikbaar
over de overlap tussen die twee fragmenten: ´ of we weten dat de fragmenten zeker overlappen,
´ of we weten dat ze zeker niet overlappen, ´ of we weten niets. Met behulp van deze informatie
moet de volledige overlap informatie tussen elk tweetal fragmenten worden berekend, dat wil
zeggen dat voor elk tweetal fragmenten moet worden berekend of ze wel of niet overlappen.
Dit probleem heet k-INTERVALIZING SANDWICH GRAPHS of k-ISG, waarbij k het aantal
copie¨ en is dat is gefragmenteerd. In de tweede variant is ook nog bekend dat alle fragmenten
gelijke lengte hebben. Deze variant heet k-UNIT-INTERVALIZING SANDWICH GRAPHS of k-UISG.
De invoer van beide problemen kan worden gemodelleerd als een graaf. Het blijkt dat
de volledige overlap informatie alleen kan worden berekend wanneer die graaf padbreedte
ten hoogste k heeft, waarbij k weer het aantal copie¨ en is. In Hoofdstuk 4 geven we een
234?Samenvatting
kwadratisch algoritme voor 3-ISG, en we bewijzen dat k-ISG NP-moeilijk is wanneer k 4.
Verder geven we een lineair algoritme voor 3-UISG.
Hoofstukken 5 9 gaan over een speciaal soort algoritmen, namelijk reductie algorit-men.
Een reductie algoritme is een algoritme waarin een reeks reducties wordt uitgevoerd op
de invoergraaf. Het gedrag van de reducties is beschreven in een verzameling van reductie
regels, welke afhangen van het probleem waarvoor het algoritme is. Wanneer de reductie re-gels
aan bepaalde voorwaarden voldoen kan het reductie algoritme lineaire tijd gebruiken (of
logaritmische tijd in het geval van een parallel reductie algoritme). De reductie algoritmen
zijn eenvoudig: de moeilijkheden van het probleem zitten verstopt in de verzameling reductie
regels, en niet in het algoritme.
Er zijn hele klassen van problemen op grafen met begrensde boombreedte waarvoor een
verzameling van reductie regels kan worden geconstrueerd. Het voordeel van reductie algo-ritmen
voor het oplossen van problemen op grafen met begrensde boombreedte is dat er geen
boomdecompositie van de graaf nodig is: de algoritmen werken direct op de graaf.
In hoofdstuk 5 geven we een overzicht van de bestaande theorie¨ en over reductie algorit-men.
We combineren verschillende bestaande idee¨ en en presenteren ze als een geheel. Dit
hoofdstuk is tevens een inleiding voor hoofdstukken 6 9.
Reductie algoritmen hebben als nadeel dat ze alleen optimaliserings- en beslissingspro-blemen
kunnen oplossen: bij een optimaliseringsprobleem wordt alleen de optimale waarde
teruggegeven, maar niet een oplossing waarvoor de waarde optimaal is. Bij beslissingspro-blemen
wordt alleen het antwoord ja of nee gegeven, maar als het antwoord ja is wordt
geen oplossing gegeven. In hoofdstuk 6 breiden we de theorie van reductie algoritmen uit
naar constructieve reductie algoritmen welke ook een (optimale) oplossing teruggeven, mits
er een is. We laten zien dat voor veel problemen op grafen met begrensde boombreedte waar-voor
reductie algoritmen kunnen worden toegepast, ook de constructieve reductie algoritmen
kunnen worden toegepast.
In hoofdstuk 7 passen we de theorie¨ en welke zijn gepresenteerd in hoofdstukken 5 en 6
toe op een aantal optimaliseringsproblemen.
In hoofdstukken 8 en 9 gebruiken we de theorie¨ en uit hoofdstuk 6, aangevuld met nieuwe
idee¨ en, om effici¨ ente, constructieve parallelle reductie algoritmen te verkrijgen voor de vol-gende
twee aanverwante problemen:
gegeven een graaf, bepaal of hij series-parallel is, en zo ja, vind dan een sp-boom van
de graaf,
gegeven een graaf, bepaal of hij boombreedte hooguit twee heeft, en zo ja, maak een
boomdecompositie van breedte twee van de graaf.
In hoofdstuk 10 vatten we de resultaten uit dit proefschrift nog eens samen, en geven we
wat richtingen aan voor verder onderzoek.
Appendix A bevat een opsomming van definities van alle graafproblemen welke worden
gebruikt in het proefschrift.
235?Samenvatting
23
Comparing graphs
Graphs are a well-studied mathematical concept, which has become ubiquitous to represent structured data in many application domains like computer vision, social network analysis or chem- and bioinformatics. The ever-increasing amount of data in these domains requires to efficiently organize and extract information from large graph data sets. In this context techniques for comparing graphs are fundamental, e.g., in order to obtain meaningful similarity measures between graphs. These are a prerequisite for the application of a variety of data mining algorithms to the domain of graphs. Hence, various approaches to graph comparison evolved and are wide-spread in practice. This thesis is dedicated to two different strategies for comparing graphs: maximum common subgraph problems and graph kernels.
We study maximum common subgraph problems, which are based on classical graph-theoretical concepts for graph comparison and are NP-hard in the general case. We consider variants of the maximum common subgraph problem in restricted graph classes, which are highly relevant for applications in cheminformatics. We develop a polynomial-time algorithm, which allows to compute a maximum common subgraph under block and bridge preserving isomorphism in series-parallel graphs. This generalizes the problem of computing maximum common biconnected subgraphs in series-parallel graphs. We show that previous approaches to this problem, which are based on the separators represented by standard graph decompositions, fail. We introduce the concept of potential separators to overcome this issue and use them algorithmically to solve the problem in series-parallel graphs. We present algorithms with improved bounds on running time for the subclass of outerplanar graphs. Finally, we establish a sufficient condition for maximum common subgraph variants to allow derivation of graph distance metrics. This leads to polynomial-time computable graph distance metrics in restricted graph classes. This progress constitutes a step towards solving practically relevant maximum common subgraph problems in polynomial time.
The second contribution of this thesis is to graph kernels, which have their origin in specific data mining algorithms. A key property of graph kernels is that they allow to consider a large (possibly infinite) number of features and can support graphs with arbitrary annotation, while being efficiently computable. The main contributions of this part of the thesis are (i) the development of novel graph kernels, which are especially designed for attributed graphs with arbitrary annotations and (ii) the systematic study of implicit and explicit mapping into a feature space for computation of graph kernels w.r.t. its impact on the running time and the ability to consider arbitrary annotations. We propose graph kernels based on bijections between subgraphs and walks of fixed length. In an experimental study we show that these approaches provide a viable alternative to known techniques, in particular for graphs with complex annotations
Subgraph Isomorphism, log-Bounded Fragmentation, and Graphs of (Locally) Bounded Treewidth
The subgraph isomorphism problem, that of nding a copy of one graph in another, has proved to be intractable except when certain restrictions are placed on the inputs. In this paper, we introduce a new property for graphs along with an associated graph class (a generalization on bounded degree graphs) and extend the known classes of inputs for which polynomial-time subgraph isomorphism algorithms are attainable. In particular, if the removal of any set of at most k vertices from an n-vertex graph results in O(k log n) connected components, we say that the graph is a log-bounded fragmentation graph. We present a polynomial-time algorithm for nding a subgraph of H isomorphic to a graph G when G is a log-bounded fragmentation graph and H has bounded treewidth; these results are extended to handle graphs of locally bounded treewidth (a generalization of treewidth) when G is a log-bounded fragmentation graph and has constant diameter