catniff 0.1.10 → 0.2.1

package/README.md

@@ -1,6 +1,6 @@
 # Catniff
 
-Catniff is an experimental tensor ops library and autograd engine inspired by [micrograd](https://github.com/karpathy/micrograd), and its name is a play on "catnip" and "differentiation". The project is heavily in-dev currently, so keep in mind that APIs can be unstable and backwards-incompatible.
+Catniff is an experimental tensor ops library and autograd engine made to be Torch-like (its name is a play on "catnip" and "differentiation"). This project is heavily under development currently, so keep in mind that APIs can be completely unstable and backwards-incompatible.
 
 ## Setup
 
@@ -13,57 +13,55 @@ npm install catniff
 
 Here is a little demo of a quadratic function:
 ```js
-const { Node } = require("catniff");
+const { Tensor } = require("catniff");
 
-const x = new Node(2);
+const x = new Tensor(2, { requiresGrad: true });
 const L = x.pow(2).add(x); // x^2 + x
 
 L.backward();
-console.log(x.grad); // 5
+
+console.log(x.grad.val()); // 5
 ```
 
 View all examples in [`./examples`](./examples).
 
 ## Tensors
 
-Tensors in Catniff are either numbers (scalars/0-D tensors) or multidimensional number arrays (n-D tensors).
-
-There is a built-in `TensorMath` class to help with tensor arithmetic, for example:
+Tensors in Catniff can be created by passing in a number or an nD array, and there are built-in methods that can be used to perform tensor arithmetic:
 ```js
-const { TensorMath } = require("catniff");
+const { Tensor } = require("catniff");
 
-const A = [ 1, 2, 3 ];
-const B = 3;
-console.log(TensorMath.add(A, B));
-```
-
-If you want to be concise, you can use `TM` or `TMath`:
-```js
-const { TM, TMath } = require("catniff");
+// Tensor init
+const A = new Tensor([ 1, 2, 3 ]);
+const B = new Tensor(3);
 
-const A = [ 1, 2, 3 ];
-const B = 3;
-console.log(TM.add(A, B));
-console.log(TMath.add(A, B));
+// Tensor addition (.val() returns the raw value rather than the tensor object)
+console.log(A.add(B).val());
 ```
 
-All available APIs are in `./src/tensor.ts`.
+All available APIs are in `./src/core.ts`.
 
 ## Autograd
 
-To compute the gradient wrt muliple variables of our mathematical expression, we use the `Node` class to dynamically build our DAG:
+To compute the gradient wrt multiple variables of our mathematical expression, we can simply set `requiresGrad` to `true`:
 ```js
-const { Node } = require("catniff");
-
-const X = new Node([
-    [ 0.5, -1.0 ],
-    [ 2.0,  0.0 ]
-]);
-
-const Y = new Node([
-    [ 1.0, -2.0 ],
-    [ 0.5,  1.5 ]
-]);
+const { Tensor } = require("catniff");
+
+const X = new Tensor(
+    [
+        [ 0.5, -1.0 ],
+        [ 2.0,  0.0 ]
+    ],
+    { requiresGrad: true }
+);
+
+const Y = new Tensor(
+    [
+        [ 1.0, -2.0 ],
+        [ 0.5,  1.5 ]
+    ],
+    { requiresGrad: true }
+);
 
 const D = X.sub(Y);
 const E = D.exp();
@@ -72,14 +70,19 @@ const G = F.log();
 
 G.backward();
 
-console.log(X.grad, Y.grad);
+// X.grad and Y.grad are tensor objects themselves, so we call .val() here to see their raw values
+console.log(X.grad.val(), Y.grad.val());
 ```
 
-All available APIs are in `./src/autograd.ts`.
+All available APIs are in `./src/core.ts`.
+
+## Documentation
+
+Todo :/
 
 ## Todos
 
-I'm mostly just learning and playing with this currently, so there are no concrete plans yet, but here are what I currently have in mind:
+I'm mostly just learning and playing with this currently, so there are no concrete plans yet, but here is what I currently have in mind:
 
 * Fix whatever is the problem right now (there are a lot of problems right now lol).
 * Add more tensor ops.

package/dist/core.d.ts

@@ -0,0 +1,88 @@
+export type TensorValue = number | TensorValue[];
+export interface TensorOptions {
+    shape?: number[];
+    strides?: number[];
+    grad?: Tensor;
+    requiresGrad?: boolean;
+    gradFn?: Function;
+    children?: Tensor[];
+}
+export declare class Tensor {
+    value: number[] | number;
+    shape: number[];
+    strides: number[];
+    grad?: Tensor;
+    requiresGrad: boolean;
+    gradFn: Function;
+    children: Tensor[];
+    constructor(value: TensorValue, options?: TensorOptions);
+    static flatten(tensor: TensorValue): number[] | number;
+    static getShape(tensor: TensorValue): number[];
+    static getStrides(shape: number[]): number[];
+    static padShape(stridesA: number[], stridesB: number[], shapeA: number[], shapeB: number[]): number[][];
+    static broadcastShapes(shapeA: number[], shapeB: number[]): number[];
+    static indexToCoords(index: number, shape: number[], strides: number[]): number[];
+    static coordsToIndex(coords: number[], shape: number[], strides: number[]): number;
+    static elementWiseAB(tA: Tensor, tB: Tensor, op: (tA: number, tB: number) => number): Tensor;
+    static elementWiseSelf(tA: Tensor, op: (tA: number) => number): Tensor;
+    elementWiseABDAG(other: TensorValue | Tensor, op: (a: number, b: number) => number, thisGrad?: (self: Tensor, other: Tensor, outGrad: Tensor) => Tensor, otherGrad?: (self: Tensor, other: Tensor, outGrad: Tensor) => Tensor): Tensor;
+    elementWiseSelfDAG(op: (a: number) => number, thisGrad?: (self: Tensor, outGrad: Tensor) => Tensor): Tensor;
+    static forceTensor(value: TensorValue | Tensor): Tensor;
+    static addGrad(tensor: Tensor, accumGrad: Tensor): void;
+    squeeze(dims?: number[] | number): Tensor;
+    unsqueeze(dim: number): Tensor;
+    sum(dims?: number[] | number, keepDims?: boolean): Tensor;
+    add(other: TensorValue | Tensor): Tensor;
+    sub(other: TensorValue | Tensor): Tensor;
+    mul(other: TensorValue | Tensor): Tensor;
+    pow(other: TensorValue | Tensor): Tensor;
+    div(other: TensorValue | Tensor): Tensor;
+    ge(other: TensorValue | Tensor): Tensor;
+    le(other: TensorValue | Tensor): Tensor;
+    gt(other: TensorValue | Tensor): Tensor;
+    lt(other: TensorValue | Tensor): Tensor;
+    eq(other: TensorValue | Tensor): Tensor;
+    logicalAnd(other: TensorValue | Tensor): Tensor;
+    logicalOr(other: TensorValue | Tensor): Tensor;
+    logicalXor(other: TensorValue | Tensor): Tensor;
+    logicalNot(): Tensor;
+    bitwiseAnd(other: TensorValue | Tensor): Tensor;
+    bitwiseOr(other: TensorValue | Tensor): Tensor;
+    bitwiseXor(other: TensorValue | Tensor): Tensor;
+    bitwiseNot(): Tensor;
+    bitwiseLeftShift(other: TensorValue | Tensor): Tensor;
+    bitwiseRightShift(other: TensorValue | Tensor): Tensor;
+    neg(): Tensor;
+    abs(): Tensor;
+    sign(): Tensor;
+    sin(): Tensor;
+    cos(): Tensor;
+    tan(): Tensor;
+    asin(): Tensor;
+    acos(): Tensor;
+    atan(): Tensor;
+    sinh(): Tensor;
+    cosh(): Tensor;
+    asinh(): Tensor;
+    acosh(): Tensor;
+    atanh(): Tensor;
+    sqrt(): Tensor;
+    exp(): Tensor;
+    log(): Tensor;
+    log2(): Tensor;
+    log10(): Tensor;
+    log1p(): Tensor;
+    relu(): Tensor;
+    sigmoid(): Tensor;
+    tanh(): Tensor;
+    transpose(dim1: number, dim2: number): Tensor;
+    t(): Tensor;
+    dot(other: TensorValue | Tensor): Tensor;
+    mm(other: TensorValue | Tensor): Tensor;
+    mv(other: TensorValue | Tensor): Tensor;
+    matmul(other: TensorValue | Tensor): Tensor;
+    static fullLike(tensor: Tensor, num: number, options?: TensorOptions): Tensor;
+    backward(): void;
+    val(): any;
+    withGrad(requiresGrad: boolean): Tensor;
+}