{"id":659,"date":"2025-05-18T12:23:19","date_gmt":"2025-05-18T10:23:19","guid":{"rendered":"https:\/\/renor.it\/neural-networks-in-php-yes-it-can-be-done\/"},"modified":"2025-12-20T15:53:59","modified_gmt":"2025-12-20T14:53:59","slug":"neural-networks-in-php-yes-it-can-be-done","status":"publish","type":"post","link":"https:\/\/renor.it\/en\/blog\/intelligenza-artificiale-algoritmi\/neural-networks-in-php-yes-it-can-be-done\/","title":{"rendered":"Neural Networks in PHP? Yes, It Can Be Done!"},"content":{"rendered":"\n

I\u2019ll begin this article with a premise\u2026 PHP is certainly not the ideal language when it comes to artificial intelligence. Neural networks are typically the domain of more scientific languages like Python, which offers optimized libraries for this purpose such as PyTorch and NumPy\u2014and that\u2019s usually the language I rely on when working in this kind of context. <\/p>\n\n

However, a few months ago I was chatting with a friend over an aperitif, and as usual, we started throwing around a bunch of silly ideas about AI (I\u2019ll spare you the wild ones we came up with). But then we focused on one specific topic: \u201cWould it be possible to create a neural network in PHP?\u201d
The short answer is yes\u2014albeit with some limitations. <\/p>\n\n

To understand this article, we first need to make a few preliminary remarks\u2026<\/p>\n\n

Introduction<\/h2>\n\n

In today\u2019s technological landscape, Artificial Intelligence (AI in English, or IA in Italian) is no longer a niche topic, but a strategic pillar for nearly any company aiming to extract value from its data, optimize processes, and offer truly competitive products.
In the field of HR & Workforce Management, for instance, predictive models make it possible to anticipate sudden absences, dynamically calibrate shifts, and, ultimately, save time and resources\u2014precisely the \u201cspeed\/quality\u201d combination we discussed in this article: https:\/\/renor.it\/velocita-e-qualita-nei-progetti\/<\/a>.


But how many of you actually know what artificial intelligence really is? <\/p>\n\n

AI \u2013 The Famed Yet Unknown<\/h2>\n\n

The term Artificial Intelligence refers to the set of techniques that allow a computer system to exhibit abilities normally attributed to human intelligence: reasoning, learning, decision-making, and recognizing complex patterns.
Within this broad field, Machine Learning represents the approach in which learning takes place through statistical analysis of data, without having to manually code every rule.
In recent years, the rise of Deep Learning has pushed evolution even further: very deep neural networks, composed of dozens or even hundreds of processing layers, are able to detect structures in data that traditional models fail to capture. <\/p>\n\n

What are neural networks used for?<\/h2>\n\n

An artificial neural network is a mathematical model inspired by the structure of the neurons in our brain. After all, almost all human discoveries are based on observing what already exists in nature.
The neural structure of the brain allows us to solve problems where the relationship between input (what we perceive from the outside) and output (what we derive from it) is non-linear or difficult to formalize. <\/p>\n\n

Let\u2019s imagine, for example, that we want to predict the likelihood of an employee being late based on variables such as traffic, weather conditions, personal history of delays and absences, and public transportation schedules. The relationship between these factors is far too complex to be described with a few conditional statements\u2014but a well-trained neural network can learn it by analyzing a large amount of historical data. <\/p>\n\n

The reason for this ability lies in the fact that each connection between neurons is associated with a weight and a bias term. We will later understand what these are. <\/p>\n\n

During the training phase, the network adjusts these parameters to minimize a loss function that measures the discrepancy between its prediction and the actual value. This refinement process occurs through the backpropagation algorithm, which computes the gradients, and an optimization method such as stochastic gradient descent, which iteratively updates the weights.
At the end of the process, the network does not contain a set of rules written by the programmer, but rather a collection of numerical coefficients that encode, in a distributed manner, the knowledge extracted from the data. <\/p>\n\n

Now that we have a general overview, we can understand the roles and responsibilities of weights and biases.<\/p>\n\n

The weight is the numerical coefficient that modulates the intensity with which an input signal contributes to the activation of the next neuron. We can think of it like a volume knob: turning it up amplifies the contribution of that specific feature, while turning it down reduces it, even to the point of inverting its effect.
From a mathematical standpoint, the weight multiplies the input value and determines the slope of the function the network is learning; a high weight indicates that the input is strongly correlated with the output, while a weight close to zero makes it practically irrelevant. <\/p>\n\n

The bias, on the other hand, acts as a translator: it is added to the product of input and weight, shifting the overall result up or down before the activation function is applied.
Therefore, if the weights\u2014as we\u2019ve seen\u2014represent the slope of a line, the bias represents the y-intercept, allowing the network to model functions that do not necessarily pass through the origin.
In practice, the bias allows a neuron to activate even when all inputs are zero, introducing that flexibility which makes neural models true function approximators. <\/p>\n\n

During training, weights and biases are updated using the backpropagation algorithm: the gradient of the loss function indicates in which direction and by how much each parameter should be adjusted to reduce the gap between the network\u2019s prediction and the actual value.
Iteration after iteration, the network adjusts these two types of parameters in a coordinated manner, refining both the slope and the position of its decision curves, until it captures the complexity of the phenomenon we aim to model. <\/p>\n\n

In summary, weights and biases are the fundamental building blocks of the network\u2019s adaptive intelligence: the former controls the relative importance of the inputs, while the latter provides the freedom to move within the solution space without predefined geometric constraints.<\/p>\n\n

Why is it worth implementing it in PHP?<\/h2>\n\n

One might wonder whether it makes sense to build a neural network in a language traditionally considered for web backend development. The answer is yes\u2014for certain well-defined scenarios.
First of all, a native implementation avoids introducing an additional runtime\u2014typically Python\u2014thereby simplifying the build, test, and deploy cycle when the entire application stack is already in PHP. Furthermore, for microservices that require lightweight models and inference times in the order of a few milliseconds, a self-contained solution is more than adequate.
There\u2019s also the good old educational aspect, which should not be underestimated: writing the network line by line dismantles the \u201cblack box\u201d aura that surrounds many deep learning frameworks, and puts developers in a position to understand, optimize, and\u2014most importantly\u2014debug every step of the computation. This offers a detailed overview of how a neural network works, leading to a deeper and more comprehensive understanding. <\/p>\n\n

Anatomy of a Minimal Feed-Forward Neural Network in PHP<\/h2>\n\n

To move forward, we need to define the backbone of a \u201cbare-metal\u201d neural network that we can build using only the core PHP engine\u2014without relying on C extensions or external libraries.
In practice, this means modeling, using native data structures, the following three fundamental elements: <\/p>\n\n

    \n
  1. The Layers \u2013 or Processing Elements<\/li>\n\n\n\n
  2. weight matrices<\/li>\n\n\n\n
  3. bias vectors<\/li>\n<\/ol>\n\n

    Each layer will be represented by a simple two-dimensional array of weights ($weights<\/code>) and a one-dimensional array of biases ($biases<\/code>). The transfer of activations from one layer to the next will occur through standard matrix-vector multiplication, followed by the application of an activation function (sigmoid, ReLU, or tanh, depending on the use case).
    This minimalist scheme has the advantage of remaining readable and facilitating step-by-step debugging, but it imposes certain design choices: no automatic parallelization, no SIMD optimizations, and a need for extreme attention to computational complexity, since the unrestrained use of nested foreach loops in PHP can cause inference times to spike. <\/p>\n\n

    Nevertheless, for networks with one or two hidden layers and a number of neurons in the order of hundreds, performance remains surprisingly decent\u2014provided that op-caching is leveraged and redundant memory allocations are avoided.
    In essence, before diving into the actual code, it\u2019s important to understand that in PHP, neurons are nothing more than rows in arrays, and gradients are float values updated within a loop. The simplicity of the implementation makes the arithmetic of the network easy to grasp, making each step of the learning process clearly visible. <\/p>\n\n

    Code Implementation: The Basic Structure of the Neural Network<\/h2>\n\n

    At this point in the article, it\u2019s appropriate to present in detail the bare-metal implementation of a two-layer feed-forward neural network, written entirely in PHP 8.1.
    The following code maintains maximum transparency: every mathematical operation is explicitly expressed using simple for loops, each intermediate variable is stored so it can be inspected during debugging, and the only prerequisites are the PHP engine and opcache enabled in production. <\/p>\n\n

    To make the project easily reusable, I have divided the code into two separate files.
    The first, NeuralNetwork.php, contains all the neural network logic, complete with classes, activation functions, forward-pass, backpropagation, and training routines.
    The second, demo_xor.php, is a simple execution script that imports the class, instantiates the network, trains it on the classic XOR problem, and prints the results to the screen. <\/p>\n\n

    NeuralNetwork.php<\/h3>\n\n
    <\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
    <?php<\/span><\/span>\ndeclare<\/span>(strict_types=<\/span>1<\/span>);<\/span><\/span>\n\n\/**<\/span><\/span>\n * Minimal feed-forward neural network in pure PHP<\/span><\/span>\n * MIT License \u2013 (c) 2025<\/span><\/span>\n *\/<\/span><\/span>\n\n\/* ---------- Activation functions ---------- *\/<\/span><\/span>\n\n\/** Sigmoid activation *\/<\/span><\/span>\nfunction<\/span> <\/span>sigmoid<\/span>(<\/span>float<\/span> <\/span>$x<\/span>): <\/span>float<\/span><\/span>\n{<\/span><\/span>\n    <\/span>return<\/span> <\/span>1.0<\/span> \/ (<\/span>1.0<\/span> + <\/span>exp<\/span>(-<\/span>$x<\/span>));<\/span><\/span>\n}<\/span><\/span>\n\n\/** Derivative of the sigmoid *\/<\/span><\/span>\nfunction<\/span> <\/span>sigmoid_derivative<\/span>(<\/span>float<\/span> <\/span>$x<\/span>): <\/span>float<\/span><\/span>\n{<\/span><\/span>\n    <\/span>$s<\/span> = <\/span>sigmoid<\/span>(<\/span>$x<\/span>);<\/span><\/span>\n    <\/span>return<\/span> <\/span>$s<\/span> * (<\/span>1<\/span> - <\/span>$s<\/span>);<\/span><\/span>\n}<\/span><\/span>\n\n\/** ReLU activation *\/<\/span><\/span>\nfunction<\/span> <\/span>relu<\/span>(<\/span>float<\/span> <\/span>$x<\/span>): <\/span>float<\/span><\/span>\n{<\/span><\/span>\n    <\/span>return<\/span> <\/span>max<\/span>(<\/span>0.0<\/span>, <\/span>$x<\/span>);<\/span><\/span>\n}<\/span><\/span>\n\n\/** Derivative of ReLU *\/<\/span><\/span>\nfunction<\/span> <\/span>relu_derivative<\/span>(<\/span>float<\/span> <\/span>$x<\/span>): <\/span>float<\/span><\/span>\n{<\/span><\/span>\n    <\/span>return<\/span> <\/span>$x<\/span> > <\/span>0<\/span> ? <\/span>1.0<\/span> : <\/span>0.0<\/span>;<\/span><\/span>\n}<\/span><\/span>\n\n\/* ---------- Layer class ---------- *\/<\/span><\/span>\n\nfinal<\/span> <\/span>class<\/span> <\/span>Layer<\/span><\/span>\n{<\/span><\/span>\n    <\/span>public<\/span> <\/span>readonly<\/span> <\/span>int<\/span> <\/span>$in<\/span>;   <\/span>\/\/ number of input neurons<\/span><\/span>\n    <\/span>public<\/span> <\/span>readonly<\/span> <\/span>int<\/span> <\/span>$out<\/span>;  <\/span>\/\/ number of output neurons<\/span><\/span>\n\n    <\/span>\/** <\/span>@var<\/span> <\/span>float[]<\/span>[] weight matrix [out][in] *\/<\/span><\/span>\n    <\/span>public<\/span> <\/span>array<\/span> <\/span>$W<\/span> = [];<\/span><\/span>\n\n    <\/span>\/** <\/span>@var<\/span> <\/span>float[]<\/span> bias vector [out] *\/<\/span><\/span>\n    <\/span>public<\/span> <\/span>array<\/span> <\/span>$b<\/span> = [];<\/span><\/span>\n\n    <\/span>private<\/span> <\/span>array<\/span> <\/span>$lastInput<\/span>  = [];<\/span><\/span>\n    <\/span>private<\/span> <\/span>array<\/span> <\/span>$lastZ<\/span>      = [];<\/span><\/span>\n    <\/span>private<\/span> <\/span>array<\/span> <\/span>$lastOutput<\/span> = [];<\/span><\/span>\n\n    <\/span>public<\/span> <\/span>function<\/span> <\/span>__construct<\/span>(<\/span><\/span>\n        <\/span>int<\/span>      <\/span>$in<\/span>,<\/span><\/span>\n        <\/span>int<\/span>      <\/span>$out<\/span>,<\/span><\/span>\n        <\/span>callable<\/span> <\/span>$act<\/span>,<\/span><\/span>\n        <\/span>callable<\/span> <\/span>$actDer<\/span><\/span>\n    ) {<\/span><\/span>\n        <\/span>$this<\/span>-><\/span>in<\/span>           = <\/span>$in<\/span>;<\/span><\/span>\n        <\/span>$this<\/span>-><\/span>out<\/span>          = <\/span>$out<\/span>;<\/span><\/span>\n        <\/span>$this<\/span>-><\/span>activation<\/span>   = <\/span>$act<\/span>;<\/span><\/span>\n        <\/span>$this<\/span>-><\/span>activation_d<\/span> = <\/span>$actDer<\/span>;<\/span><\/span>\n\n        <\/span>\/\/ Xavier\/Glorot uniform initialization<\/span><\/span>\n        <\/span>$limit<\/span> = <\/span>sqrt<\/span>(<\/span>6<\/span> \/ (<\/span>$in<\/span> + <\/span>$out<\/span>));<\/span><\/span>\n        <\/span>for<\/span> (<\/span>$i<\/span> = <\/span>0<\/span>; <\/span>$i<\/span> < <\/span>$out<\/span>; <\/span>$i<\/span>++) {<\/span><\/span>\n            <\/span>$this<\/span>-><\/span>b<\/span>[<\/span>$i<\/span>] = <\/span>0.0<\/span>;<\/span><\/span>\n            <\/span>for<\/span> (<\/span>$j<\/span> = <\/span>0<\/span>; <\/span>$j<\/span> < <\/span>$in<\/span>; <\/span>$j<\/span>++) {<\/span><\/span>\n                <\/span>$this<\/span>-><\/span>W<\/span>[<\/span>$i<\/span>][<\/span>$j<\/span>] = (<\/span>mt_rand<\/span>() \/ <\/span>mt_getrandmax<\/span>()) * <\/span>2<\/span> * <\/span>$limit<\/span> - <\/span>$limit<\/span>;<\/span><\/span>\n            }<\/span><\/span>\n        }<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>\/** Forward propagation *\/<\/span><\/span>\n    <\/span>public<\/span> <\/span>function<\/span> <\/span>forward<\/span>(<\/span>array<\/span> <\/span>$input<\/span>): <\/span>array<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>$this<\/span>-><\/span>lastInput<\/span> = <\/span>$input<\/span>;<\/span><\/span>\n        <\/span>$this<\/span>-><\/span>lastZ<\/span>     = [];<\/span><\/span>\n        <\/span>$this<\/span>-><\/span>lastOutput<\/span> = [];<\/span><\/span>\n\n        <\/span>for<\/span> (<\/span>$i<\/span> = <\/span>0<\/span>; <\/span>$i<\/span> < <\/span>$this<\/span>-><\/span>out<\/span>; <\/span>$i<\/span>++) {<\/span><\/span>\n            <\/span>$z<\/span> = <\/span>$this<\/span>-><\/span>b<\/span>[<\/span>$i<\/span>];<\/span><\/span>\n            <\/span>for<\/span> (<\/span>$j<\/span> = <\/span>0<\/span>; <\/span>$j<\/span> < <\/span>$this<\/span>-><\/span>in<\/span>; <\/span>$j<\/span>++) {<\/span><\/span>\n                <\/span>$z<\/span> += <\/span>$this<\/span>-><\/span>W<\/span>[<\/span>$i<\/span>][<\/span>$j<\/span>] * <\/span>$input<\/span>[<\/span>$j<\/span>];<\/span><\/span>\n            }<\/span><\/span>\n            <\/span>$this<\/span>-><\/span>lastZ<\/span>[<\/span>$i<\/span>]      = <\/span>$z<\/span>;<\/span><\/span>\n            <\/span>$this<\/span>-><\/span>lastOutput<\/span>[<\/span>$i<\/span>] = (<\/span>$this<\/span>-><\/span>activation<\/span>)(<\/span>$z<\/span>);<\/span><\/span>\n        }<\/span><\/span>\n        <\/span>return<\/span> <\/span>$this<\/span>-><\/span>lastOutput<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>\/** Back-propagation, returns gradient for previous layer *\/<\/span><\/span>\n    <\/span>public<\/span> <\/span>function<\/span> <\/span>backward<\/span>(<\/span>array<\/span> <\/span>$gradOutput<\/span>, <\/span>float<\/span> <\/span>$lr<\/span>): <\/span>array<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>$gradInput<\/span> = <\/span>array_fill<\/span>(<\/span>0<\/span>, <\/span>$this<\/span>-><\/span>in<\/span>, <\/span>0.0<\/span>);<\/span><\/span>\n\n        <\/span>for<\/span> (<\/span>$i<\/span> = <\/span>0<\/span>; <\/span>$i<\/span> < <\/span>$this<\/span>-><\/span>out<\/span>; <\/span>$i<\/span>++) {<\/span><\/span>\n            <\/span>$delta<\/span> = <\/span>$gradOutput<\/span>[<\/span>$i<\/span>] * (<\/span>$this<\/span>-><\/span>activation_d<\/span>)(<\/span>$this<\/span>-><\/span>lastZ<\/span>[<\/span>$i<\/span>]);<\/span><\/span>\n\n            <\/span>\/\/ Propagate gradient and update weights<\/span><\/span>\n            <\/span>for<\/span> (<\/span>$j<\/span> = <\/span>0<\/span>; <\/span>$j<\/span> < <\/span>$this<\/span>-><\/span>in<\/span>; <\/span>$j<\/span>++) {<\/span><\/span>\n                <\/span>$gradInput<\/span>[<\/span>$j<\/span>] += <\/span>$delta<\/span> * <\/span>$this<\/span>-><\/span>W<\/span>[<\/span>$i<\/span>][<\/span>$j<\/span>];<\/span><\/span>\n                <\/span>$this<\/span>-><\/span>W<\/span>[<\/span>$i<\/span>][<\/span>$j<\/span>] -= <\/span>$lr<\/span> * <\/span>$delta<\/span> * <\/span>$this<\/span>-><\/span>lastInput<\/span>[<\/span>$j<\/span>];<\/span><\/span>\n            }<\/span><\/span>\n            <\/span>\/\/ Update bias<\/span><\/span>\n            <\/span>$this<\/span>-><\/span>b<\/span>[<\/span>$i<\/span>] -= <\/span>$lr<\/span> * <\/span>$delta<\/span>;<\/span><\/span>\n        }<\/span><\/span>\n        <\/span>return<\/span> <\/span>$gradInput<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>\/* callable *\/<\/span> <\/span>private<\/span> <\/span>$activation<\/span>;<\/span><\/span>\n    <\/span>\/* callable *\/<\/span> <\/span>private<\/span> <\/span>$activation_d<\/span>;<\/span><\/span>\n}<\/span><\/span>\n\n\/* ---------- NeuralNetwork class ---------- *\/<\/span><\/span>\n\nfinal<\/span> <\/span>class<\/span> <\/span>NeuralNetwork<\/span><\/span>\n{<\/span><\/span>\n    <\/span>\/** <\/span>@var<\/span> <\/span>Layer<\/span>[]<\/span> *\/<\/span><\/span>\n    <\/span>private<\/span> <\/span>array<\/span> <\/span>$layers<\/span> = [];<\/span><\/span>\n\n    <\/span>\/** Add a layer to the network *\/<\/span><\/span>\n    <\/span>public<\/span> <\/span>function<\/span> <\/span>addLayer<\/span>(<\/span>Layer<\/span> <\/span>$layer<\/span>): <\/span>void<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>$this<\/span>-><\/span>layers<\/span>[] = <\/span>$layer<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>\/** Forward pass through all layers *\/<\/span><\/span>\n    <\/span>public<\/span> <\/span>function<\/span> <\/span>predict<\/span>(<\/span>array<\/span> <\/span>$x<\/span>): <\/span>array<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>$out<\/span> = <\/span>$x<\/span>;<\/span><\/span>\n        <\/span>foreach<\/span> (<\/span>$this<\/span>-><\/span>layers<\/span> as <\/span>$layer<\/span>) {<\/span><\/span>\n            <\/span>$out<\/span> = <\/span>$layer<\/span>-><\/span>forward<\/span>(<\/span>$out<\/span>);<\/span><\/span>\n        }<\/span><\/span>\n        <\/span>return<\/span> <\/span>$out<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>\/**<\/span><\/span>\n     * Train the network with SGD and mean squared error<\/span><\/span>\n     * <\/span>@param<\/span> <\/span>float[]<\/span>[] $xTrain<\/span><\/span>\n     * <\/span>@param<\/span> <\/span>float[]<\/span>[] $yTrain<\/span><\/span>\n     *\/<\/span><\/span>\n    <\/span>public<\/span> <\/span>function<\/span> <\/span>train<\/span>(<\/span><\/span>\n        <\/span>array<\/span> <\/span>$xTrain<\/span>,<\/span><\/span>\n        <\/span>array<\/span> <\/span>$yTrain<\/span>,<\/span><\/span>\n        <\/span>int<\/span>   <\/span>$epochs<\/span>     = <\/span>1000<\/span>,<\/span><\/span>\n        <\/span>float<\/span> <\/span>$lr<\/span>         = <\/span>0.1<\/span>,<\/span><\/span>\n        <\/span>bool<\/span>  <\/span>$verbose<\/span>    = <\/span>true<\/span>,<\/span><\/span>\n        <\/span>int<\/span>   <\/span>$logStride<\/span>  = <\/span>100<\/span><\/span>\n    ): <\/span>void<\/span> {<\/span><\/span>\n        <\/span>$n<\/span> = <\/span>count<\/span>(<\/span>$xTrain<\/span>);<\/span><\/span>\n\n        <\/span>for<\/span> (<\/span>$e<\/span> = <\/span>1<\/span>; <\/span>$e<\/span> <= <\/span>$epochs<\/span>; <\/span>$e<\/span>++) {<\/span><\/span>\n            <\/span>$loss<\/span> = <\/span>0.0<\/span>;<\/span><\/span>\n\n            <\/span>for<\/span> (<\/span>$k<\/span> = <\/span>0<\/span>; <\/span>$k<\/span> < <\/span>$n<\/span>; <\/span>$k<\/span>++) {<\/span><\/span>\n                <\/span>$out<\/span>   = <\/span>$this<\/span>-><\/span>predict<\/span>(<\/span>$xTrain<\/span>[<\/span>$k<\/span>]);<\/span><\/span>\n\n                <\/span>\/\/ MSE derivative: 2*(\u0177 - y)<\/span><\/span>\n                <\/span>$grad<\/span>  = [];<\/span><\/span>\n                <\/span>foreach<\/span> (<\/span>$out<\/span> as <\/span>$i<\/span> => <\/span>$o<\/span>) {<\/span><\/span>\n                    <\/span>$diff<\/span>      = <\/span>$o<\/span> - <\/span>$yTrain<\/span>[<\/span>$k<\/span>][<\/span>$i<\/span>];<\/span><\/span>\n                    <\/span>$grad<\/span>[<\/span>$i<\/span>]  = <\/span>2<\/span> * <\/span>$diff<\/span>;<\/span><\/span>\n                    <\/span>$loss<\/span>     += <\/span>$diff<\/span> ** <\/span>2<\/span>;<\/span><\/span>\n                }<\/span><\/span>\n\n                <\/span>\/\/ Backward pass<\/span><\/span>\n                <\/span>for<\/span> (<\/span>$l<\/span> = <\/span>count<\/span>(<\/span>$this<\/span>-><\/span>layers<\/span>) - <\/span>1<\/span>; <\/span>$l<\/span> >= <\/span>0<\/span>; <\/span>$l<\/span>--) {<\/span><\/span>\n                    <\/span>$grad<\/span> = <\/span>$this<\/span>-><\/span>layers<\/span>[<\/span>$l<\/span>]-><\/span>backward<\/span>(<\/span>$grad<\/span>, <\/span>$lr<\/span>);<\/span><\/span>\n                }<\/span><\/span>\n            }<\/span><\/span>\n\n            <\/span>if<\/span> (<\/span>$verbose<\/span> && <\/span>$e<\/span> % <\/span>$logStride<\/span> === <\/span>0<\/span>) {<\/span><\/span>\n                <\/span>printf<\/span>(<\/span>\"Epoch %d\/%d - loss: %.6f<\/span>\\n<\/span>\"<\/span>, <\/span>$e<\/span>, <\/span>$epochs<\/span>, <\/span>$loss<\/span> \/ <\/span>$n<\/span>);<\/span><\/span>\n            }<\/span><\/span>\n        }<\/span><\/span>\n    }<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n
    In this file, we find the activation functions\u2014sigmoid and ReLU\u2014along with their respective gradients. Keeping them at the global scope, rather than encapsulated within the class, reduces the overhead of method calls and allows them to be passed as callables directly to the layer constructor, maintaining flexibility without sacrificing performance.  <\/p>\n\n
    The Layer class is declared as final to prevent unwanted extensions and represents the logical unit of computation. It contains the in and out integers marked as readonly, ensuring their integrity throughout the object\u2019s entire lifecycle.
    The weight matrix and bias vector are initialized using the Xavier initialization technique, which distributes values over an interval proportional to the square root of the total number of input and output connections.
    This mathematical strategy prevents the activations from saturating during the initial epochs\u2014a phenomenon that would otherwise compromise the learning process.   <\/p>\n\n
    \"w_{ij} \sim \mathcal U\!\Bigl(-\sqrt{\tfrac{6}{n_{\text{in}} + n_{\text{out}}}},\, \sqrt{\tfrac{6}{n_{\text{in}} + n_{\text{out}}}}\Bigr)\"<\/p>\n\n

    where \"\mathcal{U}(a, b)\" denotes the continuous uniform distribution between a and b; the term under the square root, \"\sqrt{6 / (n_{\text{in}} + n_{\text{out}})}\", serves as the upper and lower bound of the sampling interval.
    Alternatively, one could use a Gaussian distribution with zero mean and variance \"\sigma^{2}= 2 / (n_{\text{in}} + n_{\text{out}})\", but the expression above\u2014used in the code example\u2014is the original uniform form proposed by Glorot and Bengio. <\/p>\n\n
    During forward propagation, each neuron sums the dot product and bias, then applies the chosen activation function. The intermediate results\u2014lastInput, lastZ, and lastOutput\u2014are stored for reuse during backpropagation, allowing the gradient computation to proceed without recalculating anything. This design is ideal for step-by-step debugging.


    The backward method receives the error gradient from the next layer, combines it with the local derivative of the activation function, and updates weights and biases by subtracting a fraction proportional to the learning rate. At the same time, it returns the gradient to be propagated backward to the previous layer.  <\/p>\n\n
    The inner loop is entirely manual\u2014a deliberate choice that highlights the underlying mathematics and makes the code perfectly transparent, even to those who have never used specialized libraries. <\/p>\n\n
    The NeuralNetwork class\u2014also declared as final\u2014acts as the orchestrator: it maintains the array of layers and provides the predict method, which channels an input vector through each layer.


    The train method implements stochastic gradient descent with mean squared error. It iterates over the training set for a specified number of epochs, computes for each example the difference between the predicted and actual output, doubles the value, and propagates the gradient backward, updating the layers in reverse order.


    At each iteration, it accumulates the loss to provide a global indicator which\u2014if the verbose flag is enabled\u2014is printed at regular intervals, allowing real-time monitoring of the model\u2019s convergence.   <\/p>\n\n
    The layer constructor accepts callables, so if in the future you wish to use different activation functions, you can simply pass their references without altering the architecture. <\/p>\n\n
    <\/p>\n\n
    demo_xor.php<\/h3>\n\n
    <\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
    <?php<\/span><\/span>\ndeclare<\/span>(strict_types=<\/span>1<\/span>);<\/span><\/span>\n\n\/\/ Include the neural network implementation<\/span><\/span>\nrequire_once<\/span> <\/span>__DIR__<\/span> <\/span>.<\/span> <\/span>'\/NeuralNetwork.php'<\/span>;<\/span><\/span>\n\n\/\/ Training data for XOR<\/span><\/span>\n$xTrain<\/span> = [<\/span><\/span>\n    [<\/span>0<\/span>, <\/span>0<\/span>],<\/span><\/span>\n    [<\/span>0<\/span>, <\/span>1<\/span>],<\/span><\/span>\n    [<\/span>1<\/span>, <\/span>0<\/span>],<\/span><\/span>\n    [<\/span>1<\/span>, <\/span>1<\/span>],<\/span><\/span>\n];<\/span><\/span>\n$yTrain<\/span> = [<\/span><\/span>\n    [<\/span>0<\/span>],<\/span><\/span>\n    [<\/span>1<\/span>],<\/span><\/span>\n    [<\/span>1<\/span>],<\/span><\/span>\n    [<\/span>0<\/span>],<\/span><\/span>\n];<\/span><\/span>\n\n\/\/ Build the network: 2-3-1 with sigmoid activations<\/span><\/span>\n$net<\/span> = <\/span>new<\/span> <\/span>NeuralNetwork<\/span>();<\/span><\/span>\n$net<\/span>-><\/span>addLayer<\/span>(<\/span>new<\/span> <\/span>Layer<\/span>(<\/span>2<\/span>, <\/span>3<\/span>, <\/span>'sigmoid'<\/span>, <\/span>'sigmoid_derivative'<\/span>));<\/span><\/span>\n$net<\/span>-><\/span>addLayer<\/span>(<\/span>new<\/span> <\/span>Layer<\/span>(<\/span>3<\/span>, <\/span>1<\/span>, <\/span>'sigmoid'<\/span>, <\/span>'sigmoid_derivative'<\/span>));<\/span><\/span>\n\n\/\/ Train the network<\/span><\/span>\n$net<\/span>-><\/span>train<\/span>(<\/span>$xTrain<\/span>, <\/span>$yTrain<\/span>, <\/span>epochs<\/span>: <\/span>5000<\/span>, <\/span>lr<\/span>: <\/span>0.5<\/span>, <\/span>logStride<\/span>: <\/span>500<\/span>);<\/span><\/span>\n\n\/\/ Test predictions<\/span><\/span>\nforeach<\/span> (<\/span>$xTrain<\/span> as <\/span>$sample<\/span>) {<\/span><\/span>\n    <\/span>$out<\/span> = <\/span>$net<\/span>-><\/span>predict<\/span>(<\/span>$sample<\/span>)[<\/span>0<\/span>];<\/span><\/span>\n    <\/span>printf<\/span>(<\/span>\"Input %s \u21d2 Output %.4f<\/span>\\n<\/span>\"<\/span>, <\/span>json_encode<\/span>(<\/span>$sample<\/span>), <\/span>$out<\/span>);<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n
    In this functional snippet, the training dataset and the corresponding ground truth for the classic XOR problem are declared: four pairs of binary inputs, each paired with its expected output. This setup allows us to test the model\u2019s ability to learn a non-linear function.<\/p>\n\n
    The core logic begins with the instantiation of the NeuralNetwork object. A two-layer topology is then constructed: the first layer accepts the two input features and projects them onto three output neurons; the second layer receives those three intermediate activations and returns a single scalar value.
    In both layers, the sigmoid activation function is used\u2014chosen for its didactic simplicity and for the ease with which its gradient is computed during the backpropagation phase.   <\/p>\n\n
    Here is the sigmoid function, along with its derivative\u2014commonly used in neural networks for both activation and backpropagation:<\/p>\n\n
    \"\sigma(x)=\frac{1}{1+\mathrm e^{-x}}\"<\/p>\n\n

    where\" \mathrm{e}\" is Euler\u2019s number (the base of natural logarithms), and \"x\" represents the real-valued input to the neuron.
    This expression guarantees a continuous output between 0 and 1, with an inflection point at the origin that defines its characteristic \u201cS\u201d shape: for very large negative values, the function tends asymptotically toward 0, while for very large positive values, it approaches 1.


    In the context of machine learning, the derivative of the sigmoid is often used during backpropagation. Its compact form is:   <\/p>\n\n
    \"\sigma'(x)=\sigma(x)\,\bigl(1-\sigma(x)\bigr)\"<\/p>\n\n

    This latter relationship derives directly from the original definition and allows the gradient to be computed without the need for additional exponential functions, thus optimizing the weight update phase.<\/p>\n\n
    Continuing on, the train method initiates the actual training process, iterating over the same small dataset for five thousand epochs. With a learning rate set to 0.5 and a loss log printed every 500 iterations, the loop performs gradient descent on the mean squared error, updating the weights and biases of both layers at each observation.


    At the end of training, a simple foreach loop iterates once more over the four input patterns, feeds them to the predict method, and prints the network\u2019s numerical outputs to the screen\u2014allowing for immediate comparison with the expected outputs and a quick evaluation of the model\u2019s accuracy.


    In a production context, this same logic could easily be encapsulated in a REST endpoint or a command-line script, but in this minimalist form it already provides a complete demonstration of how PHP can manage the entire lifecycle of a small neural network\u2014from layer definition to final prediction.    <\/p>\n\n
    Conclusions<\/h2>\n\n
    The experiment demonstrates that, although PHP wasn\u2019t designed for numerical computing, it is possible to implement a basic yet functional neural network, train it in reasonable time on small-scale problems, and deploy it in production without introducing an additional runtime. <\/p>\n\n
    Xavier initialization preserves signal stability from the very first epochs, the sigmoid ensures a well-defined gradient, and the fully transparent, non\u2013black-box approach makes the model an excellent didactic tool: every weight, every bias, and every step of backpropagation is under full control.
    It\u2019s clear that this solution is not meant to compete with GPU-optimized frameworks\u2014but when the goal is to integrate lightweight inference into an already PHP-based stack, or simply to gain a deep, hands-on understanding of how a neural network works, the presented implementation offers an elegant and accessible path.  <\/p>\n\n
    In conclusion, the most interesting aspect of this article was not to build a new ChatGPT, but rather to foster awareness and learn the mathematical principles behind the construction of a simple neural network\u2014line by line. <\/p>\n\n
    In my opinion, the true power of artificial intelligence lies in understanding the scientific principles on which it is based, rather than in the specific programming languages we use to implement it. <\/p>\n\n
    [starbox]<\/p>\n","protected":false},"excerpt":{"rendered":"
    I\u2019ll begin this article with a premise\u2026 PHP is certainly not the ideal language when it comes to artificial intelligence. Neural networks are typically the domain of more scientific languages like Python, which offers optimized libraries for this purpose such as PyTorch and NumPy\u2014and that\u2019s usually the language I rely on when working in this […]<\/p>\n","protected":false},"author":2,"featured_media":507,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"_writerflow_disable_suggestions":false,"footnotes":""},"categories":[1976],"tags":[1383,1348,1384,1385,1386,1387,1388,1389,1390,1357,1391,1392,1393,1394,1395],"class_list":["post-659","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-intelligenza-artificiale-algoritmi","tag-ai-in-php-en","tag-artificial-intelligence","tag-back-propagation-en","tag-backend-programming","tag-deep-learning-en","tag-feed-forward-network","tag-machine-learning-en","tag-microservices","tag-model-serialization","tag-neural-networks","tag-php-en","tag-rest-api-en","tag-sigmoid-function","tag-xavier-initialization","tag-xor-example"],"acf":[],"yoast_head":"\nNeural Networks in PHP? Yes, It Can Be Done! | RENOR & Partners S.r.l.<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/renor.it\/en\/blog\/intelligenza-artificiale-algoritmi\/neural-networks-in-php-yes-it-can-be-done\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Neural Networks in PHP? Yes, It Can Be Done!\" \/>\n<meta property=\"og:description\" content=\"I\u2019ll begin this article with a premise\u2026 PHP is certainly not the ideal language when it comes to artificial intelligence. Neural networks are typically the domain of more scientific languages like Python, which offers optimized libraries for this purpose such as PyTorch and NumPy\u2014and that\u2019s usually the language I rely on when working in this […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/renor.it\/en\/blog\/intelligenza-artificiale-algoritmi\/neural-networks-in-php-yes-it-can-be-done\/\" \/>\n<meta property=\"og:site_name\" content=\"RENOR & Partners S.r.l.\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/renorsrl\" \/>\n<meta property=\"article:author\" content=\"https:\/\/www.facebook.com\/simone.renzi.3954\/\" \/>\n<meta property=\"article:published_time\" content=\"2025-05-18T10:23:19+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-12-20T14:53:59+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/renor.it\/wp-content\/uploads\/2025\/05\/neural-network.webp\" \/>\n\t<meta property=\"og:image:width\" content=\"1536\" \/>\n\t<meta property=\"og:image:height\" content=\"1024\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/webp\" \/>\n<meta name=\"author\" content=\"Simone Renzi\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Simone Renzi\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"16 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/intelligenza-artificiale-algoritmi\\\/neural-networks-in-php-yes-it-can-be-done\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/intelligenza-artificiale-algoritmi\\\/neural-networks-in-php-yes-it-can-be-done\\\/\"},\"author\":{\"name\":\"Simone Renzi\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#\\\/schema\\\/person\\\/21343be04e5983a87f3a9a6182cf8795\"},\"headline\":\"Neural Networks in PHP? Yes, It Can Be Done!\",\"datePublished\":\"2025-05-18T10:23:19+00:00\",\"dateModified\":\"2025-12-20T14:53:59+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/intelligenza-artificiale-algoritmi\\\/neural-networks-in-php-yes-it-can-be-done\\\/\"},\"wordCount\":2643,\"publisher\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/intelligenza-artificiale-algoritmi\\\/neural-networks-in-php-yes-it-can-be-done\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/renor.it\\\/wp-content\\\/uploads\\\/2025\\\/05\\\/neural-network.webp\",\"keywords\":[\"AI in PHP\",\"artificial intelligence\",\"back-propagation\",\"backend programming\",\"Deep Learning\",\"feed-forward network\",\"Machine Learning\",\"microservices\",\"model serialization\",\"neural networks\",\"php\",\"REST API\",\"sigmoid function\",\"Xavier initialization\",\"XOR example\"],\"articleSection\":[\"Intelligenza Artificiale & Algoritmi\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/intelligenza-artificiale-algoritmi\\\/neural-networks-in-php-yes-it-can-be-done\\\/\",\"url\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/intelligenza-artificiale-algoritmi\\\/neural-networks-in-php-yes-it-can-be-done\\\/\",\"name\":\"Neural Networks in PHP? Yes, It Can Be Done! | RENOR & Partners S.r.l.\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/intelligenza-artificiale-algoritmi\\\/neural-networks-in-php-yes-it-can-be-done\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/intelligenza-artificiale-algoritmi\\\/neural-networks-in-php-yes-it-can-be-done\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/renor.it\\\/wp-content\\\/uploads\\\/2025\\\/05\\\/neural-network.webp\",\"datePublished\":\"2025-05-18T10:23:19+00:00\",\"dateModified\":\"2025-12-20T14:53:59+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/intelligenza-artificiale-algoritmi\\\/neural-networks-in-php-yes-it-can-be-done\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/intelligenza-artificiale-algoritmi\\\/neural-networks-in-php-yes-it-can-be-done\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/intelligenza-artificiale-algoritmi\\\/neural-networks-in-php-yes-it-can-be-done\\\/#primaryimage\",\"url\":\"https:\\\/\\\/renor.it\\\/wp-content\\\/uploads\\\/2025\\\/05\\\/neural-network.webp\",\"contentUrl\":\"https:\\\/\\\/renor.it\\\/wp-content\\\/uploads\\\/2025\\\/05\\\/neural-network.webp\",\"width\":1536,\"height\":1024,\"caption\":\"Una trama di neuroni luminescenti si intreccia su uno sfondo di snippet del linguaggio PHP, mentre il logo campeggia al centro a indicare l\u2019inusuale connubio fra programmazione web e reti neurali.\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/intelligenza-artificiale-algoritmi\\\/neural-networks-in-php-yes-it-can-be-done\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/renor.it\\\/en\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Blog\",\"item\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Artificial Intelligence & Algorithms\",\"item\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/artificial-intelligence-algorithms\\\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Neural Networks in PHP? Yes, It Can Be Done!\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#website\",\"url\":\"https:\\\/\\\/renor.it\\\/en\\\/\",\"name\":\"RENOR & Partners S.r.l.\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#organization\"},\"alternateName\":\"RENOR & Partners S.r.l.\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/renor.it\\\/en\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#organization\",\"name\":\"RENOR & Partners S.r.l.\",\"url\":\"https:\\\/\\\/renor.it\\\/en\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/renor.it\\\/wp-content\\\/uploads\\\/2025\\\/12\\\/logo-new-1.webp\",\"contentUrl\":\"https:\\\/\\\/renor.it\\\/wp-content\\\/uploads\\\/2025\\\/12\\\/logo-new-1.webp\",\"width\":432,\"height\":146,\"caption\":\"RENOR & Partners S.r.l.\"},\"image\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/renorsrl\",\"https:\\\/\\\/www.instagram.com\\\/renorpartners\\\/\",\"https:\\\/\\\/www.linkedin.com\\\/company\\\/renor-partners\\\/posts\\\/?feedView=all\"],\"description\":\"RENOR & Partners Srl \u00e8 una societ\u00e0 di consulenza tecnologica e ingegneristica specializzata in sviluppo software, cloud computing, integrazione di sistemi, intelligenza artificiale applicata e progettazione elettronica. L\u2019azienda supporta imprese e pubbliche amministrazioni nella realizzazione di soluzioni digitali affidabili, scalabili e orientate all\u2019efficienza, con un approccio pragmatico basato su competenze tecniche, progettazione su misura e innovazione concreta.\",\"email\":\"info@renor.it\",\"telephone\":\"3791489430\",\"legalName\":\"RENOR AND PARTNERS S.r.l.\",\"foundingDate\":\"2022-06-21\",\"vatID\":\"16768411007\",\"taxID\":\"16768411007\",\"numberOfEmployees\":{\"@type\":\"QuantitativeValue\",\"minValue\":\"1\",\"maxValue\":\"10\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#\\\/schema\\\/person\\\/21343be04e5983a87f3a9a6182cf8795\",\"name\":\"Simone Renzi\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/54f81b51be6bda6d63a06a1cd6563d9b0d5778d7af4f0bda4e246fc3e5737e2e?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/54f81b51be6bda6d63a06a1cd6563d9b0d5778d7af4f0bda4e246fc3e5737e2e?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/54f81b51be6bda6d63a06a1cd6563d9b0d5778d7af4f0bda4e246fc3e5737e2e?s=96&d=mm&r=g\",\"caption\":\"Simone Renzi\"},\"description\":\"Senior full-stack web engineer with over 20 years of experience in cloud architectures, AI, and SaaS solutions; member of Mensa Italia. Creator of platforms such as HR24.ai and Paghe.ai, he oversaw the web development of FNS, a neural network simulator cited in Scientific Reports (Nature Portfolio), and has collaborated on research projects with INFN \u2013 Laboratori Nazionali di Frascati, Universit\u00e0 di Roma \u201cTor Vergata\u201d, Universidad Complutense, Universidad Polit\u00e9cnica and Centro de Tecnolog\u00eda Biom\u00e9dica in Madrid. A classical pianist, he combines musical creativity and technological rigor in every project.\",\"sameAs\":[\"https:\\\/\\\/renor.it\",\"https:\\\/\\\/www.facebook.com\\\/simone.renzi.3954\\\/\",\"https:\\\/\\\/www.linkedin.com\\\/in\\\/simone-renzi\"],\"url\":\"https:\\\/\\\/renor.it\\\/en\\\/author\\\/thesimon\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Neural Networks in PHP? Yes, It Can Be Done! | RENOR & Partners S.r.l.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/renor.it\/en\/blog\/intelligenza-artificiale-algoritmi\/neural-networks-in-php-yes-it-can-be-done\/","og_locale":"en_US","og_type":"article","og_title":"Neural Networks in PHP? Yes, It Can Be Done!","og_description":"I\u2019ll begin this article with a premise\u2026 PHP is certainly not the ideal language when it comes to artificial intelligence. Neural networks are typically the domain of more scientific languages like Python, which offers optimized libraries for this purpose such as PyTorch and NumPy\u2014and that\u2019s usually the language I rely on when working in this […]","og_url":"https:\/\/renor.it\/en\/blog\/intelligenza-artificiale-algoritmi\/neural-networks-in-php-yes-it-can-be-done\/","og_site_name":"RENOR & Partners S.r.l.","article_publisher":"https:\/\/www.facebook.com\/renorsrl","article_author":"https:\/\/www.facebook.com\/simone.renzi.3954\/","article_published_time":"2025-05-18T10:23:19+00:00","article_modified_time":"2025-12-20T14:53:59+00:00","og_image":[{"width":1536,"height":1024,"url":"https:\/\/renor.it\/wp-content\/uploads\/2025\/05\/neural-network.webp","type":"image\/webp"}],"author":"Simone Renzi","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Simone Renzi","Est. reading time":"16 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/renor.it\/en\/blog\/intelligenza-artificiale-algoritmi\/neural-networks-in-php-yes-it-can-be-done\/#article","isPartOf":{"@id":"https:\/\/renor.it\/en\/blog\/intelligenza-artificiale-algoritmi\/neural-networks-in-php-yes-it-can-be-done\/"},"author":{"name":"Simone Renzi","@id":"https:\/\/renor.it\/en\/#\/schema\/person\/21343be04e5983a87f3a9a6182cf8795"},"headline":"Neural Networks in PHP? Yes, It Can Be Done!","datePublished":"2025-05-18T10:23:19+00:00","dateModified":"2025-12-20T14:53:59+00:00","mainEntityOfPage":{"@id":"https:\/\/renor.it\/en\/blog\/intelligenza-artificiale-algoritmi\/neural-networks-in-php-yes-it-can-be-done\/"},"wordCount":2643,"publisher":{"@id":"https:\/\/renor.it\/en\/#organization"},"image":{"@id":"https:\/\/renor.it\/en\/blog\/intelligenza-artificiale-algoritmi\/neural-networks-in-php-yes-it-can-be-done\/#primaryimage"},"thumbnailUrl":"https:\/\/renor.it\/wp-content\/uploads\/2025\/05\/neural-network.webp","keywords":["AI in PHP","artificial intelligence","back-propagation","backend programming","Deep Learning","feed-forward network","Machine Learning","microservices","model serialization","neural networks","php","REST API","sigmoid function","Xavier initialization","XOR example"],"articleSection":["Intelligenza Artificiale & Algoritmi"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/renor.it\/en\/blog\/intelligenza-artificiale-algoritmi\/neural-networks-in-php-yes-it-can-be-done\/","url":"https:\/\/renor.it\/en\/blog\/intelligenza-artificiale-algoritmi\/neural-networks-in-php-yes-it-can-be-done\/","name":"Neural Networks in PHP? Yes, It Can Be Done! | RENOR & Partners S.r.l.","isPartOf":{"@id":"https:\/\/renor.it\/en\/#website"},"primaryImageOfPage":{"@id":"https:\/\/renor.it\/en\/blog\/intelligenza-artificiale-algoritmi\/neural-networks-in-php-yes-it-can-be-done\/#primaryimage"},"image":{"@id":"https:\/\/renor.it\/en\/blog\/intelligenza-artificiale-algoritmi\/neural-networks-in-php-yes-it-can-be-done\/#primaryimage"},"thumbnailUrl":"https:\/\/renor.it\/wp-content\/uploads\/2025\/05\/neural-network.webp","datePublished":"2025-05-18T10:23:19+00:00","dateModified":"2025-12-20T14:53:59+00:00","breadcrumb":{"@id":"https:\/\/renor.it\/en\/blog\/intelligenza-artificiale-algoritmi\/neural-networks-in-php-yes-it-can-be-done\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/renor.it\/en\/blog\/intelligenza-artificiale-algoritmi\/neural-networks-in-php-yes-it-can-be-done\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/renor.it\/en\/blog\/intelligenza-artificiale-algoritmi\/neural-networks-in-php-yes-it-can-be-done\/#primaryimage","url":"https:\/\/renor.it\/wp-content\/uploads\/2025\/05\/neural-network.webp","contentUrl":"https:\/\/renor.it\/wp-content\/uploads\/2025\/05\/neural-network.webp","width":1536,"height":1024,"caption":"Una trama di neuroni luminescenti si intreccia su uno sfondo di snippet del linguaggio PHP, mentre il logo campeggia al centro a indicare l\u2019inusuale connubio fra programmazione web e reti neurali."},{"@type":"BreadcrumbList","@id":"https:\/\/renor.it\/en\/blog\/intelligenza-artificiale-algoritmi\/neural-networks-in-php-yes-it-can-be-done\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/renor.it\/en\/"},{"@type":"ListItem","position":2,"name":"Blog","item":"https:\/\/renor.it\/en\/blog\/"},{"@type":"ListItem","position":3,"name":"Artificial Intelligence & Algorithms","item":"https:\/\/renor.it\/en\/blog\/artificial-intelligence-algorithms\/"},{"@type":"ListItem","position":4,"name":"Neural Networks in PHP? Yes, It Can Be Done!"}]},{"@type":"WebSite","@id":"https:\/\/renor.it\/en\/#website","url":"https:\/\/renor.it\/en\/","name":"RENOR & Partners S.r.l.","description":"","publisher":{"@id":"https:\/\/renor.it\/en\/#organization"},"alternateName":"RENOR & Partners S.r.l.","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/renor.it\/en\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/renor.it\/en\/#organization","name":"RENOR & Partners S.r.l.","url":"https:\/\/renor.it\/en\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/renor.it\/en\/#\/schema\/logo\/image\/","url":"https:\/\/renor.it\/wp-content\/uploads\/2025\/12\/logo-new-1.webp","contentUrl":"https:\/\/renor.it\/wp-content\/uploads\/2025\/12\/logo-new-1.webp","width":432,"height":146,"caption":"RENOR & Partners S.r.l."},"image":{"@id":"https:\/\/renor.it\/en\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/renorsrl","https:\/\/www.instagram.com\/renorpartners\/","https:\/\/www.linkedin.com\/company\/renor-partners\/posts\/?feedView=all"],"description":"RENOR & Partners Srl \u00e8 una societ\u00e0 di consulenza tecnologica e ingegneristica specializzata in sviluppo software, cloud computing, integrazione di sistemi, intelligenza artificiale applicata e progettazione elettronica. L\u2019azienda supporta imprese e pubbliche amministrazioni nella realizzazione di soluzioni digitali affidabili, scalabili e orientate all\u2019efficienza, con un approccio pragmatico basato su competenze tecniche, progettazione su misura e innovazione concreta.","email":"info@renor.it","telephone":"3791489430","legalName":"RENOR AND PARTNERS S.r.l.","foundingDate":"2022-06-21","vatID":"16768411007","taxID":"16768411007","numberOfEmployees":{"@type":"QuantitativeValue","minValue":"1","maxValue":"10"}},{"@type":"Person","@id":"https:\/\/renor.it\/en\/#\/schema\/person\/21343be04e5983a87f3a9a6182cf8795","name":"Simone Renzi","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/54f81b51be6bda6d63a06a1cd6563d9b0d5778d7af4f0bda4e246fc3e5737e2e?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/54f81b51be6bda6d63a06a1cd6563d9b0d5778d7af4f0bda4e246fc3e5737e2e?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/54f81b51be6bda6d63a06a1cd6563d9b0d5778d7af4f0bda4e246fc3e5737e2e?s=96&d=mm&r=g","caption":"Simone Renzi"},"description":"Senior full-stack web engineer with over 20 years of experience in cloud architectures, AI, and SaaS solutions; member of Mensa Italia. Creator of platforms such as HR24.ai and Paghe.ai, he oversaw the web development of FNS, a neural network simulator cited in Scientific Reports (Nature Portfolio), and has collaborated on research projects with INFN \u2013 Laboratori Nazionali di Frascati, Universit\u00e0 di Roma \u201cTor Vergata\u201d, Universidad Complutense, Universidad Polit\u00e9cnica and Centro de Tecnolog\u00eda Biom\u00e9dica in Madrid. A classical pianist, he combines musical creativity and technological rigor in every project.","sameAs":["https:\/\/renor.it","https:\/\/www.facebook.com\/simone.renzi.3954\/","https:\/\/www.linkedin.com\/in\/simone-renzi"],"url":"https:\/\/renor.it\/en\/author\/thesimon\/"}]}},"_links":{"self":[{"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/posts\/659","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/comments?post=659"}],"version-history":[{"count":0,"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/posts\/659\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/media\/507"}],"wp:attachment":[{"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/media?parent=659"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/categories?post=659"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/tags?post=659"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}