Note Management System

Edit Note

Title:

Content:

Let's go through the code to understand how the neural network is set up, how the weights, biases, and layers work, and how it processes input to make predictions.

1. Class Definition: NeuralNetwork
The NeuralNetwork class represents the neural network and handles the essential operations: initializing layers, weights, and biases, feeding forward data, and performing matrix operations.

php
Copy code
class NeuralNetwork {
    private $layers;  // Array defining the number of neurons in each layer
    private $weights; // Weights for each layer
    private $biases;  // Biases for each layer
$layers: This defines the structure of the neural network — how many neurons there are in each layer.
$weights: This array holds the weight matrices that define the strength of connections between neurons in consecutive layers.
$biases: This array holds the bias values for each neuron in the network.
2. Constructor: __construct($layers)
The constructor initializes the network by setting up layers, weights, and biases.

php
Copy code
public function __construct($layers) {
    $this->layers = $layers;  // Set layers
    $this->weights = [];      // Initialize weights array
    $this->biases = [];       // Initialize biases array

// Initialize weights and biases with random values
    for ($i = 1; $i < count($layers); $i++) {
        $this->weights[$i] = $this->randomMatrix($layers[$i], $layers[$i-1]);
        $this->biases[$i] = $this->randomMatrix($layers[$i], 1);
    }
}
The constructor accepts an array $layers that defines the number of neurons in each layer (e.g., [12, 10, 9, 2, 3] for 12 neurons in the input layer, 10 in the first hidden layer, etc.).
The weights for each layer are initialized using the randomMatrix method. It generates matrices with random values between -1 and 1. This randomness ensures the network starts with different weights for each training process.
3. Method: randomMatrix($rows, $cols)
This method creates a matrix (2D array) with random values for weights or biases.

php
Copy code
private function randomMatrix($rows, $cols) {
    $matrix = [];
    for ($i = 0; $i < $rows; $i++) {
        for ($j = 0; $j < $cols; $j++) {
            $matrix[$i][$j] = mt_rand(-1000, 1000) / 1000; // Random values between -1 and 1
        }
    }
    return $matrix;
}
It generates random values for each element in a matrix of size rows x cols.
The random values are between -1 and 1 (scaled from mt_rand(-1000, 1000) to a value between -1 and 1).
4. Method: feedForward($input)
This method performs the feedforward operation to pass the input data through the network and obtain the output.

php
Copy code
public function feedForward($input) {
    $output = $input;

// Loop through each layer
    for ($i = 1; $i < count($this->layers); $i++) {
        // Matrix multiplication of inputs and weights + bias
        $output = $this->sigmoid($this->matrixAdd($this->matrixMultiply($this->weights[$i], $output), $this->biases[$i]));
    }
    return $output;
}
Input: The input data is passed to the first layer.
Loop: The data flows through each layer of the network (starting from the input layer).
For each layer, matrix multiplication of weights and inputs is performed, followed by adding biases.
The result is passed through the activation function (sigmoid in this case) to introduce non-linearity.
5. Method: sigmoid($x)
This method applies the sigmoid activation function.

php
Copy code
private function sigmoid($x) {
    if (is_array($x)) {
        foreach ($x as &$row) {
            foreach ($row as &$value) {
                $value = 1 / (1 + exp(-$value));  // Apply sigmoid function element-wise
            }
        }
    } else {
        $x = 1 / (1 + exp(-$x)); // Apply sigmoid function to single value
    }
    return $x;
}
Sigmoid function: The sigmoid function transforms inputs into a range between 0 and 1, making it suitable for binary classification problems (e.g., "Will Buy" or "Won't Buy").
6. Matrix Operations
Two important operations are used to process data through the network:

Matrix Multiplication (matrixMultiply): This function multiplies two matrices.
Matrix Addition (matrixAdd): This function adds two matrices (used for adding weights and biases).
7. Display Weights
The displayWeights method is used to output the weights for each layer.

php
Copy code
public function displayWeights() {
    foreach ($this->weights as $key => $layerWeights) {
        echo "Weights for layer $key:<br>";
        foreach ($layerWeights as $neuronWeights) {
            echo "[" . implode(", ", $neuronWeights) . "]<br>";
        }
    }
}
This is useful for debugging or inspecting the network's learned parameters.

8. Form for Prediction
The form collects user input (e.g., age, salary, experience, education) and submits it as a POST request. The neural network then uses the input to predict whether the person will buy the product.

php
Copy code
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    if (isset($_POST['age'], $_POST['salary'], $_POST['experience'], $_POST['education'], $_POST['marital_status'], $_POST['location'])) {
        $input = [
            [floatval($_POST['age'])],
            [floatval($_POST['salary'])],
            [floatval($_POST['experience'])],
            [floatval($_POST['education'])],
            [floatval($_POST['marital_status'])],
            [floatval($_POST['location'])],
            // Add additional fields if needed to fill all 12 input neurons
            [0.0], [0.0], [0.0], [0.0], [0.0], [0.0]
        ];

// Perform feedforward operation to get the prediction
        $output = $nn->feedForward($input);
        $prediction = $output[0][0] >= 0.5 ? "Will Buy" : "Won't Buy";
        echo "Prediction: $prediction<br>";
        echo "Predicted Probability: " . number_format($output[0][0], 4);
    } else {
        echo "Please fill in all the fields.";
    }
}
Prediction: After the user submits the form, the feedForward method is called to calculate the network's prediction based on the input.
Output: The prediction is displayed along with the predicted probability.
Conclusion
In summary, the code represents a simple feedforward neural network for binary classification. It uses layers, weights, and biases to process input data and make predictions. The weights and biases are initialized randomly and the neural network can be trained (though training is not covered here). The neural network uses the sigmoid activation function and matrix operations to propagate data through the layers.
////////////////////////////////////////////////////

