Issue 12322

DIRECTORY.md

@@ -832,6 +832,7 @@
   * [Input Data](neural_network/input_data.py)
   * [Simple Neural Network](neural_network/simple_neural_network.py)
   * [Two Hidden Layers Neural Network](neural_network/two_hidden_layers_neural_network.py)
+  * [Radial Basis Function Neural Network](neural_network/radial_basis_function_neural_network.py)
 
 ## Other
   * [Activity Selection](other/activity_selection.py)

neural_network/radial_basis_function_neural_network.py

@@ -0,0 +1,124 @@
+import numpy as np
+
+
+class RadialBasisFunctionNeuralNetwork:
+    """
+    A simple implementation of a Radial Basis Function Neural Network (RBFNN).
+
+    Attributes:
+        centers (np.ndarray): Centers of the radial basis functions.
+        weights (np.ndarray): Weights for the output layer.
+        sigma (float): Spread of the radial basis functions.
+
+    Reference:
+        Radial Basis Function Network: https://en.wikipedia.org/wiki/Radial_basis_function_network
+    """
+
+    def __init__(self, n_centers: int, sigma: float):
+        """
+        Initialize the RBFNN with the given number of centers and spread.
+
+        Args:
+            n_centers (int): Number of centers for the radial basis functions.
+            sigma (float): Spread of the radial basis functions.
+        """
+        self.n_centers = n_centers
+        self.sigma = sigma
+        self.centers: np.ndarray | None = None  # To be initialized during training
+        self.weights: np.ndarray | None = None  # To be initialized during training
+
+    def _gaussian(self, x: np.ndarray, center: np.ndarray) -> float:
+        """
+        Calculate the Gaussian radial basis function.
+
+        Args:
+            x (np.ndarray): Input vector.
+            center (np.ndarray): Center of the RBF.
+
+        Returns:
+            float: The output of the RBF evaluated at x.
+
+        >>> import numpy as np
+        >>> rbf_nn = RadialBasisFunctionNeuralNetwork(n_centers=2, sigma=0.5)
+        >>> rbf_nn._gaussian(np.array([0, 0]), np.array([1, 1]))
+        0.1353352832366127
+        """
+        return np.exp(-(np.linalg.norm(x - center) ** 2) / (2 * self.sigma**2))
+
+    def _compute_rbf(self, x: np.ndarray) -> np.ndarray:
+        """
+        Compute the output of the radial basis functions for input data.
+
+        Args:
+            x (np.ndarray): Input data matrix (num_samples x num_features).
+
+        Returns:
+            np.ndarray: A matrix of shape (num_samples x n_centers) containing the RBF outputs.
+        """
+        rbf_outputs = np.zeros((x.shape[0], self.n_centers))
+        for i, center in enumerate(self.centers):
+            for j in range(x.shape[0]):
+                rbf_outputs[j, i] = self._gaussian(x[j], center)
+        return rbf_outputs
+
+    def fit(self, x: np.ndarray, y: np.ndarray):
+        """
+        Train the RBFNN on the provided data.
+
+        Args:
+            x (np.ndarray): Input data matrix (num_samples x num_features).
+            y (np.ndarray): Target values (num_samples x output_dim).
+
+        Raises:
+            ValueError: If number of samples in x and y do not match.
+        """
+        if x.shape[0] != y.shape[0]:
+            raise ValueError("Number of samples in x and y must match.")
+
+        # Initialize centers using random samples from x
+        random_indices = np.random.choice(x.shape[0], self.n_centers, replace=False)
+        self.centers = x[random_indices]
+
+        # Compute the RBF outputs for the training data
+        rbf_outputs = self._compute_rbf(x)
+
+        # Calculate weights using the pseudo-inverse
+        self.weights = np.linalg.pinv(rbf_outputs).dot(y)
+
+    def predict(self, x: np.ndarray) -> np.ndarray:
+        """
+        Predict the output for the given input data.
+
+        Args:
+            x (np.ndarray): Input data matrix (num_samples x num_features).
+
+        Returns:
+            np.ndarray: Predicted values (num_samples x output_dim).
+        """
+        rbf_outputs = self._compute_rbf(x)
+        return rbf_outputs.dot(self.weights)
+
+
+# Example Usage
+if __name__ == "__main__":
+    # Sample dataset
+    X = np.array([[0, 0], [1, 0], [0, 1], [1, 1]])  # 2D input
+    y = np.array([[0], [1], [1], [0]])  # Target output for XOR
+
+    # Create and train the RBFNN
+    rbf_nn = RadialBasisFunctionNeuralNetwork(n_centers=2, sigma=0.5)
+    rbf_nn.fit(X, y)
+
+    # Predict using the trained model
+    predictions = rbf_nn.predict(X)
+    print("Predictions:\n", predictions)
+
+# Sample Expected Output:
+# Predictions:
+# [[0.24826229]
+# [0.06598867]
+# [0.06598867]
+# [0.24826229]]
+
+
+