update main routine to run evo algo.

Author: tmetsch

.gitignore

@@ -1,3 +1,5 @@
-graph_gen.py
 **.pyc*
-*.idea/
+*.idea/
+.coverage
+dist/
+graph_stitcher.egg-info/

README.md

@@ -55,7 +55,7 @@ As mentioned above graph stitcher is pluggable, to test different algorithms of
 interface for the *stitch()* and *validate()* routine (see *BaseStitcher*
 class).
 
-To stitch two graphs the tool needs to know how which relationships are needed:
+To stitch two graphs the tool needs to know which relationships are needed:
 
     Type of source node | Type of target node
     -----------------------------------------
@@ -97,7 +97,7 @@ The following dictionary can be passed in as a composition condition:
                       ('share', ('group', ['x', 'y']))]
     }
 
-graph stitcher is mostly developed to test & play around. Also to check if
+This graph stitcher is mostly developed to test & play around. Also to check if
 [evolutionary algorithms](https://en.wikipedia.org/wiki/Evolutionary_algorithm)
 can be developed to determine the best resulting graph.
 
@@ -114,3 +114,12 @@ dotted lines. Each graph is a candidate solution, the results of the
 validation are shown as titles of the graphs.
 
 ![output](./figure_1.png?raw=true "Output")
+
+To test the evolutionary algorithm run:
+
+    $ ./run_me.py -ea
+    
+Please note that it might not always find a set of good solutions, as the 
+container and the request are pretty small. Also note that currently the 
+fitness function expresses a fitness for the given conditions; and does not 
+include a fitness value for the validation phase.

build.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+pep8 -r **/*.py
+
+pylint -r n **/*.py
+
+nosetests --with-coverage --cover-package=stitcher

run_me.py

@@ -5,32 +5,77 @@
 """
 
 import json
+import random
+import sys
+import logging
+import networkx as nx
 
 from networkx.readwrite import json_graph
 
+from stitcher import evolutionary
 from stitcher import stitch
 from stitcher import vis
 
+FORMAT = "%(asctime)s - %(filename)s - %(lineno)s - " \
+         "%(levelname)s - %(message)s"
+logging.basicConfig(format=FORMAT, level=logging.DEBUG)
 
-def main():
+
+def main(use_evol=False):
     """
     main routine.
     """
     container_tmp = json.load(open('data/container.json'))
     container = json_graph.node_link_graph(container_tmp, directed=True)
     request_tmp = json.load(open('data/request.json'))
     request = json_graph.node_link_graph(request_tmp, directed=True)
+    stitches = json.load(open('data/stitch.json'))
 
     # XXX: change this to whatever stitcher you want to use
     stitcher = stitch.IncomingEdgeStitcher()
-    # stitcher = stitch.NodeRankStitcher()
-    graphs = stitcher.stitch(container, request)
+
+    if use_evol:
+        evo = evolutionary.BasicEvolution(percent_cutoff=0.9,
+                                          percent_mutate=0.0)
+
+        condy = {'compositions': {('diff', ('k', 'l'))}}
+
+        # initial population
+        population = []
+        for _ in range(10):
+            tmp = {}
+            for item in request.nodes():
+                trg_cand = random.choice(list(['A', 'B', 'C', 'D', 'E', 'F']))
+                tmp[item] = trg_cand
+            population.append(evolutionary.GraphCandidate(tmp, stitches,
+                                                          condy, [], request,
+                                                          container))
+
+        _, population = evo.run(population,
+                                10,  # do 10 steps
+                                fitness_goal=-1.0)  # want multiple
+
+        if population[0].fitness() != 0.0:
+            print('Please rerun - did not find a viable solution')
+            sys.exit(1)
+
+        graphs = []
+        for candidate in population:
+            if candidate.fitness() == 0.0:
+                tmp_graph = nx.union(container, request)
+                for item in candidate.gen:
+                    tmp_graph.add_edge(item, candidate.gen[item])
+                graphs.append(tmp_graph)
+    else:
+        graphs = stitcher.stitch(container, request)
     results = stitcher.validate(graphs, {'b': 5})
-    # results = stitcher.validate(graphs, {'a': (1, 4)})
 
     # XXX: disable this if you do not want to see the results.
     vis.show(graphs, request.nodes(), results)
 
 
 if __name__ == '__main__':
-    main()
+    USE_EA = False
+    if len(sys.argv) == 2 and sys.argv[1] == '-ea':
+        USE_EA = True
+    main(USE_EA)

setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup
 
 setup(name='graph_stitcher',
-      version='0.0.9',
+      version='0.0.10',
       author='Thijs Metsch',
       url='https://github.com/tmetsch/graph_stitcher',
       description=('This tool is a little framework to determine possible'

stitcher/evolutionary.py

@@ -5,10 +5,149 @@
 
 import logging
 import random
+import re
 
 LOG = logging.getLogger()
 
 
+def _eq_attr(node, attr, gens, container):
+    """
+    Calcs fitness based on the fact that node need target node to have an attr
+    with a certain value.
+    """
+    trg_nd = container.node[gens[node]]
+    if attr[0] not in trg_nd:
+        return 10.1
+    elif attr[1] != trg_nd[attr[0]]:
+        return 10.2
+    return 0.0
+
+
+def _neq_attr(node, attr, gens, container):
+    """
+    Calcs fitness based on the fact that node's target shall not have an attr
+    with a certain value.
+    """
+    trg_nd = container.node[gens[node]]
+    if attr[0] in trg_nd and attr[1] == trg_nd[attr[0]]:
+        return 10.1
+    return 0.0
+
+
+def _lg_attr(node, attr, gens, container):
+    """
+    Calcs fitness based on the fact that node's target node shall have an attr
+    with a value larger than the given one.
+    """
+    trg_nd = container.node[gens[node]]
+    if attr[0] not in trg_nd:
+        return 10.1
+    elif attr[1] > trg_nd[attr[0]]:
+        return 10.2
+    return 0.0
+
+
+def _lt_attr(node, attr, gens, container):
+    """
+    Calcs fitness based on the fact that node's target node shall have an attr
+    with a value smaller than the given one.
+    """
+    trg_nd = container.node[gens[node]]
+    if attr[0] not in trg_nd:
+        return 10.1
+    elif attr[1] < trg_nd[attr[0]]:
+        return 10.2
+    return 0.0
+
+
+def _regex_attr(node, attr, gens, container):
+    """
+    Calcs fitness based on the fact that node's target node shall have an attr
+    with a value smaller than the given one.
+    """
+    trg_nd = container.node[gens[node]]
+    if attr[0] not in trg_nd:
+        return 10.1
+    elif not re.search(attr[1], trg_nd[attr[0]]):
+        return 10.2
+    return 0.0
+
+
+def _same_target(node1, node2, gens):
+    """
+    Calcs fitness based on the fact that two nodes should share same target.
+    """
+    shared_tg = None
+    for src in gens:
+        if shared_tg is None and src in [node1, node2]:
+            shared_tg = gens[src]
+        elif shared_tg is not None and gens[src] != shared_tg:
+            return 10.0
+    return 0.0
+
+
+def _diff_target(node1, node2, gens):
+    """
+    Calc fitness based on the fact that two nodes should not share same target.
+    """
+    shared_tg = None
+    for src in gens:
+        if shared_tg is None and src in [node1, node2]:
+            shared_tg = gens[src]
+        elif shared_tg is not None and gens[src] == shared_tg:
+            return 10.0
+    return 0.0
+
+
+def _share_attr(attrn, node_list, gens, container):
+    """
+    Calcs fitness based on the fact that two nodes from the request should be
+    stitched to two nodes in the container two share the same attribute
+    """
+    attrv = None
+    for node in node_list:
+        trg = gens[node]
+        if attrn not in container.node[trg]:
+            return 10.1
+        elif attrv is None:
+            attrv = container.node[trg][attrn]
+        elif attrv != container.node[trg][attrn]:
+            return 10.2
+    return 0.0
+
+
+def _my_filter(conditions, gens, container):
+    """
+    Apply filters.
+    """
+    res = 0.0
+    if 'attributes' in conditions:
+        for condition in conditions['attributes']:
+            para1 = condition[1][0]
+            para2 = condition[1][1]
+            if condition[0] == 'eq':
+                res += _eq_attr(para1, para2, gens, container)
+            if condition[0] == 'neq':
+                res += _neq_attr(para1, para2, gens, container)
+            if condition[0] == 'lg':
+                res += _lg_attr(para1, para2, gens, container)
+            if condition[0] == 'lt':
+                res += _lt_attr(para1, para2, gens, container)
+            if condition[0] == 'regex':
+                res += _regex_attr(para1, para2, gens, container)
+    if 'compositions' in conditions:
+        for condition in conditions['compositions']:
+            para1 = condition[1][0]
+            para2 = condition[1][1]
+            if condition[0] == 'same':
+                res += _same_target(para1, para2, gens)
+            if condition[0] == 'diff':
+                res += _diff_target(para1, para2, gens)
+            if condition[0] == 'share':
+                res += _share_attr(para1, para2, gens, container)
+    return res
+
+
 class Candidate(object):
     """
     A candidate of a population for an evolutionary algorithm
@@ -41,6 +180,83 @@ def crossover(self, partner):
         """
         raise NotImplementedError('Not done yet.')
 
+    def __eq__(self, other):
+        return self.gen == other.gen
+
+
+class GraphCandidate(Candidate):
+    """
+    Candidate within a population. The DNA of this candidate is defined by a
+    dictionary of source to target stitches.
+    """
+
+    def __init__(self, gen, stitch, conditions, mutation_list, request,
+                 container):
+        super(GraphCandidate, self).__init__(gen)
+        self.stitch = stitch
+        self.conditions = conditions
+        self.mutation_list = mutation_list
+        self.request = request
+        self.container = container
+
+    def fitness(self):
+        fit = 0.0
+
+        # 1. stitch
+        for src in self.gen:
+            trg = self.gen[src]
+            if self.container.node[trg]['type'] != \
+                    self.stitch[self.request.node[src]['type']]:
+                fit += 100
+
+        # 2. conditions
+        fit += _my_filter(self.conditions, self.gen, self.container)
+
+        return fit
+
+    def mutate(self):
+        # let's mutate to an option outside of the shortlisted candidate list.
+        src = random.choice(list(self.gen.keys()))
+
+        done = False
+        cutoff = len(self.gen)
+        i = 0
+        while not done and i <= cutoff:
+            # break off as there might be no other match available.
+            nd_trg = self.mutation_list[random.randint(
+                0, len(self.mutation_list) - 1)][0]
+            if self.container.node[nd_trg]['type'] == \
+                    self.stitch[self.request.node[src]['type']]:
+                done = True
+                self.gen[src] = nd_trg
+            i += 1
+
+    def crossover(self, partner):
+        tmp = {}
+
+        for src in self.gen:
+            # pick one from partner
+            done = False
+            nd_trg = ''
+            cutoff = len(self.gen)
+            i = 0
+            while not done and i <= cutoff:
+                nd_trg = random.choice(list(partner.gen.values()))
+                if self.container.node[nd_trg]['type'] \
+                        == self.stitch[self.request.node[src]['type']]:
+                    done = True
+                i += 1
+            if done:
+                tmp[src] = nd_trg
+            else:
+                tmp[src] = self.gen[src]
+
+        return self.__class__(tmp, self.stitch, self.conditions,
+                              self.mutation_list, self.request, self.container)
+
+    def __repr__(self):
+        return 'f: ' + str(self.fitness()) + ' - ' + repr(self.gen)
+
 
 class BasicEvolution(object):
     """