Neural Network Initialization (__construct):

This class creates a 6-layer neural network.
The layers are [6, 35, 35, 35, 35, 1], where 6 is the number of input neurons, 35 is the number of neurons in each hidden layer, and 1 is the output neuron.
Weights and biases for each layer are randomly initialized.
<?php

class NeuralNetwork {
    private $layers;  // Array defining the number of neurons in each layer
    private $weights; // Weights for each layer
    private $biases;  // Biases for each layer

public function __construct($layers) {
        $this->layers = $layers;
        $this->weights = [];
        $this->biases = [];

// Initialize weights and biases with random values
        for ($i = 1; $i < count($layers); $i++) {
            $this->weights[$i] = $this->randomMatrix($layers[$i], $layers[$i-1]);
            $this->biases[$i] = $this->randomMatrix($layers[$i], 1);
        }
    }

// Random matrix initialization function
    private function randomMatrix($rows, $cols) {
        $matrix = [];
        for ($i = 0; $i < $rows; $i++) {
            for ($j = 0; $j < $cols; $j++) {
                $matrix[$i][$j] = mt_rand(-1000, 1000) / 1000; // Random values between -1 and 1
            }
        }
        return $matrix;
    }

// Feed forward function to pass data through the network
    public function feedForward($input) {
        $output = $input;

// Loop through each layer
        for ($i = 1; $i < count($this->layers); $i++) {
            // Matrix multiplication of inputs and weights + bias
            $output = $this->sigmoid($this->matrixAdd($this->matrixMultiply($this->weights[$i], $output), $this->biases[$i]));
        }
        return $output;
    }

// Sigmoid activation function
    private function sigmoid($x) {
        if (is_array($x)) {
            foreach ($x as &$row) {
                foreach ($row as &$value) {
                    $value = 1 / (1 + exp(-$value));  // Apply sigmoid function element-wise
                }
            }
        } else {
            $x = 1 / (1 + exp(-$x)); // Apply sigmoid function to single value
        }
        return $x;
    }

// Matrix multiplication function
    private function matrixMultiply($a, $b) {
        $rowsA = count($a);
        $colsA = count($a[0]);
        $colsB = count($b[0]);
        $result = [];

for ($i = 0; $i < $rowsA; $i++) {
            for ($j = 0; $j < $colsB; $j++) {
                $sum = 0;
                for ($k = 0; $k < $colsA; $k++) {
                    $sum += $a[$i][$k] * $b[$k][$j];
                }
                $result[$i][$j] = $sum;
            }
        }
        return $result;
    }

// Matrix addition function
    private function matrixAdd($a, $b) {
        $rows = count($a);
        $cols = count($a[0]);
        $result = [];

for ($i = 0; $i < $rows; $i++) {
            for ($j = 0; $j < $cols; $j++) {
                $result[$i][$j] = $a[$i][$j] + $b[$i][$j];
            }
        }
        return $result;
    }
}

// Define the number of neurons in each layer (6 input features, 4 hidden layers with 35 neurons each, 1 output neuron)
$nn = new NeuralNetwork([6, 35, 35, 35, 35, 1]);

// Check if the form is submitted
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    // Collect input data from the form
    if (isset($_POST['age'], $_POST['salary'], $_POST['experience'], $_POST['education'], $_POST['marital_status'], $_POST['location'])) {
        
        // Convert form inputs to float
        $input = [
            [floatval($_POST['age'])],
            [floatval($_POST['salary'])],
            [floatval($_POST['experience'])],
            [floatval($_POST['education'])],
            [floatval($_POST['marital_status'])],
            [floatval($_POST['location'])]
        ];

// Perform feedforward operation to get the prediction
        $output = $nn->feedForward($input);
        $prediction = $output[0][0] >= 0.5 ? "Will Buy" : "Won't Buy";

// Display the result
        echo "Prediction: $prediction<br>";
        echo "Predicted Probability: " . number_format($output[0][0], 4);
    } else {
        echo "Please fill in all the fields.";
    }
} else {
    echo "Please submit the form to get a prediction.";
}
?>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Predict Product Purchase</title>
</head>
<body>
    <h1>Predict if someone will buy a product</h1>

<label for="salary">Salary:</label>
        <input type="number" step="any" id="salary" name="salary" required><br>

<label for="experience">Years of Experience:</label>
        <input type="number" step="any" id="experience" name="experience" required><br>

<label for="education">Education Level:</label>
        <select id="education" name="education" required>
            <option value="1">High School</option>
            <option value="2">Bachelor's</option>
            <option value="3">Master's</option>
            <option value="4">PhD</option>
        </select><br>

<label for="marital_status">Marital Status:</label>
        <select id="marital_status" name="marital_status" required>
            <option value="0">Single</option>
            <option value="1">Married</option>
        </select><br>

<label for="location">Location:</label>
        <input type="text" id="location" name="location" required><br>

</body>
</html>

//////////////////////////////

<?php