Deep learning algorithms work with almost any kind of data and require large amounts of computation power and information to solve complicated issues. Now, let us, deep-dive, into one of the most powerful deep learning algorithms: Radial basis function networks (RBFNs).
Radial Basis Function Networks (RBFNs) are a powerful tool for specific types of problems, particularly those involving interpolation and function approximation. Their simplicity and effectiveness in these areas make them a valuable model in the machine learning and deep learning toolbox.
RBFNs are special types of feedforward neural networks that use radial basis functions as activation functions. They have an input layer, a hidden layer, and an output layer and are mostly used for classification, regression, and time-series prediction.
If you are interested in learning how to use Python for deep learning with Radial basis function networks (RBFNs), this article is perfect for you.
Before we begin, let’s see the diagram of RBFN architecture:
Table of Contents
What is Deep Learning?
Deep learning is a branch of machine learning focused on solving complex problems through the use of artificial neural networks. These networks are composed of multiple layers of interconnected nodes that work together to extract features from input data. By training on large datasets, deep learning models can identify patterns and correlations that are often beyond human capability to detect.
The influence of deep learning on artificial intelligence has been substantial. It has paved the way for the creation of intelligent systems that can learn, adapt, and make autonomous decisions. This technology has driven significant advancements in various fields, including function approximation, classification, time-series prediction, image and speech recognition, natural language processing, machine translation, and autonomous driving, among others.
The following is a scheme of the use of neural networks in the Global Positioning System (GPS):
4 Reasons to Use Python for Deep Learning
Python’s rise in popularity is attributed to its adaptability and simplicity, particularly in the realm of deep learning. It has become the go-to language for many professionals in machine learning, deep learning, AI, and data science due to its comprehensive libraries and frameworks designed for these purposes.
Here are four compelling reasons why Python excels as a deep learning language:
1. Straightforward syntax and readability
Python’s straightforward syntax and readability make it an ideal choice for deep learning. Its high-level nature allows developers to write clean, understandable code, which is particularly beneficial for those new to programming or deep learning. This simplicity helps researchers and developers focus on creating and refining models without being bogged down by complex syntax, enabling faster experimentation and iteration.
2. Extensive ecosystem of libraries and frameworks
The extensive ecosystem of libraries and frameworks is another major advantage of using Python for deep learning. Libraries such as TensorFlow, PyTorch, and Keras offer powerful tools for building, training, and deploying deep learning models. These frameworks come with pre-built components that handle many aspects of deep learning, from data preprocessing to model evaluation, significantly reducing the amount of boilerplate code developers need to write. This makes the development process more efficient and allows for rapid prototyping.
3. Strong community support
Python’s strong community support enhances its appeal in the deep learning field. The large and active community of Python developers contributes to a wealth of resources, including comprehensive documentation, tutorials, and forums. This support network is invaluable for troubleshooting, learning new techniques, and staying up-to-date with the latest advancements in deep learning. The collaborative environment fostered by the Python community ensures continuous improvement and innovation in the tools and libraries available for deep learning.
4. Cross-platform compatibility
Cross-platform compatibility is another significant benefit of using Python. Python’s platform independence means that code written on one operating system can be easily executed on another with minimal modifications. This flexibility is crucial for deploying deep learning models across various environments, from local machines to cloud-based platforms. Python’s compatibility with different operating systems ensures that deep learning solutions can be seamlessly integrated into diverse deployment scenarios, enhancing their usability and reach.
What Are Radial Basis Function Networks (RBFNs)?
Radial Basis Function Networks, abbreviated as RBFNs, are a class of artificial neural networks frequently employed for tasks such as function approximation, classification, and clustering. These networks excel in addressing challenges involving nonlinear or discontinuous data.
The fundamental concept of RBFNs revolves around the use of radial basis functions as their activation functions. Positioned at specific locations within the input space, these functions enable the transformation of input data into a higher-dimensional space, facilitating easier separation and classification of the data.
What Python tools and libraries are needed for RBFN development?
Developing a Radial Basis Function Network (RBFN) in Python can be facilitated using several libraries and tools. Here’s a list of the most commonly used ones:
Core Libraries
1. NumPy:
- Purpose: For numerical operations and handling arrays.
- Installation:
pip install numpy
2. SciPy:
- Purpose: For scientific computing, including optimization and special functions.
- Installation:
pip install scipy
3. scikit-learn:
- Purpose: Although scikit-learn doesn’t have a dedicated RBFN implementation, it provides tools for clustering (e.g., k-means) which can be useful for selecting centers, and other utilities for data preprocessing.
- Installation:
pip install scikit-learn
Data Handling and Visualization
4. Pandas:
- Purpose: For data manipulation and analysis.
- Installation:
pip install pandas
5. Matplotlib:
- Purpose: For plotting and visualizing data.
- Installation:
pip install matplotlib
6. Seaborn:
- Purpose: For statistical data visualization, built on top of Matplotlib.
- Installation:
pip install seaborn
Example Code
Here’s a basic example of how you can implement an RBFN using these libraries:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
import numpy as np from scipy.spatial.distance import cdist from sklearn.cluster import KMeans from sklearn.linear_model import LinearRegression class RBFN: def __init__(self, num_centers, spread): self.num_centers = num_centers self.spread = spread def _rbf(self, X, centers, spread): return np.exp(-cdist(X, centers) ** 2 / (2 * spread ** 2)) def fit(self, X, y): # Step 1: Use k-means to find centers kmeans = KMeans(n_clusters=self.num_centers) kmeans.fit(X) self.centers = kmeans.cluster_centers_ # Step 2: Calculate the RBF activations RBF_X = self._rbf(X, self.centers, self.spread) # Step 3: Train linear regression on RBF activations self.regressor = LinearRegression() self.regressor.fit(RBF_X, y) def predict(self, X): RBF_X = self._rbf(X, self.centers, self.spread) return self.regressor.predict(RBF_X) # Sample usage if __name__ == "__main__": from sklearn.datasets import make_regression from sklearn.model_selection import train_test_split from sklearn.metrics import mean_squared_error # Generate synthetic data X, y = make_regression(n_samples=100, n_features=2, noise=0.1) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # Initialize and train RBFN rbfn = RBFN(num_centers=10, spread=1.0) rbfn.fit(X_train, y_train) # Predict and evaluate y_pred = rbfn.predict(X_test) mse = mean_squared_error(y_test, y_pred) print(f"Mean Squared Error: {mse}") # Plot results import matplotlib.pyplot as plt plt.scatter(y_test, y_pred) plt.xlabel("True Values") plt.ylabel("Predictions") plt.title("RBFN Predictions vs True Values") plt.show() |
These libraries provide a solid foundation for developing and experimenting with RBFNs in Python.
Radial basis function networks (RBFNs) as building blocks for more complex networks in AI
Radial basis function networks (RBFNs) are the building blocks for various applications in machine learning and neural networks, particularly for tasks involving pattern recognition, function approximation, and time-series prediction. They are characterized by their use of radial basis functions as activation functions, which measure the distance between input data points and a set of center points. This unique feature allows RBFNs to capture local patterns in the data, making them highly effective for interpolation and classification tasks.
Moreover, RBFNs serve as foundational components in more complex architectures and algorithms, such as support vector machines and Gaussian processes, further extending their utility in the field of artificial intelligence.
The following is an example of the employment of RBFNNs for Navigation Systems:
RBFNs vs MLPs
Radial Basis Function Networks (RBFNs) and Multilayer Perceptrons (MLPs) are both types of artificial neural networks used in machine learning, but they have distinct structures and mechanisms for processing information.
Comparison
Structure and Complexity:
RBFNs are simpler in structure compared to MLPs. RBFNs have a single hidden layer, while MLPs can have multiple hidden layers.
Training Process:
The training of RBFNs is typically faster as it involves finding centers and spreads followed by linear output weights. MLPs require iterative backpropagation, which can be computationally intensive.
Interpretability:
RBFNs, with their localized response to input data, can be more interpretable than MLPs, where the influence of individual neurons is harder to decipher.
Function Approximation:
RBFNs are often preferred for tasks requiring interpolation and where the relationship between inputs and outputs is locally smooth. MLPs, on the other hand, are more versatile and can handle more complex, non-linear relationships.
Generalization:
MLPs generally have better generalization capabilities due to their deeper architecture and non-linear activations, making them suitable for a broader range of tasks compared to the typically shallow architecture of RBFNs.
In summary, while both RBFNs and MLPs are powerful tools in machine learning, they are suited to different types of problems and have distinct strengths and weaknesses. RBFNs are often used for their simplicity and effectiveness in local function approximation, while MLPs are favored for their flexibility and ability to model complex global patterns in data.
RBFNs vs LSTMs
On the other hand, the following are the key differences between RBFNs and LSTMs:
Architecture
RBFNs:
- Structure: Comprise three layers—input, hidden (with radial basis functions as activation functions), and output.
- Hidden Layer: Uses radial basis functions (e.g., Gaussian functions) that respond to the distance between the input and a center.
- Output: Produces a linear combination of the hidden layer activations.
- Training: Involves determining centers and widths of the radial basis functions, followed by training the output weights using linear regression techniques.
LSTMs:
For more details on LSTMs, please refer to our previous article:
- Structure: A type of recurrent neural network (RNN) with cells that include gates to manage memory and state.
- Cells: Each LSTM cell has input, output, and forget gates to control the flow of information.
- Memory: Designed to retain information over long sequences, addressing the vanishing gradient problem common in traditional RNNs.
- Training: Uses backpropagation through time (BPTT) to update weights, which can be computationally intensive.
Applications
RBFNs:
- Function Approximation: Well-suited for interpolating functions in multi-dimensional space.
- Classification: Can classify data by learning decision boundaries.
- Regression: Useful for predicting continuous values.
- Time-Series Prediction: Applied to forecasting future values based on past data, though not as effective as LSTMs for long sequences.
LSTMs:
- Sequential Data: Ideal for tasks involving sequences, such as natural language processing (NLP), speech recognition, and time-series prediction.
- Memory Retention: Effective in capturing long-term dependencies in data sequences.
- Complex Patterns: Capable of learning intricate patterns over time, making them suitable for tasks like language translation, sentiment analysis, and video analysis.
Strengths and Weaknesses
RBFNs:
- Strengths:
- Fast Training: Training the output layer is relatively quick.
- Simple Architecture: Easier to implement and understand compared to LSTMs.
- Strong Interpolation: Good at interpolating data in multi-dimensional spaces.
- Weaknesses:
- Scalability: May struggle with large datasets and high-dimensional data.
- Parameter Selection: Choosing centers, widths, and the number of hidden neurons can be challenging.
LSTMs:
- Strengths:
- Long-Term Dependencies: Excellent at capturing long-term dependencies in sequential data.
- Versatility: Effective for a wide range of tasks involving sequential data.
- Advanced Memory Management: Gates in LSTM cells manage the flow of information efficiently.
- Weaknesses:
- Complex Training: Training can be computationally intensive and slow due to the complexity of the architecture.
- Overfitting: Prone to overfitting if not properly regularized, especially with limited data.
Summary
- RBFNs are best suited for problems involving interpolation, classification, and simple time-series prediction.
They are easier to train and understand but may not scale well with large and complex datasets.
- LSTMs excel in handling sequential data with long-term dependencies, such as in NLP and advanced time-series prediction.
They are more complex and require more computational resources but are highly effective for tasks involving sequences.
Choosing between RBFNs and LSTMs depends on the specific nature of the problem at hand. If the task involves learning from sequential data with long-term dependencies, LSTMs are generally the better choice. For simpler problems involving function approximation or classification in multi-dimensional space, RBFNs might be more appropriate.
Hands-On RBFNs 1: Stock market prediction
This example uses synthetic data for simplicity, but you can replace it with actual stock market data:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 |
import numpy as np from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler from sklearn.metrics import mean_squared_error import matplotlib.pyplot as plt # Generate synthetic stock market data np.random.seed(42) X = np.linspace(0, 10, 100).reshape(-1, 1) y = np.sin(X).ravel() + np.random.normal(scale=0.1, size=X.shape[0]) # Split data into training and test sets X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # Standardize the data scaler = StandardScaler() X_train_scaled = scaler.fit_transform(X_train) X_test_scaled = scaler.transform(X_test) class RBFNetwork: def __init__(self, num_input, num_hidden, num_output, sigma=1.0): self.num_input = num_input self.num_hidden = num_hidden self.num_output = num_output self.sigma = sigma self.centers = None self.weights = None def _calculate_centers(self, X): idx = np.random.choice(X.shape[0], self.num_hidden, replace=False) centers = X[idx] return centers def _compute_activation(self, X): activation = np.zeros((X.shape[0], self.num_hidden)) for i in range(self.num_hidden): activation[:, i] = np.exp(-np.linalg.norm(X - self.centers[i], axis=1) ** 2 / (2 * self.sigma ** 2)) return activation def fit(self, X, y): self.centers = self._calculate_centers(X) activation = self._compute_activation(X) self.weights = np.dot(np.linalg.pinv(activation), y) def predict(self, X): activation = self._compute_activation(X) output = np.dot(activation, self.weights) return output # Initialize RBF network num_hidden_neurons = 10 rbf_net = RBFNetwork(num_input=X_train_scaled.shape[1], num_hidden=num_hidden_neurons, num_output=1, sigma=1.0) # Train the network rbf_net.fit(X_train_scaled, y_train) # Make predictions y_train_pred = rbf_net.predict(X_train_scaled) y_test_pred = rbf_net.predict(X_test_scaled) # Evaluate the model train_mse = mean_squared_error(y_train, y_train_pred) test_mse = mean_squared_error(y_test, y_test_pred) print(f'Train MSE: {train_mse:.4f}') print(f'Test MSE: {test_mse:.4f}') # Plot the results plt.figure(figsize=(10, 6)) plt.plot(X, y, 'b-', label='True Data') plt.plot(X_train, y_train_pred, 'ro', label='Train Predictions') plt.plot(X_test, y_test_pred, 'go', label='Test Predictions') plt.legend() plt.xlabel('X') plt.ylabel('y') plt.title('RBF Network - Stock Market Prediction') plt.show() |
To execute the code above seamlessly without any errors, we can utilize the PyScripter IDE.
What did the code above do?
Let’s break down the important parts of the code above.
We’ll use the numpy library for numerical operations and sklearn for preprocessing. Here’s the step-by-step code:
1. Import Libraries
Import the necessary libraries.
2. Prepare Data
Load and preprocess your stock market data. For demonstration, we will create synthetic stock market data. Replace this with your actual data.
3. Define the RBF Network
Implement the RBF network class.
4. Train the Model
Train the RBFN on the training data.
5. Make Predictions
Use the trained model to make predictions.
This is a basic implementation to demonstrate how an RBFN can be applied to stock market prediction.
For real-world applications, you should:
1. Use Real Stock Market Data
Replace the synthetic data generation with actual stock market data loading and preprocessing.
2. Tune Hyperparameters
Optimize the number of hidden neurons, sigma, and other hyperparameters using cross-validation or other techniques.
3. Feature Engineering
Use relevant financial indicators and features that affect stock prices.
4. Regularization and Advanced Techniques
Incorporate regularization, cross-validation, and more advanced techniques to improve model robustness and performance.
Hands-On RBFNs 2: Anomaly detection
Below is a Python example of how you can use a Radial Basis Function Network (RBFN) for anomaly detection. This example uses synthetic data for simplicity, but you can replace it with actual data.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
import numpy as np import matplotlib.pyplot as plt from sklearn.cluster import KMeans from sklearn.datasets import make_classification from sklearn.linear_model import LinearRegression from sklearn.metrics import accuracy_score import scipy.spatial.distance as distance class RadialBasisFunctionNeuralNetwork: def __init__(self, num_of_rbf_units=10): self.num_of_rbf_units = num_of_rbf_units def _rbf_unit(self, rbf_center, point_in_dataset): return np.exp(-self.beta * distance.cdist([point_in_dataset], [rbf_center], 'euclidean')**2).flatten()[0] def _construct_interpolation_matrix(self, input_dataset): interpolation_matrix = np.zeros((len(input_dataset), self.num_of_rbf_units)) for idx, point_in_dataset in enumerate(input_dataset): for center_idx, rbf_center in enumerate(self.rbf_centers): interpolation_matrix[idx, center_idx] = self._rbf_unit(rbf_center, point_in_dataset) return interpolation_matrix def train_model(self, input_dataset, target_dataset): self.kmeans_clustering = KMeans(n_clusters=self.num_of_rbf_units, random_state=0).fit(input_dataset) self.rbf_centers = self.kmeans_clustering.cluster_centers_ self.beta = 1.0 / (2.0 * (self.kmeans_clustering.inertia_ / input_dataset.shape[0])) interpolation_matrix = self._construct_interpolation_matrix(input_dataset) self.model_weights = np.linalg.pinv(interpolation_matrix.T.dot(interpolation_matrix)).dot(interpolation_matrix.T).dot(target_dataset) def predict(self, input_dataset): interpolation_matrix = self._construct_interpolation_matrix(input_dataset) predicted_values = interpolation_matrix.dot(self.model_weights) return predicted_values if __name__ == "__main__": # Generating a simple classification dataset input_dataset, target_dataset = make_classification(n_samples=500, n_features=2, n_informative=2, n_redundant=0, n_classes=2) # Initializing and training the RBF neural network rbf_neural_network = RadialBasisFunctionNeuralNetwork(num_of_rbf_units=20) rbf_neural_network.train_model(input_dataset, target_dataset) # Predicting the target values predictions = rbf_neural_network.predict(input_dataset) # Converting continuous output to binary labels binary_predictions = np.where(predictions > 0.5, 1, 0) # print("Accuracy: {}".format(accuracy_score(target_dataset, binary_predictions))) print(f"Accuracy: {accuracy_score(target_dataset, binary_predictions)}") # Plotting the results plt.scatter(input_dataset[:, 0], input_dataset[:, 1], c=binary_predictions, cmap='viridis', alpha=0.7) plt.scatter(rbf_neural_network.rbf_centers[:, 0], rbf_neural_network.rbf_centers[:, 1], c='red') plt.title('Classification Result') plt.show() |
To execute the code above seamlessly without any errors, we can utilize the PyScripter IDE.
What did the code above do?
Let’s break down the important parts of the code above.
1. Import Libraries
Import necessary libraries.
2. Prepare Data
- Generate and preprocess data. For demonstration, we will create synthetic normal and anomalous data.
- Split the data into training and test sets.
- Standardize the data.
3. Define the RBF Network
Implement the RBF network class: Define an RBF network class with methods to fit the model, predict outputs, and calculate reconstruction errors.
4. Train the Model
Train the RBF network using only the normal data.
5. Anomaly Detection
Use the trained model to detect anomalies. We use the trained model to detect anomalies based on reconstruction error:
- Calculate the reconstruction error for both training and test sets.
- Determine a threshold for anomaly detection (e.g., the 95th percentile of training errors).
- Classify anomalies based on whether their reconstruction error exceeds the threshold.
- Evaluate and visualize the results.
This example demonstrates how to use an RBF network for anomaly detection. For real-world applications, you should adjust the data preprocessing, network parameters, and threshold determination based on the specific characteristics of your data and use case.
Hands-On RBFNs 3: Signal processing
Radial Basis Function Networks (RBFNs) are a type of artificial neural network used for various applications, including signal processing. Below is a Python code example demonstrating signal processing using an RBFN.
For this example, let’s use the scikit-learn library, which provides tools to work with RBFNs through its RBFSampler and MLPRegressor classes.
Here is the Python code for signal processing using an RBFN:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
import numpy as np import matplotlib.pyplot as plt from sklearn.kernel_approximation import RBFSampler from sklearn.linear_model import Ridge # Generate a sample signal (e.g., a noisy sine wave) np.random.seed(42) n_samples = 100 X = np.linspace(0, 4 * np.pi, n_samples).reshape(-1, 1) y = np.sin(X).ravel() + np.random.normal(scale=0.1, size=n_samples) # Plot the original noisy signal plt.figure(figsize=(10, 6)) plt.plot(X, y, label='Noisy signal') plt.title('Original Noisy Signal') plt.xlabel('Time') plt.ylabel('Amplitude') plt.legend() plt.show() # Use RBFSampler to approximate the RBF kernel rbf_sampler = RBFSampler(gamma=1.0, n_components=100, random_state=42) X_features = rbf_sampler.fit_transform(X) # Train a Ridge regression model on the RBF features model = Ridge(alpha=1.0) model.fit(X_features, y) # Predict the signal using the trained model y_pred = model.predict(X_features) # Plot the original noisy signal and the filtered signal plt.figure(figsize=(10, 6)) plt.plot(X, y, label='Noisy signal') plt.plot(X, y_pred, label='Filtered signal', color='red') plt.title('Signal Processing using RBFN') plt.xlabel('Time') plt.ylabel('Amplitude') plt.legend() plt.show() |
To execute the code above seamlessly without any errors, we can utilize the PyScripter IDE.
What did the code above do?
1. Generate a Sample Signal
We create a noisy sine wave as an example signal.
2. Plot the Original Noisy Signal
We visualize the noisy signal.
3. RBFSampler
We use the RBFSampler to approximate the RBF kernel, transforming the input data X into a higher-dimensional feature space.
4. Ridge Regression
We use Ridge regression on the transformed features to fit the model. Ridge regression is used here due to its robustness in handling collinearity and overfitting.
5. Predict the Signal
We use the trained model to predict the signal.
6. Plot the Original and Filtered Signal
We visualize the noisy signal alongside the filtered signal obtained through the RBFN.
Notes
- The parameter
gammainRBFSamplercontrols the width of the RBF kernel. You might need to tune this parameter for your specific application. - The
n_componentsparameter determines the number of features generated by theRBFSampler. Increasing this value can improve the model’s performance but will also increase computational complexity. - Ridge regression is used for its simplicity and effectiveness in this example. Depending on your application, other regression methods or neural network models could be used.
This code provides a basic framework for using RBFNs for signal processing tasks. You can further customize and optimize it for your specific requirements.
Conclusion
Radial Basis Function Networks (RBFNs) are a versatile and powerful tool in the deep learning and machine learning toolbox, particularly suited for tasks such as interpolation, classification, and regression. Their unique architecture and use of radial basis functions as activation functions allow them to effectively capture local patterns in data, making them highly valuable for specific applications.
By leveraging the power of Python and its rich ecosystem of libraries, you can efficiently implement and experiment with RBFNs for a wide range of tasks. Whether you are tackling stock market predictions, anomaly detection, or signal processing, Python’s straightforward syntax, extensive libraries, and strong community support make it an ideal choice for developing deep learning models.
RBFNs, with their simplicity and effectiveness, serve as building blocks for more complex neural networks and machine learning algorithms. While they may not always match the complexity and scalability of other models like Multilayer Perceptrons (MLPs) or Long Short-Term Memory networks (LSTMs), RBFNs offer a practical and interpretable approach to solving specific types of problems.
As you delve deeper into the world of deep learning and explore the capabilities of RBFNs, you’ll find that these networks provide a robust foundation for building intelligent systems that can learn and adapt. By continuously experimenting and refining your models, you can unlock the full potential of Python for deep learning with Radial Basis Function Networks.
Check out the full repository here:
github.com/Embarcadero/DL_Python06_GAN
Click here to get started with PyScripter, a free, feature-rich, and lightweight Python IDE.
Download RAD Studio to create more powerful Python GUI Windows Apps in 5x less time.
Check out Python4Delphi, which makes it simple to create Python GUIs for Windows using Delphi.
Also, look into DelphiVCL, which makes it simple to create Windows GUIs with Python.
References & further readings
[1] Biswal, A. (2023).
Top 10 Deep Learning Algorithms You Should Know in 2023. Simplilearn. simplilearn.com/tutorials/deep-learning-tutorial/deep-learning-algorithm
[2] Buhmann, M. D. (2000).
Radial basis functions. Acta numerica, 9, 1-38.
[3] Jwo, D. J., Biswal, A., & Mir, I. A. (2023).
Artificial neural networks for navigation systems: A review of recent research. Applied Sciences, 13(7), 4475.
[4] Lowe, D., & Broomhead, D. (1988).
Multivariable functional interpolation and adaptive networks. Complex systems, 2(3), 321-355.
[5] Olabanjo, O. A., Wusu, A. S., & Manuel, M. (2022).
A machine learning prediction of academic performance of secondary school students using radial basis function neural network. Trends in Neuroscience and Education, 29, 100190.
[6] Park, J., & Sandberg, I. W. (1991).
Universal approximation using radial-basis-function networks. Neural computation, 3(2), 246-257.
[7] scikit-learn developers. (2007-2024).
1.17.1. Multi-layer Perceptron, in 1.17. Neural network models (supervised). scikit-learn docs. scikit-learn.org/stable/modules/ neural_networks_supervised.html#multi-layer-perceptron
[8] Simplilearn. (2023).
What are Radial Basis Functions Neural Networks? Everything You Need to Know. Simplilearn. simplilearn.com/tutorials/machine-learning-tutorial/what-are-radial-basis-functions-neural-networks
