fixed some stuff in the code

code/network.py

@@ -61,11 +61,13 @@ class NeuralNetwork(PrintingObject):
 
     def __init__(self, **params):
         super().__init__()
-        self.model = Sequential()
         self.params = dict(epsilon=0.00000000000001)
         self.params.update(params)
         self.keras_params = dict(activation='linear', use_bias=False)
 
+    def get_model(self):
+        raise NotImplementedError
+
     def get_params(self):
         return self.params
 
@@ -81,13 +83,13 @@ class NeuralNetwork(PrintingObject):
         return self
 
     def get_weights(self):
-        return self.model.get_weights()
+        return self.get_model().get_weights()
 
     def get_weights_flat(self):
         return np.hstack([weight.flatten() for weight in self.get_weights()])
 
     def set_weights(self, new_weights):
-        return self.model.set_weights(new_weights)
+        return self.get_model().set_weights(new_weights)
 
     def apply_to_weights(self, old_weights):
         raise NotImplementedError
@@ -117,7 +119,7 @@ class NeuralNetwork(PrintingObject):
         return NeuralNetwork.are_weights_diverged(self.get_weights())
 
     def is_zero(self, epsilon=None):
-        epsilon = epsilon or self.params.get('epsilon')
+        epsilon = epsilon or self.get_params().get('epsilon')
         return NeuralNetwork.are_weights_within(self.get_weights(), -epsilon, epsilon)
 
     def is_fixpoint(self, degree=1, epsilon=None):
@@ -159,11 +161,15 @@ class WeightwiseNeuralNetwork(NeuralNetwork):
         super().__init__(**kwargs)
         self.width = width
         self.depth = depth
+        self.model = Sequential()
         self.model.add(Dense(units=self.width, input_dim=4, **self.keras_params))
         for _ in range(self.depth-1):
             self.model.add(Dense(units=self.width, **self.keras_params))
         self.model.add(Dense(units=1, **self.keras_params))
 
+    def get_model(self):
+        return self.model
+
     def apply(self, *inputs):
         stuff = np.transpose(np.array([[inputs[0]], [inputs[1]], [inputs[2]], [inputs[3]]]))
         return self.model.predict(stuff)[0][0]
@@ -258,11 +264,15 @@ class AggregatingNeuralNetwork(NeuralNetwork):
         self.aggregates = aggregates
         self.width = width
         self.depth = depth
+        self.model = Sequential()
         self.model.add(Dense(units=width, input_dim=self.aggregates, **self.keras_params))
         for _ in range(depth-1):
             self.model.add(Dense(units=width, **self.keras_params))
         self.model.add(Dense(units=self.aggregates, **self.keras_params))
 
+    def get_model(self):
+        return self.model
+
     def get_aggregator(self):
         return self.params.get('aggregator', self.aggregate_average)
 
@@ -395,11 +405,15 @@ class FFTNeuralNetwork(NeuralNetwork):
         self.aggregates = aggregates
         self.width = width
         self.depth = depth
+        self.model = Sequential()
         self.model.add(Dense(units=width, input_dim=self.aggregates, **self.keras_params))
         for _ in range(depth-1):
             self.model.add(Dense(units=width, **self.keras_params))
         self.model.add(Dense(units=self.aggregates, **self.keras_params))
 
+    def get_model(self):
+        return self.model
+
     def get_shuffler(self):
         return self.params.get('shuffler', self.shuffle_not)
 
@@ -452,11 +466,15 @@ class RecurrentNeuralNetwork(NeuralNetwork):
         self.features = 1
         self.width = width
         self.depth = depth
+        self.model = Sequential()
         self.model.add(SimpleRNN(units=width, input_dim=self.features, return_sequences=True, **self.keras_params))
         for _ in range(depth-1):
             self.model.add(SimpleRNN(units=width, return_sequences=True, **self.keras_params))
         self.model.add(SimpleRNN(units=self.features, return_sequences=True, **self.keras_params))
 
