Refactor of SNN

Author: apiad

docker-compose.yml

@@ -5,6 +5,7 @@ services:
     image: matcomuh/ml:cpu
     volumes:
       - ./:/ml
+      - ./snn:/usr/lib/python3/dist-packages/snn
     ports:
       - '8888:8888'
     container_name: ml

notebooks/sample-snn.ipynb

@@ -0,0 +1,154 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using TensorFlow backend.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from keras.layers import Input\n",
+    "from keras.models import Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from snn.base_model import SNN\n",
+    "from snn import Entity, Relation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Thing = Entity(\"Thing\")\n",
+    "Person = Entity(\"Person\", Thing)\n",
+    "Object = Entity(\"Object\", Thing)\n",
+    "\n",
+    "hold = Relation(\"hold\", Person, Object)\n",
+    "look = Relation(\"look\", Person, Object)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "snn = SNN(entities=[Thing, Person, Object], relations=[hold, look])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = Input(shape=(100,))\n",
+    "y = snn(x, compiled=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "__________________________________________________________________________________________________\n",
+      "Layer (type)                    Output Shape         Param #     Connected to                     \n",
+      "==================================================================================================\n",
+      "input_1 (InputLayer)            (None, 100)          0                                            \n",
+      "__________________________________________________________________________________________________\n",
+      "Object (Entitie)                (None, 32)           4288        input_1[0][0]                    \n",
+      "__________________________________________________________________________________________________\n",
+      "Person (Entitie)                (None, 32)           4288        input_1[0][0]                    \n",
+      "__________________________________________________________________________________________________\n",
+      "max_Person_Object (Maximum)     (None, 32)           0           Person[0][0]                     \n",
+      "                                                                 Object[0][0]                     \n",
+      "__________________________________________________________________________________________________\n",
+      "Person_Object_isa_Thing (Dense) (None, 32)           1056        max_Person_Object[0][0]          \n",
+      "__________________________________________________________________________________________________\n",
+      "Thing (Entitie)                 (None, 32)           2112        Person_Object_isa_Thing[0][0]    \n",
+      "__________________________________________________________________________________________________\n",
+      "hold (Relation)                 (None, 32)           2112        Person[0][0]                     \n",
+      "                                                                 Object[0][0]                     \n",
+      "__________________________________________________________________________________________________\n",
+      "look (Relation)                 (None, 32)           2112        Person[0][0]                     \n",
+      "                                                                 Object[0][0]                     \n",
+      "__________________________________________________________________________________________________\n",
+      "out_embeding (Concatenate)      (None, 160)          0           Object[0][0]                     \n",
+      "                                                                 Person[0][0]                     \n",
+      "                                                                 Thing[0][0]                      \n",
+      "                                                                 hold[0][0]                       \n",
+      "                                                                 look[0][0]                       \n",
+      "==================================================================================================\n",
+      "Total params: 15,968\n",
+      "Trainable params: 15,968\n",
+      "Non-trainable params: 0\n",
+      "__________________________________________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "y.summary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(None, 160)"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y.output_shape"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.5.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

notebooks/test-snn.ipynb

@@ -0,0 +1 @@
+from .base import SNN, Entity, Relation

src/test_new_snn.ipynb renamed to notebooks/test_new_snn.ipynb

@@ -0,0 +1,117 @@
+from keras.models import Model
+from keras.layers import Input, Dense, maximum, concatenate
+from keras.utils.vis_utils import model_to_dot
+
+from .utils import EntityLayer, RelationLayer
+
+
+class SNN:
+    def __init__(self, entities, relations, entity_shape=32, relation_shape=64):
+        self.entities = entities
+        self.relations = relations
+        self.entity_shape = entity_shape
+        self.relation_shape = relation_shape
+
+    def __call__(self, x):
+        self.input_ = x
+        self.entity_capsules_ = self._build_entities(x)
+        self.relation_capsules_ = self._build_relations()
+        self.outputs_, self.indicators_, self.representations_ = self._build_outputs()
+        return self.representations_
+
+    def build(self):
+        return Model(inputs=self.input_, outputs=self.indicators_)
+
+    def _build_entities(self, x):
+        entity_capsules = {}
+
+        for e in toposort(self.entities):
+            entity_capsules[e] = self._build_entity_capsule(x, e, entity_capsules)
+
+        return entity_capsules
+
+    def _build_entity_capsule(self, x, entity, capsules):
+        children = [capsules[c] for c in entity.children]
+
+        if children:
+            inputs = maximum(children, name="Max-%s" % entity.name)
+        else:
+            inputs = x
+
+        return EntityLayer(self.entity_shape, name=entity.name)(inputs)
+
+    def _build_relations(self):
+        relation_capsules = {}
+
+        for r in self.relations:
+            relation_capsules[r] = self._build_relation_capsule(r)
+
+        return relation_capsules
+
+    def _build_relation_capsule(self, relation):
+        src = self.entity_capsules_[relation.src]
+        dst = self.entity_capsules_[relation.dst]
+
+        return RelationLayer(self.relation_shape, name=relation.label)([src, dst])
+
+    def _build_outputs(self):
+        outputs = {}
+        outputs_indicators = []
+        outputs_concat = []
+
+        for e in self.entities:
+            outputs[e] = Dense(units=1, activation='sigmoid', name="Indicator-%s" % e.name)(self.entity_capsules_[e])
+            outputs_indicators.append(outputs[e])
+            outputs_concat.append(self.entity_capsules_[e])
+
+        for r in self.relations:
+            outputs[r] = Dense(units=1, activation='sigmoid', name="Indicator-%s" % r.label)(self.relation_capsules_[r])
+            outputs_indicators.append(outputs[r])
+            outputs_concat.append(self.relation_capsules_[r])
+
+        indicators = concatenate(outputs_indicators, name="Indicators")
+        concat = concatenate(outputs_concat, name="Representations")
+
+        return outputs, indicators, concat
+
+
+def toposort(entities):
+    visited = set()
+    path = []
+
+    def visit(e):
+        if e in visited:
+            return
+
+        for c in e.children:
+            visit(c)
+
+        visited.add(e)
+        path.append(e)
+
+    for e in entities:
+        visit(e)
+
+    return path
+
+
+class Entity:
+    def __init__(self, name, *parents):
+        self.name = name
+        self.parents = parents
+        self.children = []
+
+        for p in self.parents:
+            p.children.append(self)
+
+    def __repr__(self):
+        return "<%s>" % self.name
+
+class Relation:
+    def __init__(self, label, src:Entity, dst:Entity):
+        self.label = label
+        self.src = src
+        self.dst = dst
+
+    def __repr__(self):
+        return "%s(%s , %s)" % (self.label, self.src, self.dst)

