- Overview
- Core Components
- Mathematical Foundation
- Class Reference
- Activation Functions
- Training Method
- Evaluation Metrics
- Implementation Guide
- Example Usage
The FNN (Fuzzy Neural Network) module implements a hybrid intelligent system that combines neural networks with fuzzy logic principles. This implementation is specifically optimized for Arduino platforms, providing efficient computation while maintaining prediction accuracy.
class FNN {
private:
std::vector<std::vector<float>> weights; // Layer weights
std::vector<float> biases; // Layer biases
std::function<float(float)> activationFunction; // Activation function
std::map<std::string, float> fuzzyRules; // Fuzzy ruleset
...
}
- Multi-layer neural network architecture
- Customizable activation functions
- Integrated fuzzy rule system
- Gradient descent-based training
- Comprehensive evaluation metrics
- Accepts normalized input vectors
- Dimension:
inputSize
(user-defined) - Data type:
std::vector<float>
Hidden Layer
Computation formula:
Where:
-
$h_j$ : Hidden layer neuron output -
$w_{ji}$ : Connection weight -
$x_i$ : Input value -
$b_j$ : Bias term -
$f$ : Activation function
Final computation:
Parameters:
-
$h_j$ : Hidden layer outputs -
$w_j$ : Output weights -
$b_o$ : Output bias
Components:
-
$y_i$ : Expected output -
$\hat{y}_i$ : Predicted output -
$N$ : Sample size
Where:
-
$\eta$ : Learning rate -
$\frac{\partial L}{\partial w}$ : Loss gradient
FNN(int inputSize = 3, float bias = 0.1, std::function<float(float)> activation = nullptr)
Parameters:
inputSize
: Number of input neuronsbias
: Initial bias valueactivation
: Activation function (defaults to sigmoid)
void setWeights(const std::vector<float>& newWeights)
Purpose: Sets network layer weights Parameters:
newWeights
: Vector of weight values Validation: Checks dimension compatibility
void setBiases(const std::vector<float>& newBiases)
Purpose: Sets layer biases Parameters:
newBiases
: Vector of bias values Validation: Verifies vector size
void setFuzzyRules(const std::map<std::string, float>& rules)
Purpose: Defines fuzzy classification rules Parameters:
rules
: Map of linguistic terms to numeric values
void train(const std::vector<std::vector<float>>& inputs,
const std::vector<std::string>& targets,
int epochs = 100,
float learningRate = 0.01)
Purpose: Trains the network Parameters:
inputs
: Training data matrixtargets
: Expected outputsepochs
: Training iterationslearningRate
: Learning rate
Implementation:
static float sigmoid(float x) {
return 1.0 / (1.0 + exp(-x));
}
Use case: General classification tasks
Implementation:
static float tanh(float x) {
return std::tanh(x);
}
Use case: Normalized data ranges
Implementation:
static std::function<float(float)> leakyRelu(float alpha = 0.01)
Use case: Deep networks, preventing dying ReLU
float evaluateAccuracy(const std::vector<std::vector<float>>& testInputs,
const std::vector<std::string>& expectedOutputs)
Calculation:
accuracy = (correct_predictions / total_predictions) * 100
float evaluatePrecision(const std::vector<std::vector<float>>& testInputs,
const std::vector<std::string>& expectedOutputs)
Calculation:
precision = (true_positives / (true_positives + false_positives)) * 100
#include "fnn.h"
FNN fnn(6); // 6 input neurons
// Weight initialization
fnn.setWeights({0.3, 0.5, 0.2, 0.4, 0.1, 0.6});
// Bias configuration
fnn.setBiases({0.1, 0.2});
// Activation function selection
fnn.setActivationFunction(FNN::sigmoid);
// Fuzzy rule definition
fnn.setFuzzyRules({
{"Not Suitable", 0.0},
{"Low", 0.2},
{"High", 1.0}
});
// Training parameters
int numEpochs = 1000;
float learningRate = 0.01;
// Training data format
std::vector<std::vector<float>> trainingInputs = {
{4.5, 2.8, 0.9, 3.7, 3.1, 7.9},
{1.2, 0.6, 0.3, 0.5, 0.2, 0.7}
};
std::vector<std::string> trainingTargets = {"High", "Low"};
#include "fnn.h"
FNN fnn(6);
void setup() {
Serial.begin(9600);
// Configuration
fnn.setWeights({0.3, 0.5, 0.2, 0.4, 0.1, 0.6});
fnn.setBiases({0.1, 0.2});
fnn.setActivationFunction(FNN::sigmoid);
// Fuzzy rules
fnn.setFuzzyRules({
{"Not Suitable", 0.0},
{"Low", 0.2},
{"Very Low", 0.4},
{"Below Average", 0.6},
{"Above Average", 0.7},
{"High", 1.0},
{"Extreme", 1.1}
});
// Training data
std::vector<std::vector<float>> trainingInputs = {
{4.5, 2.8, 0.9, 3.7, 3.1, 7.9},
{1.2, 0.6, 0.3, 0.5, 0.2, 0.7},
{0.4, 0.3, 0.2, 0.6, 0.5, 0.4}
};
std::vector<std::string> trainingTargets = {
"High", "Low", "Not Suitable"
};
// Training
int numEpochs = 1000;
float learningRate = 0.01;
// Train and evaluate
for (int epoch = 0; epoch < numEpochs; ++epoch) {
fnn.train(trainingInputs, trainingTargets, 1, learningRate);
if (epoch % 100 == 0) {
float accuracy = fnn.evaluateAccuracy(trainingInputs, trainingTargets);
Serial.print("Epoch: ");
Serial.print(epoch);
Serial.print(" Accuracy: ");
Serial.println(accuracy);
}
}
}
void loop() {
// Prediction example
std::vector<float> newInput = {4.5, 2.8, 0.9, 3.7, 3.1, 7.9};
String prediction = fnn.predictFNN(newInput).c_str();
Serial.println(prediction);
delay(1000);
}
- Use fixed-point arithmetic where possible
- Minimize dynamic memory allocation
- Optimize matrix operations
- Cache frequently used calculations
The module includes comprehensive error checking:
- Input validation
- Memory allocation verification
- Dimension compatibility checks
- Fuzzy rule consistency validation
Contributions are welcome. Please follow the standard pull request process:
- Fork the repository
- Create your feature branch
- Commit your changes
- Push to the branch
- Create a Pull Request
For issues and feature requests, please create an issue in the repository.
No | Name | Address |
---|---|---|
1 | Galih Ridho Utomo | Perum Permata Blok CB 20 / 10 Keluruhan Gelam Jaya, Kecamatan Pasar Kemis, Kabupaten Tangerang, Provinsi Banten, Pasar Kemis, Tangerang |
2 | Septi Ida Suryani | Sraten RT 05/ RW 04, Cluring, Banyuwangi, Jawa Timur, Cluring, Banyuwangi |
3 | Deffrian Prayogo | Jl. Sreni Indah, RT 02/03, Bategede, Kec. Nalumsari, Kab. Jepara, Jawa Tengah, Nalumsari, Jepara |
4 | Achmad Rouf | Sempulur, RT 04, RW 01, Kel. Sempulur, Kec. Karanggede, Kab. Boyolali, Karanggede, Boyolali |
5 | Fionita Fahra Azzahra | Karang Asem, 01/06, Ketapang, Kec. Susukan, Kab. Semarang, Jawa Tengah, Susukan, Semarang |
6 | Dendy Randa | Tanjung Uncang, Batu Aji, Kota Batam, Kepulauan Riau, Batu Aji, Batam |
7 | Fahma Mutia Sari | Dusun Pancuran RT 01/RW 13, Desa Banyubiru, Kecamatan Banyubiru, Kab. Semarang, Jawa Tengah, Banyubiru, Semarang |
8 | Dava Arya Danendra | Jl. Wonodri Joho III No. 1002B, Wonodri, Semarang Selatan, Semarang Selatan, Semarang |
9 | Qotrunnada Fauziah Hasna | Ds. Ngeluk,RT/RW 01/01, Kec. Penawangan, Kab. Grobogan , Penawangan, Grobogan |
10 | Tamara Rizky Senda | RT 09/RW 02, Kelurahan Kramat Jati, Kec. Kramat Jati, Jakarta Timur, Provinsi DKI Jakarta , Kramat Jati, Jakarta Timur |
11 | Dika Saputra | Griya Asri Bahagia Blok F5 No 4 Kel. Bahagia Kec. Babelan Kab. Bekasi,Babelan,Bekasi |
Please cite this respotory, if your use in the publication
@misc{fnn,
author = {Utomo, Galih Ridho, Septi Ida Suryani, Deffrian Prayogo, Achmad Rouf, Fionita Fahra Azzahra, Dendy Randa, Dava Arya Danendra, Qotrunnada Fauziah Hasna, Tamara Rizky Senda, Dika Saputra},
title = {FNN (Fuzzy Neural Network) module implements a hybrid intelligent system that combines neural networks with fuzzy logic principles. This implementation is specifically optimized for Arduino platforms, providing efficient computation while maintaining prediction accuracy},
year = {2025},
howpublished = {\url{https://github.com/4211421036/fnn}},
note = {GitHub repository},
}