+    def get_model(self):
+        return self.model
+
     def apply(self, *inputs):
         stuff = np.transpose(np.array([[[inputs[i]] for i in range(len(inputs))]]))
         return self.model.predict(stuff)[0].flatten()
@@ -545,22 +563,15 @@ class LearningNeuralNetwork(NeuralNetwork):
                 bar.update()
 
 
-class TrainingNeuralNetworkDecorator(NeuralNetwork):
+class TrainingNeuralNetworkDecorator():
 
     def __init__(self, net, **kwargs):
-        super().__init__(**kwargs)
         self.net = net
         self.compile_params = dict(loss='mse', optimizer='sgd')
         self.model_compiled = False
 
-    def get_params(self):
+    def __getattr__(self, name):
-        return self.net.get_params()
+        return getattr(self.net, name)
-
-    def get_keras_params(self):
-        return self.net.get_keras_params()
-
-    def get_compile_params(self):
-        return self.net.get_compile_params()
 
     def with_params(self, **kwargs):
         self.net.with_params(**kwargs)
@@ -570,16 +581,13 @@ class TrainingNeuralNetworkDecorator(NeuralNetwork):
         self.net.with_keras_params(**kwargs)
         return self
 
+    def get_compile_params(self):
+        return self.compile_params
+
     def with_compile_params(self, **kwargs):
         self.compile_params.update(kwargs)
         return self
 
-    def get_model(self):
-        return self.net.model
-
-    def apply_to_weights(self, old_weights):
-        return self.net.apply_to_weights(old_weights)
-
     def compile_model(self, **kwargs):
         compile_params = copy.deepcopy(self.compile_params)
         compile_params.update(kwargs)
@@ -639,7 +647,7 @@ if __name__ == '__main__':
     if True:
         # ok so this works quite realiably
         with FixpointExperiment() as exp:
-            run_count = 100
+            run_count = 1000
             net = TrainingNeuralNetworkDecorator(WeightwiseNeuralNetwork(width=2, depth=2))\
                 .with_params(epsilon=0.0001).with_keras_params(optimizer='sgd')
             for run_id in tqdm(range(run_count+1)):

code/soup.py

@@ -41,11 +41,8 @@ class Soup:
                     other_particle_id = int(prng() * len(self.particles))
                     other_particle = self.particles[other_particle_id]
                     particle.train_other(other_particle)
-                try:
                 for _ in range(self.params.get('train', 0)):
                     particle.compiled().train()
-                except AttributeError:
-                    pass
                 if self.params.get('remove_divergent') and particle.is_diverged():
                     self.particles[particle_id] = self.generator()
                 if self.params.get('remove_zero') and particle.is_zero():
@@ -67,6 +64,11 @@ class Soup:
                 counters['other'] += 1
         return counters
         
+    def print_all(self):
+        for particle in self.particles:
+            particle.print_weights()
+            print(particle.is_fixpoint())
+
 
 class LearningSoup(Soup):
 
@@ -89,16 +91,18 @@ if __name__ == '__main__':
                 exp.log(soup.count())
 
     if True:
-        with SoupExperiment() as exp:
+        with SoupExperiment("soup") as exp:
             for run_id in range(1):
                 net_generator = lambda: TrainingNeuralNetworkDecorator(WeightwiseNeuralNetwork(2, 2)).with_keras_params(
-                    activation='linear')
+                    activation='sigmoid').with_params(epsilon=0.0001)
+
                 # net_generator = lambda: AggregatingNeuralNetwork(4, 2, 2).with_keras_params(activation='sigmoid')\
                 # .with_params(shuffler=AggregatingNeuralNetwork.shuffle_random)
                 # net_generator = lambda: RecurrentNeuralNetwork(2, 2).with_keras_params(activation='linear').with_params()
-                soup = Soup(10, net_generator).with_params(remove_divergent=True, remove_zero=True).with_params(train=500)
+                soup = Soup(10, net_generator).with_params(remove_divergent=True, remove_zero=True, train=200)
                 soup.seed()
                 for _ in tqdm(range(10)):
                     soup.evolve()
+                    soup.print_all()
                 exp.log(soup.count())