Aggiunta della struttura neuron e tensor

src/main.zig

@@ -3,26 +3,44 @@ const Neuron = @import("neuron.zig").Neuron;
 const Tensor = @import("tensor.zig").Tensor;
 
 pub fn main() !void {
-    // 1. Setup dell'allocatore per la memoria
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
     const allocator = gpa.allocator();
     defer _ = gpa.deinit();
 
-    // 2. Creiamo un neurone con 3 ingressi
+    // 1. Inizializza Neurone
     var my_neuron = try Neuron.init(allocator, 3);
     defer my_neuron.deinit();
 
-    // 3. Creiamo dei dati di input di esempio (es. [1.0, 0.5, -2.0])
+    // 2. Dati di Input
     var inputs = try Tensor.init(allocator, &[_]usize{3});
     defer inputs.deinit();
     inputs.data[0] = 1.0;
     inputs.data[1] = 0.5;
     inputs.data[2] = -2.0;
 
-    // 4. Eseguiamo il calcolo
+    // 3. Il Target: Vogliamo che il neurone impari a rispondere "4.0"
-    const output = my_neuron.forward(inputs);
+    const target: f32 = 4.0;
 
-    std.debug.print("Input: {any}\n", .{inputs.data});
+    // Learning Rate: La velocità di apprendimento (né troppo alta, né troppo bassa)
-    std.debug.print("Pesi del neurone: {any}\n", .{my_neuron.weights.data});
+    const lr: f32 = 0.01;
-    std.debug.print("Risultato (Output): {d:.4}\n", .{output});
+
+    std.debug.print("--- INIZIO TRAINING ---\n", .{});
+    std.debug.print("Target desiderato: {d:.2}\n", .{target});
+
+    // 4. Ciclo di Training (Epochs)
+    var i: usize = 0;
+    while (i < 100) : (i += 1) {
+        const loss = my_neuron.train(inputs, target, lr);
+
+        // Stampiamo lo stato ogni 10 passaggi
+        if (i % 10 == 0) {
+            const current_pred = my_neuron.forward(inputs);
+            std.debug.print("Epoca {d}: Loss = {d:.6} | Previsione attuale = {d:.4}\n", .{ i, loss, current_pred });
+        }
+    }
+
+    std.debug.print("\n--- TRAINING COMPLETATO ---\n", .{});
+    std.debug.print("Pesi finali: {any}\n", .{my_neuron.weights.data});
+    std.debug.print("Bias finale: {d:.4}\n", .{my_neuron.bias});
+    std.debug.print("Risultato finale: {d:.4}\n", .{my_neuron.forward(inputs)});
 }

src/neuron.zig

@@ -40,4 +40,21 @@ pub const Neuron = struct {
 
         return if (z > 0) z else 0;
     }
+
+    pub fn train(self: *Neuron, inputs: Tensor, target: f32, learning_rate: f32) f32 {
+        const prediction = self.forward(inputs);
+
+        const err = prediction - target;
+
+        const d_relu: f32 = if (prediction > 0) 1.0 else 0.0;
+
+        for (self.weights.data, inputs.data) |*w, x| {
+            const gradient = err * d_relu * x;
+            w.* -= learning_rate * gradient;
+        }
+
+        self.bias -= learning_rate * err * d_relu;
+
+        return err * err;
+    }
 };