changing keras classes up-to-date

RBF_neuralNetwork_updated.py

@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+"""
+MIT Licence
+
+Zoghbi Abderraouf
+Change data to your location 
+"""
+
+from keras import backend as K
+from keras.layers import Layer
+from keras.initializers import RandomUniform, Initializer, Constant
+import numpy as np
+
+
+class InitCentersRandom(Initializer):
+    """ Initializer for initialization of centers of RBF network
+        as random samples from the given data set.
+    # Arguments
+        X: matrix, dataset to choose the centers from (random rows
+          are taken as centers)
+    """
+
+    def __init__(self, X):
+        self.X = X
+
+    def __call__(self, shape, dtype=None):
+        assert shape[1] == self.X.shape[1]
+        idx = np.random.randint(self.X.shape[0], size=shape[0])
+        return self.X[idx, :]
+
+
+class RBFLayer(Layer):
+    """ Layer of Gaussian RBF units.
+    # Example
+    ```python
+        model = Sequential()
+        model.add(RBFLayer(10,
+                           initializer=InitCentersRandom(X),
+                           betas=1.0,
+                           input_shape=(1,)))
+        model.add(Dense(1))
+    ```
+    # Arguments
+        output_dim: number of hidden units (i.e. number of outputs of the
+                    layer)
+        initializer: instance of initiliazer to initialize centers
+        betas: float, initial value for betas
+    """
+
+    def __init__(self, output_dim, initializer=None, betas=1.0, **kwargs):
+        self.output_dim = output_dim
+        self.init_betas = betas
+        if not initializer:
+            self.initializer = RandomUniform(0.0, 1.0)
+        else:
+            self.initializer = initializer
+        super(RBFLayer, self).__init__(**kwargs)
+
+    def build(self, input_shape):
+
+        self.centers = self.add_weight(name='centers',
+                                       shape=(self.output_dim, input_shape[1]),
+                                       initializer=self.initializer,
+                                       trainable=True)
+        self.betas = self.add_weight(name='betas',
+                                     shape=(self.output_dim,),
+                                     initializer=Constant(
+                                         value=self.init_betas),
+                                     # initializer='ones',
+                                     trainable=True)
+
+        super(RBFLayer, self).build(input_shape)
+
+    def call(self, x):
+
+        C = K.expand_dims(self.centers)
+        H = K.transpose(C-K.transpose(x))
+        return K.exp(-self.betas * K.sum(H**2, axis=1))
+
+        # C = self.centers[np.newaxis, :, :]
+        # X = x[:, np.newaxis, :]
+
+        # diffnorm = K.sum((C-X)**2, axis=-1)
+        # ret = K.exp( - self.betas * diffnorm)
+        # return ret
+
+    def compute_output_shape(self, input_shape):
+        return (input_shape[0], self.output_dim)
+
+    def get_config(self):
+        # have to define get_config to be able to use model_from_json
+        config = {
+            'output_dim': self.output_dim
+        }
+        base_config = super(RBFLayer, self).get_config()
+        return dict(list(base_config.items()) + list(config.items()))
+
+from keras.initializers import Initializer
+from sklearn.cluster import KMeans
+
+
+class InitCentersKMeans(Initializer):
+    """ Initializer for initialization of centers of RBF network
+        by clustering the given data set.
+    # Arguments
+        X: matrix, dataset
+    """
+
+    def __init__(self, X, max_iter=100):
+        self.X = X
+        self.max_iter = max_iter
+
+    def __call__(self, shape, dtype=None):
+        assert shape[1] == self.X.shape[1]
+
+        n_centers = shape[0]
+        km = KMeans(n_clusters=n_centers, max_iter=self.max_iter, verbose=0)
+        km.fit(self.X)
+        return km.cluster_centers_
+
+
+
+
+