RBFNet

import pandas as pd
import numpy as np

import sklearn.cluster
from sklearn.metrics.pairwise import euclidean_distances

import sklearn.metrics
import sklearn.linear_model
from sklearn.base import BaseEstimator, ClassifierMixin


class RBFNetwork(BaseEstimator, ClassifierMixin):

    def __init__(self, number_of_centers, random_state=42):
        self.number_of_centers = number_of_centers

        self.random_state = random_state


    @staticmethod
    def make_gaussian_kernel(center, sigma):
        ''' Creates a Gaussian Kernel function that takes X and calculate the
        distance from the center with the sigma deviation.
        '''
        variance = sigma**2
        if(variance == 0):
             variance = 1e-10
        gamma = 2*(variance)
        reshaped_center = np.reshape(center, newshape=(1, -1))

        def gaussian(X):
            dist = euclidean_distances(X, reshaped_center, squared=True)
            normalization_constant = 1/(2*np.pi*variance)
            return normalization_constant * np.exp(-(dist/gamma))
        return gaussian

    def fit(self, X, y):


        self.centers = None
        self.centers_std = None
        self.kernels = None

        self.algorithm = sklearn.linear_model.LinearRegression()

        self._fit_centers(X, y)
        self._generate_radial_functions()

        transformed_X = self._transformed_inputs(X)
        self._linear_fit(transformed_X, y)

    def predict(self, X):
        transformed_X = self._transformed_inputs(X)
        return (self.algorithm.predict(transformed_X))

    def _fit_centers(self, X, y=None):
        kmeans = sklearn.cluster.KMeans(n_clusters=self.number_of_centers,
                                        random_state=self.random_state)
        kmeans.fit(X)
        self.centers = kmeans.cluster_centers_
        groups = kmeans.predict(X)

        center_distances = euclidean_distances(X, self.centers)
        center_distances_df = pd.DataFrame(center_distances)
        center_distances_df['classe'] = groups

        center_distances_std = center_distances_df.groupby('classe').std()
        self.centers_std = np.diag(center_distances_std)

    def _generate_radial_functions(self):
        self.kernels = list()
        for cluster_center, cluster_deviance in zip(self.centers, self.centers_std):
            kernel = RBFNetwork.make_gaussian_kernel(
                cluster_center, cluster_deviance)
            self.kernels.append(kernel)

    def _transformed_inputs(self, X):
        features = [kernel(X) for kernel in self.kernels]
        features_array = (np.concatenate(features, axis=1))
        features_array = np.nan_to_num(x = features_array, nan = 0.0 )
        return features_array

    def _linear_fit(self, hidden_X, y):
        self.algorithm.fit(hidden_X, y)