Create radial_basis_function_neural_network

neural_network/radial_basis_function_neural_network.py

@@ -0,0 +1,89 @@
+"""
+ - - - - - -- - - - - - - - - - - - - - - - - - - - - - - 
+Name - - RBFNN - Radial Basis Function Neural Network
+Goal - - Recognize Patterns in Data
+Detail: Total 3 layers neural network
+        * Input layer
+        * Hidden layer with RBF activation
+        * Output layer
+Author: Your Name
+Github: [email protected]
+Date: 2024.10.31
+- - - - - -- - - - - - - - - - - - - - - - - - - - - - - 
+"""
+
+import numpy as np  # For numerical operations
+
+class RBFNN:
+    def __init__(self, input_size, hidden_size, output_size):
+        """
+        Initialize the RBFNN parameters.
+
+        :param input_size: Number of input features
+        :param hidden_size: Number of hidden units in the RBF layer
+        :param output_size: Number of output classes
+        """
+        self.input_size = input_size  # Size of input layer
+        self.hidden_size = hidden_size  # Size of hidden layer
+        self.output_size = output_size  # Size of output layer
+
+        rng = np.random.default_rng()  # Create a random number generator
+        # Initialize centers and spread of the RBF neurons
+        self.centers = rng.random((hidden_size, input_size))  # Centers for RBF
+        self.spread = rng.random(hidden_size)  # Spread for each RBF
+
+        # Initialize weights for the output layer
+        self.weights = rng.random((hidden_size, output_size))  # Weights for output layer
+
+    def rbf(self, x, center, spread):
+        """ Radial Basis Function (Gaussian). """
+        return np.exp(-np.linalg.norm(x - center) ** 2 / (2 * spread ** 2))
+
+    def forward(self, x):
+        """ Forward pass through the network. """
+        hidden_outputs = np.zeros(self.hidden_size)  # Outputs of hidden layer
+        for i in range(self.hidden_size):
+            hidden_outputs[i] = self.rbf(x, self.centers[i], self.spread[i])  # Compute RBF outputs
+
+        output = np.dot(hidden_outputs, self.weights)  # Compute final output
+        return output
+
+    def train(self, x_train, y_train, epochs, learning_rate):
+        """
+        Train the RBFNN model.
+
+        :param x_train: Input data
+        :param y_train: Target output
+        :param epochs: Number of training iterations
+        :param learning_rate: Learning rate for weight updates
+        """
+        for _ in range(epochs):  # Use underscore for unused loop variable
+            for i in range(len(x_train)):
+                x_i = x_train[i]
+                y_i = y_train[i]
+
+                # Forward pass
+                hidden_outputs = np.zeros(self.hidden_size)
+                for j in range(self.hidden_size):
+                    hidden_outputs[j] = self.rbf(x_i, self.centers[j], self.spread[j])
+
+                output = np.dot(hidden_outputs, self.weights)  # Output layer
+
+                # Calculate the error
+                error = y_i - output
+
+                # Update weights
+                self.weights += learning_rate * hidden_outputs.reshape(-1, 1) * error
+
+    def predict(self, x_test):
+        """
+        Predict outputs for given input data.
+
+        :param x_test: Input data
+        :return: Predicted outputs
+        """
+        predictions = []
+        for x in x_test:
+            output = self.forward(x)  # Forward pass to get prediction
+            predictions.append(output)
+        return np.array(predictions)