To compare and optimize

Final goal is 100% coverage!

For Neo to become a truly awesome project we need a truly awesome programming experience, how do we do that? With a nice interface exposing backend-agnostic methods and operations.

I propose we take inspiration from projects like numpy, julia, matlab and tfjs.

For now I think the most important thing we need an interface for is ndarrays and different variations of the ndarray such as tensors and matrix.

I think it would be wise to support all functions from numpy:

• Cholesky decomposition
• Determinant
• Eigenvalues
• Inverse
• Least squares
• Norm
• Moore–Penrose inverse
• Solve
• Singular value decomposition

Support for clustering multiple agents using RPC and the execution graph somehow.

Supported features: depth-clip-control, texture-compression-bc, texture-compression-etc2, texture-compression-astc, address-mode-clamp-to-border, texture-adapter-specific-format-features, clear-texture
error: Uncaught (in promise) WebGPUValidationError: 
Shader '' parsing error: expected ',', found ';'
  ┌─ wgsl:3:17
  │
3 │   inputSize: u32;
  │                 ^ expected ','

: expected ',', found ';'
      const err = new Error(error.value ?? "unknown");
                  ^
    at InnerGPUDevice.proto.pushError (https://crux.land/api/get/4ZZB5m.ts:7:19)
    at GPUDevice.createShaderModule (deno:ext/webgpu/01_webgpu.js:1237:14)
    at WebGPUBackend.register (https://raw.githubusercontent.com/denosaurs/neo/main/backend/webgpu/backend.ts:52:32)
    at feedForward (https://deno.land/x/[email protected]/src/gpu/kernels/feedforward.ts:19:34)
    at BaseGPULayer.feedForward (https://deno.land/x/[email protected]/src/gpu/layers/base.ts:118:11)
    at GPUNetwork.feedForward (https://deno.land/x/[email protected]/src/gpu/network.ts:51:27)
    at GPUNetwork.train (https://deno.land/x/[email protected]/src/gpu/network.ts:111:20)
    at async NeuralNetwork.train (https://deno.land/x/[email protected]/src/mod.ts:60:5)
    at async file:///home/erfanium/Documents/deno_mnist/sample.ts:28:1

Code:

import { NeuralNetwork } from "https://deno.land/x/[email protected]/mod.ts";
import { DataSet } from "https://deno.land/x/[email protected]/src/types.ts";
import { loadTest, loadTrain } from "./loader.ts";

const [x, y] = await loadTrain("data");
const trainData: DataSet[] = [];

for (let i = 0; i < 10; i++) {
  trainData.push({
    inputs: x[i],
    outputs: [y[i] / 10],
  });
}

const net = await new NeuralNetwork({
  hidden: [
    { size: 10, activation: "sigmoid" },
  ],
  cost: "crossentropy",
  output: { size: 1, activation: "sigmoid" },
  input: {
    type: "f32",
  },
  silent: false,
}).setupBackend(true, false);

await net.train(
  trainData,
  200,
  1,
  0.1,
);

deno 1.24.2

Support for multiple parallel threads running wasm, intelligently constructing a compute tree and automatically executing it maximally parallel.

A way to construct a graph of operations from A to Z automatically parallelizing, threading and utilizing the resources available.

You heard me, examples for everything and actual example applications! Like a NN or a linear regression or something, if possible it should be visual because my ape brain likes pretty graphs and colors!

Make the wgsl preprocessor its own thing and fix all of its bugs.

Support for multiple GPUs

Write docs for everything!

I think it would be wise to support all FFT functions from numpy:

• fft
• fft2
• fftn
• ifft
• ifft2
• ifftn