Fix compile issues

Author: Kaweees

README.md

@@ -112,12 +112,27 @@ To include `micrograd` in your Zig project, follow these steps:
 
 ## Usage
 
-micrograd is designed to be easy to use. You can include the library in your Zig project by adding the following line to your source files:
+`micrograd` is designed to be easy to use. You can include the library in your Zig project by adding the following line to your source files:
 
 ```zig
 const micrograd = @import("micrograd");
 ```
 
+<!-- PROJECT FILE STRUCTURE -->
+## Project Structure
+
+```sh
+micrograd/
+├── .github/                       # GitHub Actions CI/CD workflows
+├── src/                           # Library source files
+│   ├── lib.zig                      # Public API entry point
+│   └── ...
+├── build.zig                      # Zig build script
+├── build.zig.zon                  # Zig build script dependencies
+├── LICENSE                        # Project license
+└── README.md                      # You are here
+```
+
 ## License
 
 The source code for [Kaweees/micrograd](https://github.com/Kaweees/micrograd) is distributed under the terms of the MIT License, as I firmly believe that collaborating on free and open-source software fosters innovations that mutually and equitably beneficial to both collaborators and users alike. See [`LICENSE`](./LICENSE) for details and more information.

shell.nix

@@ -5,6 +5,7 @@ pkgs.mkShell {
     zig # Zig compiler
     just # Just runner
     nixfmt # Nix formatter
+    graphviz # Graphviz
   ];
 
   # Shell hook to set up environment

src/engine.zig

@@ -62,6 +62,7 @@ pub const BinaryType = enum {
 /// - Rectified Linear Unit (ReLU)
 /// - Softmax
 pub fn Value(comptime T: type) type {
+    // Check that T is a valid type
     if (@typeInfo(T) != .int and @typeInfo(T) != .float) {
         @compileError("Expected @int or @float type, got: " ++ @typeName(T));
     }
@@ -153,7 +154,7 @@ pub fn Value(comptime T: type) type {
         }
 
         /// Add two values
-        pub fn add(self: *Self, other: *Self) *Self {
+        pub inline fn add(self: *Self, other: *Self) *Self {
             return binary(self.data + other.data, .add, add_back, self, other);
         }
 
@@ -164,7 +165,7 @@ pub fn Value(comptime T: type) type {
         }
 
         /// Multiply two values
-        pub fn mul(self: *Self, other: *Self) *Self {
+        pub inline fn mul(self: *Self, other: *Self) *Self {
             return binary(self.data * other.data, .mul, mul_back, self, other);
         }
 
@@ -175,7 +176,7 @@ pub fn Value(comptime T: type) type {
         }
 
         /// Subtract two values
-        pub fn sub(self: *Self, other: *Self) *Self {
+        pub inline fn sub(self: *Self, other: *Self) *Self {
             return binary(self.data - other.data, .sub, sub_back, self, other);
         }
 
@@ -186,7 +187,7 @@ pub fn Value(comptime T: type) type {
         }
 
         /// Divide two values
-        pub fn div(self: *Self, other: *Self) *Self {
+        pub inline fn div(self: *Self, other: *Self) *Self {
             return binary(self.data / other.data, .div, div_back, self, other);
         }
 
@@ -197,23 +198,23 @@ pub fn Value(comptime T: type) type {
         }
 
         /// Apply the ReLU function to a value
-        pub fn relu(self: *Self) *Self {
+        pub inline fn relu(self: *Self) *Self {
             return unary(if (self.data > 0) self.data else @as(T, 0), .relu, relu_back, self);
         }
 
         /// Backpropagation function for ReLU
         fn relu_back(self: *Self) void {
-            self.expr.unary.prev.grad += if (self.data > 0) self.grad else @as(T, 0);
+            self.expr.unary.prev[0].grad += if (self.data > 0) self.grad else @as(T, 0);
         }
 
         /// Apply the softmax function to a value
-        pub fn softmax(self: *Self) *Self {
+        pub inline fn softmax(self: *Self) *Self {
             return unary(std.math.exp(self.data), .softmax, softmax_back, self);
         }
 
         /// Backpropagation function for softmax
         fn softmax_back(self: *Self) void {
-            self.expr.unary.prev.grad += self.grad * std.math.exp(self.data);
+            self.expr.unary.prev[0].grad += self.grad * std.math.exp(self.data);
         }
 
         /// Generate Graphviz DOT format representation of the computational graph
@@ -302,25 +303,29 @@ pub fn Value(comptime T: type) type {
 
             try visited.put(self, {});
 
-            if (self.prev) |children| {
-                for (children) |child| {
-                    try child.buildTopo(topo, visited);
-                }
+            const prevNodes = switch (self.expr) {
+                .nop => &[_]*Self{},
+                .unary => |u| &u.prev,
+                .binary => |b| &b.prev,
+            };
+
+            for (prevNodes) |prev| {
+                try prev.buildTopo(topo, visited);
             }
 
             try topo.append(self);
         }
 
         /// Backward pass - topological sort and gradient computation
-        pub fn backwardPass(self: *Self, allocator: std.mem.Allocator) !void {
+        pub fn backwardPass(self: *Self, allocator: std.mem.Allocator) void {
             // Topological ordering
             var topo = std.ArrayList(*Self).init(allocator);
             defer topo.deinit();
 
             var visited = std.AutoHashMap(*Self, void).init(allocator);
             defer visited.deinit();
 
-            try self.buildTopo(&topo, &visited);
+            self.buildTopo(&topo, &visited) catch unreachable;
 
             // Apply chain rule
             self.grad = @as(T, 1);
@@ -330,7 +335,7 @@ pub fn Value(comptime T: type) type {
             var i = items.len;
             while (i > 0) {
                 i -= 1;
-                items[i].backward(items[i]);
+                items[i].backprop();
             }
         }
     };

src/nn.zig

@@ -15,13 +15,9 @@ const zprob = @import("zprob");
 /// const output = try neuron.forward(&inputs);
 /// ```
 pub fn Neuron(comptime T: type) type {
-    if (@typeInfo(T) != .int and @typeInfo(T) != .float) {
-        @compileError("Expected @int or @float type, got: " ++ @typeName(T));
-    }
-
+    const ValueType = engine.Value(T);
     return struct {
         const Self = @This();
-        const ValueType = engine.Value(T);
 
         /// The number of inputs
         nin: usize,
@@ -33,13 +29,12 @@ pub fn Neuron(comptime T: type) type {
         var arena: std.heap.ArenaAllocator = undefined;
         var env: zprob.RandomEnvironment = undefined;
 
-        pub fn init(alloc: std.mem.Allocator) !void {
+        pub fn init(alloc: std.mem.Allocator) void {
             arena = std.heap.ArenaAllocator.init(alloc);
             env = try zprob.RandomEnvironment.init(arena.allocator());
-            defer env.deinit();
         }
 
-        /// Free allocated memory
+        /// Cleanup allocated memory
         pub fn deinit() void {
             arena.deinit();
         }
@@ -63,20 +58,20 @@ pub fn Neuron(comptime T: type) type {
 
         /// Generate a random value appropriate for the type T
         pub fn generate() T {
-            return env.rNormal(@as(T, 0), @as(T, 1));
+            return env.rNormal(@as(T, -1), @as(T, 1)) catch @as(T, 0);
         }
 
         /// Forward pass through the neuron
         pub fn forward(self: *Self, inputs: []*ValueType) *ValueType {
             if (inputs.len != self.nin) {
-                return error.InputSizeMismatch;
+                std.debug.panic("Input size mismatch: {d} != {d}", .{ inputs.len, self.nin });
             }
 
             var sum = self.bias;
             for (self.weights, inputs) |w, x| {
                 sum = sum.add(w.mul(x));
             }
-
+            // Apply activation function (ReLU)
             return sum.relu();
         }
     };

train.zig

@@ -44,7 +44,7 @@ pub fn main() !void {
     try stdout.print("d.data: {}\n", .{d.data});
     try stdout.print("d.grad: {}\n", .{d.grad});
 
-    d.backprop(); // d.grad = 1
+    try d.backwardPass(std.heap.page_allocator);
 
     try stdout.print("d.data: {}\n", .{d.data});
     try stdout.print("d.grad: {}\n", .{d.grad});