From: sjinzh <redacted>
Date: Mon, 26 Jun 2023 20:48:31 +0000 (+0800)
Subject: zig : add tests by zig (#307)
X-Git-Tag: upstream/0.0.1642~1370
X-Git-Url: https://git.djapps.eu/?a=commitdiff_plain;h=ee1b3727e60403012dd2b57d35b60558f4db66d8;p=pkg%2Fggml%2Fsources%2Fggml

zig : add tests by zig (#307)

* update build.zig

* zig : add tests by zig
---

diff --git a/.gitignore b/.gitignore
index 09303190..698b04a9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,4 +18,6 @@ src/arm_neon.h
 tests/arm_neon.h
 
 zig-out/
-zig-cache/
\ No newline at end of file
+zig-cache/
+
+*.dot
\ No newline at end of file
diff --git a/build.zig b/build.zig
index 34582cec..87151a88 100644
--- a/build.zig
+++ b/build.zig
@@ -2,24 +2,26 @@ const std = @import("std");
 
 // Zig Version: 0.11.0-dev.3798+a5e15eced
 // Zig Build Command: zig build
-// Zig Run Command:    
-//     zig build run_dolly-v2             
-//     zig build run_gpt-2                  
-//     zig build run_gpt-j                   
-//     zig build run_gpt-neox                 
-//     zig build run_mnist                    
-//     zig build run_mpt                     
-//     zig build run_replit                  
-//     zig build run_starcoder                
-//     zig build run_test-grad0               
-//     zig build run_test-mul-mat0            
-//     zig build run_test-mul-mat2            
-//     zig build run_test-opt                 
-//     zig build run_test-vec1                
-//     zig build run_test0                   
-//     zig build run_test1                    
-//     zig build run_test2                    
-//     zig build run_test3                    
+// Zig Run Command: zig build -h  
+//     zig build run_dolly-v2           
+//     zig build run_gpt-2                
+//     zig build run_gpt-j                 
+//     zig build run_gpt-neox               
+//     zig build run_mnist                  
+//     zig build run_mpt                 
+//     zig build run_replit        
+//     zig build run_starcoder            
+//     zig build run_test-grad0            
+//     zig build run_test-mul-mat0          
+//     zig build run_test-mul-mat2         
+//     zig build run_test-opt               
+//     zig build run_test-vec1               
+//     zig build run_test0                 
+//     zig build run_test1                  
+//     zig build run_test2              
+//     zig build run_test3
+//     zig build run_zig_test0
+//     zig build run_zig_test1     
 pub fn build(b: *std.build.Builder) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
@@ -110,4 +112,27 @@ pub fn build(b: *std.build.Builder) void {
         const run_step = b.step("run_" ++ name, "Run tests");
         run_step.dependOn(&run_cmd.step);
     }
+
+    // zig_tests
+    const zig_tests = .{
+        "test0",
+        "test1",
+    };
+    inline for (zig_tests) |name| {
+        const exe = b.addExecutable(.{
+            .name = name,
+            .root_source_file = .{ .path = std.fmt.comptimePrint("tests/{s}.zig", .{name}) },
+            .target = target,
+            .optimize = optimize,
+        });
+        exe.addIncludePath("./include");
+        exe.addIncludePath("./include/ggml");
+        exe.linkLibrary(lib);
+        b.installArtifact(exe);
+        const run_cmd = b.addRunArtifact(exe);
+        run_cmd.step.dependOn(b.getInstallStep());
+        if (b.args) |args| run_cmd.addArgs(args);
+        const run_step = b.step("run_zig_" ++ name, "Run zig_tests");
+        run_step.dependOn(&run_cmd.step);
+    }
 }
\ No newline at end of file
diff --git a/tests/test0.zig b/tests/test0.zig
new file mode 100644
index 00000000..8246a978
--- /dev/null
+++ b/tests/test0.zig
@@ -0,0 +1,43 @@
+const std = @import("std");
+const c = @cImport({
+    @cInclude("stdio.h");
+    @cInclude("stdlib.h");
+    @cInclude("ggml/ggml.h");
+});
+
+pub fn main() !void {
+    const params = .{
+        .mem_size   = 128*1024*1024,
+        .mem_buffer = null,
+        .no_alloc   = false,
+    };
+
+    const ctx0 = c.ggml_init(params);
+    defer c.ggml_free(ctx0);
+
+    const t1 = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 10);
+    const t2 = c.ggml_new_tensor_2d(ctx0, c.GGML_TYPE_I16, 10, 20);
+    const t3 = c.ggml_new_tensor_3d(ctx0, c.GGML_TYPE_I32, 10, 20, 30);
+
+    try std.testing.expect(t1.*.n_dims == 1);
+    try std.testing.expect(t1.*.ne[0]  == 10);
+    try std.testing.expect(t1.*.nb[1]  == 10*@sizeOf(f32));
+
+    try std.testing.expect(t2.*.n_dims == 2);
+    try std.testing.expect(t2.*.ne[0]  == 10);
+    try std.testing.expect(t2.*.ne[1]  == 20);
+    try std.testing.expect(t2.*.nb[1]  == 10*@sizeOf(i16));
+    try std.testing.expect(t2.*.nb[2]  == 10*20*@sizeOf(i16));
+
+    try std.testing.expect(t3.*.n_dims == 3);
+    try std.testing.expect(t3.*.ne[0]  == 10);
+    try std.testing.expect(t3.*.ne[1]  == 20);
+    try std.testing.expect(t3.*.ne[2]  == 30);
+    try std.testing.expect(t3.*.nb[1]  == 10*@sizeOf(i32));
+    try std.testing.expect(t3.*.nb[2]  == 10*20*@sizeOf(i32));
+    try std.testing.expect(t3.*.nb[3]  == 10*20*30*@sizeOf(i32));
+
+    c.ggml_print_objects(ctx0);
+
+    _ = try std.io.getStdIn().reader().readByte();
+}
diff --git a/tests/test1.zig b/tests/test1.zig
new file mode 100644
index 00000000..e40c37e8
--- /dev/null
+++ b/tests/test1.zig
@@ -0,0 +1,459 @@
+const std = @import("std");
+const c = @cImport({
+    @cInclude("stdio.h");
+    @cInclude("stdlib.h");
+    @cInclude("ggml/ggml.h");
+});
+
+pub fn main() !void {
+    const params = .{
+        .mem_size   = 128*1024*1024,
+        .mem_buffer = null,
+        .no_alloc   = false,
+    };
+
+    const ctx0 = c.ggml_init(params);
+    defer c.ggml_free(ctx0);
+
+    {
+        const x = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 1);
+
+        c.ggml_set_param(ctx0, x);
+
+        const a = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 1);
+        const b = c.ggml_mul(ctx0, x, x);
+        const f = c.ggml_mul(ctx0, b, a);
+
+        // a*x^2
+        // 2*a*x
+
+        c.ggml_print_objects(ctx0);
+
+        const gf = c.ggml_build_forward(f);
+        const gb = c.ggml_build_backward(ctx0, @constCast(&gf), false);
+
+        _ = c.ggml_set_f32(x, 2.0);
+        _ = c.ggml_set_f32(a, 3.0);
+
+        c.ggml_graph_reset(@constCast(&gf));
+        _ = c.ggml_set_f32(f.*.grad, 1.0);
+
+        c.ggml_graph_compute(ctx0, @constCast(&gb));
+
+        std.debug.print("f     = {d:.6}\n", .{c.ggml_get_f32_1d(f, 0)});
+        std.debug.print("df/dx = {d:.6}\n", .{c.ggml_get_f32_1d(x.*.grad, 0)});
+
+        try std.testing.expect(c.ggml_get_f32_1d(f, 0)          ==  12.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x.*.grad, 0)   ==  12.0);
+
+        _ = c.ggml_set_f32(x, 3.0);
+
+        c.ggml_graph_reset(@constCast(&gf));
+        _ = c.ggml_set_f32(f.*.grad, 1.0);
+
+        c.ggml_graph_compute(ctx0, @constCast(&gb));
+
+        std.debug.print("f     = {d:.6}\n", .{c.ggml_get_f32_1d(f, 0)});
+        std.debug.print("df/dx = {d:.6}\n", .{c.ggml_get_f32_1d(x.*.grad, 0)});
+
+        try std.testing.expect(c.ggml_get_f32_1d(f, 0)          ==  27.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x.*.grad, 0)   ==  18.0);
+
+        c.ggml_graph_dump_dot(&gf, null, "test1-1-forward.dot");
+        c.ggml_graph_dump_dot(&gb, &gf,  "test1-1-backward.dot");
+    }
+
+    /////////////////////////////////////////////////////////////
+
+    {
+        const x1 = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 1);
+        const x2 = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 1);
+        const x3 = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 1);
+
+        _ = c.ggml_set_f32(x1, 3.0);
+        _ = c.ggml_set_f32(x2, 1.0);
+        _ = c.ggml_set_f32(x3, 0.0);
+
+        c.ggml_set_param(ctx0, x1);
+        c.ggml_set_param(ctx0, x2);
+
+        const y = c.ggml_add(ctx0, c.ggml_mul(ctx0, x1, x1), c.ggml_mul(ctx0, x1, x2));
+
+        const gf = c.ggml_build_forward(y);
+        const gb = c.ggml_build_backward(ctx0, @constCast(&gf), false);
+
+        c.ggml_graph_reset(@constCast(&gf));
+        _ = c.ggml_set_f32(y.*.grad, 1.0);
+
+        c.ggml_graph_compute(ctx0, @constCast(&gb));
+
+        std.debug.print("y      = {d:.6}\n", .{c.ggml_get_f32_1d(y, 0)});
+        std.debug.print("df/dx1 = {d:.6}\n", .{c.ggml_get_f32_1d(x1.*.grad, 0)});
+        std.debug.print("df/dx2 = {d:.6}\n", .{c.ggml_get_f32_1d(x2.*.grad, 0)});
+
+        try std.testing.expect(c.ggml_get_f32_1d(y, 0)          ==  12.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 0)  ==  7.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 0)  ==  3.0);
+
+        const g1 = x1.*.grad;
+        const g2 = x2.*.grad;
+
+        const gbb = c.ggml_build_backward(ctx0, @constCast(&gb), true);
+
+        c.ggml_graph_reset(@constCast(&gb));
+        _ = c.ggml_set_f32(g1.*.grad, 1.0);
+        _ = c.ggml_set_f32(g2.*.grad, 1.0);
+
+        c.ggml_graph_compute(ctx0, @constCast(&gbb));
+
+        std.debug.print("H * [1, 1] = [ {d:.6} {d:.6} ]\n", .{c.ggml_get_f32_1d(x1.*.grad, 0), c.ggml_get_f32_1d(x2.*.grad, 0)});
+
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 0)  ==  3.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 0)  ==  1.0);
+
+        c.ggml_graph_dump_dot(&gf, null, "test1-2-forward.dot");
+        c.ggml_graph_dump_dot(&gb, &gf,  "test1-2-backward.dot");
+    }
+    
+    ///////////////////////////////////////////////////////////////
+
+    {
+        const x1 = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 1);
+        const x2 = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 1);
+
+        c.ggml_set_param(ctx0, x1);
+        c.ggml_set_param(ctx0, x2);
+
+        const y = c.ggml_mul(ctx0, c.ggml_add(ctx0, c.ggml_mul(ctx0, x1, x1), c.ggml_mul(ctx0, x1, x2)), x1);
+
+        const gf = c.ggml_build_forward(y);
+        const gb = c.ggml_build_backward(ctx0, @constCast(&gf), false);
+
+        _ = c.ggml_set_f32(x1, 3.0);
+        _ = c.ggml_set_f32(x2, 4.0);
+
+        c.ggml_graph_reset(@constCast(&gf));
+        _ = c.ggml_set_f32(y.*.grad, 1.0);
+
+        c.ggml_graph_compute(ctx0, @constCast(&gb));
+
+        std.debug.print("y      = {d:.6}\n", .{c.ggml_get_f32_1d(y, 0)});
+        std.debug.print("df/dx1 = {d:.6}\n", .{c.ggml_get_f32_1d(x1.*.grad, 0)});
+        std.debug.print("df/dx2 = {d:.6}\n", .{c.ggml_get_f32_1d(x2.*.grad, 0)});
+
+        try std.testing.expect(c.ggml_get_f32_1d(y, 0)          ==  63.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 0)  ==  51.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 0)  ==  9.0);
+
+        c.ggml_graph_dump_dot(&gf, null, "test1-3-forward.dot");
+        c.ggml_graph_dump_dot(&gb, &gf,  "test1-3-backward.dot");
+    }
+
+    ///////////////////////////////////////////////////////////////
+
+    {
+        const x1 = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 1);
+        const x2 = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 1);
+        const x3 = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 1);
+
+        c.ggml_set_param(ctx0, x1);
+        c.ggml_set_param(ctx0, x2);
+        c.ggml_set_param(ctx0, x3);
+
+        const y = c.ggml_mul(ctx0, c.ggml_mul(ctx0, c.ggml_mul(ctx0, x1, x1), c.ggml_mul(ctx0, x2, x2)), x3);
+
+        const gf = c.ggml_build_forward(y);
+        const gb = c.ggml_build_backward(ctx0, @constCast(&gf), false);
+
+        _ = c.ggml_set_f32(x1, 1.0);
+        _ = c.ggml_set_f32(x2, 2.0);
+        _ = c.ggml_set_f32(x3, 3.0);
+
+        c.ggml_graph_reset(@constCast(&gf));
+        _ = c.ggml_set_f32(y.*.grad, 1.0);
+
+        c.ggml_graph_compute(ctx0, @constCast(&gb));
+
+        std.debug.print("y      = {d:.6}\n", .{c.ggml_get_f32_1d(y, 0)});
+        std.debug.print("df/dx1 = {d:.6}\n", .{c.ggml_get_f32_1d(x1.*.grad, 0)});
+        std.debug.print("df/dx2 = {d:.6}\n", .{c.ggml_get_f32_1d(x2.*.grad, 0)});
+        std.debug.print("df/dx3 = {d:.6}\n", .{c.ggml_get_f32_1d(x3.*.grad, 0)});
+
+        try std.testing.expect(c.ggml_get_f32_1d(y, 0)          ==  12.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 0)  ==  24.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 0)  ==  12.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x3.*.grad, 0)  ==  4.0);      
+
+        const g1 = x1.*.grad;
+        const g2 = x2.*.grad;
+        const g3 = x3.*.grad;
+
+        const gbb = c.ggml_build_backward(ctx0, @constCast(&gb), true);
+
+        c.ggml_graph_reset(@constCast(&gb));
+        _ = c.ggml_set_f32(g1.*.grad, 1.0);
+        _ = c.ggml_set_f32(g2.*.grad, 1.0);
+        _ = c.ggml_set_f32(g3.*.grad, 1.0);
+
+        c.ggml_graph_compute(ctx0, @constCast(&gbb));
+
+        std.debug.print("H * [1, 1, 1] = [ {d:.6} {d:.6} {d:.6}]\n", 
+            .{  
+                c.ggml_get_f32_1d(x1.*.grad, 0), 
+                c.ggml_get_f32_1d(x2.*.grad, 0),
+                c.ggml_get_f32_1d(x3.*.grad, 0),
+            });
+
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 0)  ==  56.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 0)  ==  34.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x3.*.grad, 0)  ==  12.0);  
+
+        c.ggml_graph_dump_dot(&gf, null, "test1-4-forward.dot");
+        c.ggml_graph_dump_dot(&gb, &gf,  "test1-4-backward.dot");
+    }
+
+    ///////////////////////////////////////////////////////////////
+
+    {
+        const x1 = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 3);
+        const x2 = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 3);
+
+        c.ggml_set_param(ctx0, x1);
+        c.ggml_set_param(ctx0, x2);
+
+        const y = c.ggml_sum(ctx0, c.ggml_mul(ctx0, x1, x2));
+
+        const gf = c.ggml_build_forward(y);
+        const gb = c.ggml_build_backward(ctx0, @constCast(&gf), false);
+
+        _ = c.ggml_set_f32(x1, 3.0);
+        _ = c.ggml_set_f32(x2, 5.0);
+
+        c.ggml_graph_reset(@constCast(&gf));
+        _ = c.ggml_set_f32(y.*.grad, 1.0);
+
+        c.ggml_graph_compute(ctx0, @constCast(&gb));
+
+        std.debug.print("y      = {d:.6}\n", .{c.ggml_get_f32_1d(y, 0)});
+        std.debug.print("df/dx1 = {d:.6} {d:.6} {d:.6}\n", 
+            .{
+                c.ggml_get_f32_1d(x1.*.grad, 0),
+                c.ggml_get_f32_1d(x1.*.grad, 1),
+                c.ggml_get_f32_1d(x1.*.grad, 2),
+            });
+        std.debug.print("df/dx2 = {d:.6} {d:.6} {d:.6}\n", 
+            .{
+                c.ggml_get_f32_1d(x2.*.grad, 0),
+                c.ggml_get_f32_1d(x2.*.grad, 1),
+                c.ggml_get_f32_1d(x2.*.grad, 2),
+            });
+
+        try std.testing.expect(c.ggml_get_f32_1d(y, 0)          ==  45.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 0)  ==  5.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 0)  ==  3.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 1)  ==  5.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 1)  ==  3.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 2)  ==  5.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 2)  ==  3.0);
+
+        c.ggml_graph_dump_dot(&gf, null, "test1-5-forward.dot");
+        c.ggml_graph_dump_dot(&gb, &gf,  "test1-5-backward.dot");
+    }
+
+    ///////////////////////////////////////////////////////////////
+
+    {
+        const x1 = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 3);
+        const x2 = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 3);
+
+        c.ggml_set_param(ctx0, x1);
+        c.ggml_set_param(ctx0, x2);
+
+        const y =
+            c.ggml_sum(ctx0,
+                    c.ggml_add(ctx0,
+                        c.ggml_mul(ctx0, x1, x2),
+                        c.ggml_mul(ctx0,
+                            c.ggml_repeat(ctx0, c.ggml_new_f32(ctx0, -2.0), x1),
+                            c.ggml_mul(ctx0, x1, x1)
+                            )
+                        )
+                    );
+
+        const gf = c.ggml_build_forward(y);
+        const gb = c.ggml_build_backward(ctx0, @constCast(&gf), false);
+
+        _ = c.ggml_set_f32(x1, 3.0);
+        _ = c.ggml_set_f32(x2, 5.0);
+
+        c.ggml_graph_reset(@constCast(&gf));
+        _ = c.ggml_set_f32(y.*.grad, 1.0);
+
+        c.ggml_graph_compute(ctx0, @constCast(&gb));
+
+        std.debug.print("y      = {d:.6}\n", .{c.ggml_get_f32_1d(y, 0)});
+        std.debug.print("df/dx1 = {d:.6} {d:.6} {d:.6}\n", 
+            .{
+                c.ggml_get_f32_1d(x1.*.grad, 0),
+                c.ggml_get_f32_1d(x1.*.grad, 1),
+                c.ggml_get_f32_1d(x1.*.grad, 2),
+            });
+        std.debug.print("df/dx2 = {d:.6} {d:.6} {d:.6}\n", 
+            .{
+                c.ggml_get_f32_1d(x2.*.grad, 0),
+                c.ggml_get_f32_1d(x2.*.grad, 1),
+                c.ggml_get_f32_1d(x2.*.grad, 2),
+            });
+
+        try std.testing.expect(c.ggml_get_f32_1d(y, 0)          ==  -9.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 0)  ==  -7.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 1)  ==  -7.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 2)  ==  -7.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 0)  ==  3.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 1)  ==  3.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 2)  ==  3.0);
+
+        c.ggml_graph_dump_dot(&gf, null, "test1-6-forward.dot");
+        c.ggml_graph_dump_dot(&gb, &gf,  "test1-6-backward.dot");
+    }
+
+    ///////////////////////////////////////////////////////////////
+
+    {
+        const x1 = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 3);
+        const x2 = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 3);
+
+        c.ggml_set_param(ctx0, x1);
+        c.ggml_set_param(ctx0, x2);
+
+        const y =
+            c.ggml_sum(ctx0,
+                    c.ggml_sub(ctx0,
+                        c.ggml_mul(ctx0, x1, x2),
+                        c.ggml_mul(ctx0,
+                            c.ggml_mul(ctx0, x1, x1),
+                            c.ggml_repeat(ctx0, c.ggml_new_f32(ctx0, -2.0), x1)
+                            )
+                        )
+                    );
+
+        const gf = c.ggml_build_forward(y);
+        const gb = c.ggml_build_backward(ctx0, @constCast(&gf), false);
+
+        _ = c.ggml_set_f32(x1, 3.0);
+        _ = c.ggml_set_f32(x2, 5.0);
+
+        c.ggml_graph_reset(@constCast(&gf));
+        _ = c.ggml_set_f32(y.*.grad, 1.0);
+
+        c.ggml_graph_compute(ctx0, @constCast(&gb));
+
+        std.debug.print("y      = {d:.6}\n", .{c.ggml_get_f32_1d(y, 0)});
+        std.debug.print("df/dx1 = {d:.6} {d:.6} {d:.6}\n", 
+            .{
+                c.ggml_get_f32_1d(x1.*.grad, 0),
+                c.ggml_get_f32_1d(x1.*.grad, 1),
+                c.ggml_get_f32_1d(x1.*.grad, 2),
+            });
+        std.debug.print("df/dx2 = {d:.6} {d:.6} {d:.6}\n", 
+            .{
+                c.ggml_get_f32_1d(x2.*.grad, 0),
+                c.ggml_get_f32_1d(x2.*.grad, 1),
+                c.ggml_get_f32_1d(x2.*.grad, 2),
+            });
+
+        try std.testing.expect(c.ggml_get_f32_1d(y, 0)          ==  99.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 0)  ==  17.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 1)  ==  17.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 2)  ==  17.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 0)  ==  3.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 1)  ==  3.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 2)  ==  3.0);
+
+        c.ggml_graph_dump_dot(&gf, null, "test1-7-forward.dot");
+        c.ggml_graph_dump_dot(&gb, &gf,  "test1-7-backward.dot");
+    }
+
+    ///////////////////////////////////////////////////////////////
+
+    {
+        const x1 = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 3);
+        const x2 = c.ggml_new_tensor_1d(ctx0, c.GGML_TYPE_F32, 3);
+
+        c.ggml_set_param(ctx0, x1);
+        c.ggml_set_param(ctx0, x2);
+
+        const y =
+            c.ggml_abs(ctx0,
+                    c.ggml_sub(ctx0, x1, x2)
+                    );
+
+        const gf = c.ggml_build_forward(y);
+        const gb = c.ggml_build_backward(ctx0, @constCast(&gf), false);
+
+        _ = c.ggml_set_f32(x1, 3.0);
+        _ = c.ggml_set_f32(x2, 5.0);
+
+        c.ggml_graph_reset(@constCast(&gf));
+        _ = c.ggml_set_f32(y.*.grad, 1.0);
+
+        c.ggml_graph_compute(ctx0, @constCast(&gb));
+
+        std.debug.print("y      = {d:.6}\n", .{c.ggml_get_f32_1d(y, 0)});
+        std.debug.print("df/dx1 = {d:.6} {d:.6} {d:.6}\n", 
+            .{
+                c.ggml_get_f32_1d(x1.*.grad, 0),
+                c.ggml_get_f32_1d(x1.*.grad, 1),
+                c.ggml_get_f32_1d(x1.*.grad, 2),
+            });
+        std.debug.print("df/dx2 = {d:.6} {d:.6} {d:.6}\n", 
+            .{
+                c.ggml_get_f32_1d(x2.*.grad, 0),
+                c.ggml_get_f32_1d(x2.*.grad, 1),
+                c.ggml_get_f32_1d(x2.*.grad, 2),
+            });
+
+        try std.testing.expect(c.ggml_get_f32_1d(y, 0)          ==  2.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 0)  ==  -1.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 1)  ==  -1.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 2)  ==  -1.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 0)  ==  1.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 1)  ==  1.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 2)  ==  1.0);
+
+        _ = c.ggml_set_f32(x1, 7.0);
+        _ = c.ggml_set_f32(x2, 5.0);
+
+        c.ggml_graph_reset(@constCast(&gf));
+        _ = c.ggml_set_f32(y.*.grad, 1.0);
+
+        c.ggml_graph_compute(ctx0, @constCast(&gb));
+
+        std.debug.print("y      = {d:.6}\n", .{c.ggml_get_f32_1d(y, 0)});
+        std.debug.print("df/dx1 = {d:.6} {d:.6} {d:.6}\n", 
+            .{
+                c.ggml_get_f32_1d(x1.*.grad, 0),
+                c.ggml_get_f32_1d(x1.*.grad, 1),
+                c.ggml_get_f32_1d(x1.*.grad, 2),
+            });
+        std.debug.print("df/dx2 = {d:.6} {d:.6} {d:.6}\n", 
+            .{
+                c.ggml_get_f32_1d(x2.*.grad, 0),
+                c.ggml_get_f32_1d(x2.*.grad, 1),
+                c.ggml_get_f32_1d(x2.*.grad, 2),
+            });
+
+        try std.testing.expect(c.ggml_get_f32_1d(y, 0)          ==  2.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 0)  ==  1.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 1)  ==  1.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x1.*.grad, 2)  ==  1.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 0)  ==  -1.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 1)  ==  -1.0);
+        try std.testing.expect(c.ggml_get_f32_1d(x2.*.grad, 2)  ==  -1.0);
+
+        c.ggml_graph_dump_dot(&gf, null, "test1-8-forward.dot");
+        c.ggml_graph_dump_dot(&gb, &gf,  "test1-8-backward.dot");
+    }
+
+    _ = try std.io.getStdIn().reader().readByte();
+}
\ No newline at end of file