snn/__init__.py

@@ -5,15 +5,21 @@
 #     from .utils import tnorm, tnorm_output_shape, isLayer, isModel
 # except ImportError:
 #     from utils import tnorm, tnorm_output_shape, isLayer, isModel
-from utils import tnorm, tnorm_output_shape, isLayer, isModel
+from .utils import tnorm, tnorm_output_shape, isLayer, isModel, tnorm_loss, bin_acc
+from .utils import Entitie as EntityLayer
+from .utils import Relation as RelationLayer
+from .base import Entity, Relation
 
+from keras.models import Model
 from keras.layers import Lambda, Maximum, Dense, Concatenate
 
 
-class SNN(metaclass=abc.ABCMeta):
+Entities = List[Entity]
+Relations = List[Relation]
+
 
-    def __init__(self, entities: List[str],
-                 relations: Dict[str, List[Tuple[str]]], isar: List[Tuple[str]]):
+class SNN(metaclass=abc.ABCMeta):
+    def __init__(self, entities: Entities, relations:Relations):
         """ redes semanticas
         entities: lista de strings
         relations: diccionario de: llave relacion, valor lista de tuplas de
@@ -24,6 +30,10 @@ def __init__(self, entities: List[str],
         isar: lista de tuplas de pares de entidades relacionadas por relaciones
         parecidas a "is a" de la forma (hijo, padre)
         """
+        isar = [(e.name, p.name) for e in entities for p in e.parents]
+        entities = [e.name for e in entities]
+        relations = {r.label: [(r.src.name, r.dst.name)] for r in relations}
+
         eet = set(entities)
         # check for duplicate entities
         assert len(eet) == len(entities), "Exist duplicated entities"
@@ -154,7 +164,7 @@ def _build_model(self, inputt):
                 rels[rel+str(n)] = self.relation_capsule(
                     rel+'_'+str(n), [ents[e1], ents[e2]])
 
-    def __call__(self, inputt, train=False, compilee=False):
+    def __call__(self, inputt, train=False, compiled=False):
         self._build_model(inputt)
         ents = self.ents
         rels = self.rels
@@ -167,12 +177,12 @@ def __call__(self, inputt, train=False, compilee=False):
                 out.append(Lambda(tnorm,
                                   output_shape=tnorm_output_shape, name=i+'-out')(rels[i]))
             outt = Concatenate(name='out_embeding')(out)
-            if compilee:
+            if compiled:
                 return self.wrap_compile(inputt, outt)
             return outt
         outt = Concatenate(name='out_embeding')([ents[i] for i in self.entities] +
                                                 [rels[j] for j in sorted(rels.keys())])
-        if compilee:
+        if compiled:
             return self.wrap_compile(inputt, outt)
         return outt
 
@@ -183,33 +193,32 @@ def pretrain(self):
     def wrap_compile(self, inn, outt):
         return self._compile(inn, outt)
 
-    @abc.abstractmethod
     def _compile(self, inn, outt):
-        raise NotImplementedError()
+        model = Model(inputs=inn, outputs=outt)
+        model.compile(optimizer='RMSprop',
+                        loss=tnorm_loss, metrics=[bin_acc])
+        return model
 
-    @abc.abstractmethod
     def entitie_capsule(self, name: str, inputt):
         """
         name:  name of the entitie
         imput: is a keras symbolic tensor or input layer or a class that
         implement keras.Layer interface
         """
-        raise NotImplementedError()
+        return EntityLayer(32, name=name)(inputt)
 
-    @abc.abstractmethod
     def relation_capsule(self, name: str, inputs: List):
         """
         name:  name of the entitie
         imputs: is a list of keras symbolic tensors or input layers or a
         classes that implement keras.Layer interface
         """
-        raise NotImplementedError()
+        return RelationLayer(32, name=name)(inputs)
 
-    @abc.abstractmethod
     def isa_capsule(self, name: str, inputt):
         """
         name:  name of the entitie
         imput: is a keras symbolic tensor or input layer or a class that
         implement keras.Layer interface
         """
-        raise NotImplementedError()
+        return Dense(32, name=name)(inputt)