froog 0.2.2__tar.gz → 0.2.4__tar.gz

froog-0.2.4/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.1
+Name: froog
+Version: 0.2.4
+Summary: a beautifully simplistic ml framework
+Author: Kevin Buhler
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# ribbit <img src="https://github.com/kevbuh/ribbit/actions/workflows/test.yml/badge.svg" alt="unit test badge" >
+<div align="center" >
+  <img src="https://raw.githubusercontent.com/kevbuh/ribbit/main/assets/froog.png" alt="froog the frog" height="200">
+  <br/>
+  ribbit: fast real-time optimization of gradients 
+  <br/>
+  a beautifully compact machine-learning library
+  <br/>
+  <a href="https://github.com/kevbuh/ribbit">homepage</a> | <a href="https://github.com/kevbuh/ribbit/tree/main/docs">documentation</a> | <a href="https://pypi.org/project/ribbit/">pip</a>
+  <br/>
+  <br/>
+</div>
+
+RIBBIT is a SUPER SIMPLE machine learning framework with the goal of creating tools with AI --> easily and efficiently.
+
+It's an end-to-end framework, encapsulating everything from ensemble trees to deep neural networks (still working on all that lol)
+
+# Installation
+```bash
+pip install ribbit
+```
+
+### Overview of Features
+- <a href="https://github.com/kevbuh/ribbit/blob/main/ribbit/tensor.py">Custom Tensors</a> 
+  - Backpropagation
+  - Automatic Differentiation (autograd)
+      - Forward and backward passes
+- <a href="https://github.com/kevbuh/ribbit/blob/main/ribbit/ops.py">ML Operations</a> 
+  - 2D Convolutions (im2col)
+  - Numerical gradient checking
+  - Acceleration methods (Adam)
+  - Avg & Max pooling
+- <a href="https://github.com/kevbuh/ribbit/blob/main/models/efficientnet.py">EfficientNet</a> inference
+- <a href="https://github.com/kevbuh/ribbit/blob/main/ribbit/ops_gpu.py">GPU Support</a> 
+- and a bunch <a href="https://github.com/kevbuh/ribbit/tree/main/ribbit">more</a> 
+
+### Sneak Peek
+```python
+from ribbit.tensor import Tensor
+from ribbit.utils import Linear
+import ribbit.optim as optim
+
+class mnistMLP:
+  def __init__(self):
+    self.l1 = Tensor(Linear(784, 128))
+    self.l2 = Tensor(Linear(128, 10))
+
+  def forward(self, x):
+    return x.dot(self.l1).relu().dot(self.l2).logsoftmax()
+
+model = mnistMLP()
+optim = optim.SGD([model.l1, model.l2], lr=0.001)
+```
+
+# Bounties
+THERES LOT OF STUFF TO WORK ON! VISIT THE <a href="https://github.com/kevbuh/ribbit/blob/main/docs/bounties.md">BOUNTY SHOP</a>
+
+Pull requests will be merged if they:
+* increase simplicity
+* increase functionality
+* increase efficiency
+
+more info on <a href="https://github.com/kevbuh/ribbit/blob/main/docs/contributing.md">contributing</a>

froog-0.2.4/README.md

@@ -0,0 +1,63 @@
+# ribbit <img src="https://github.com/kevbuh/ribbit/actions/workflows/test.yml/badge.svg" alt="unit test badge" >
+<div align="center" >
+  <img src="https://raw.githubusercontent.com/kevbuh/ribbit/main/assets/froog.png" alt="froog the frog" height="200">
+  <br/>
+  ribbit: fast real-time optimization of gradients 
+  <br/>
+  a beautifully compact machine-learning library
+  <br/>
+  <a href="https://github.com/kevbuh/ribbit">homepage</a> | <a href="https://github.com/kevbuh/ribbit/tree/main/docs">documentation</a> | <a href="https://pypi.org/project/ribbit/">pip</a>
+  <br/>
+  <br/>
+</div>
+
+RIBBIT is a SUPER SIMPLE machine learning framework with the goal of creating tools with AI --> easily and efficiently.
+
+It's an end-to-end framework, encapsulating everything from ensemble trees to deep neural networks (still working on all that lol)
+
+# Installation
+```bash
+pip install ribbit
+```
+
+### Overview of Features
+- <a href="https://github.com/kevbuh/ribbit/blob/main/ribbit/tensor.py">Custom Tensors</a> 
+  - Backpropagation
+  - Automatic Differentiation (autograd)
+      - Forward and backward passes
+- <a href="https://github.com/kevbuh/ribbit/blob/main/ribbit/ops.py">ML Operations</a> 
+  - 2D Convolutions (im2col)
+  - Numerical gradient checking
+  - Acceleration methods (Adam)
+  - Avg & Max pooling
+- <a href="https://github.com/kevbuh/ribbit/blob/main/models/efficientnet.py">EfficientNet</a> inference
+- <a href="https://github.com/kevbuh/ribbit/blob/main/ribbit/ops_gpu.py">GPU Support</a> 
+- and a bunch <a href="https://github.com/kevbuh/ribbit/tree/main/ribbit">more</a> 
+
+### Sneak Peek
+```python
+from ribbit.tensor import Tensor
+from ribbit.utils import Linear
+import ribbit.optim as optim
+
+class mnistMLP:
+  def __init__(self):
+    self.l1 = Tensor(Linear(784, 128))
+    self.l2 = Tensor(Linear(128, 10))
+
+  def forward(self, x):
+    return x.dot(self.l1).relu().dot(self.l2).logsoftmax()
+
+model = mnistMLP()
+optim = optim.SGD([model.l1, model.l2], lr=0.001)
+```
+
+# Bounties
+THERES LOT OF STUFF TO WORK ON! VISIT THE <a href="https://github.com/kevbuh/ribbit/blob/main/docs/bounties.md">BOUNTY SHOP</a>
+
+Pull requests will be merged if they:
+* increase simplicity
+* increase functionality
+* increase efficiency
+
+more info on <a href="https://github.com/kevbuh/ribbit/blob/main/docs/contributing.md">contributing</a>

froog-0.2.4/froog.egg-info/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.1
+Name: froog
+Version: 0.2.4
+Summary: a beautifully simplistic ml framework
+Author: Kevin Buhler
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# ribbit <img src="https://github.com/kevbuh/ribbit/actions/workflows/test.yml/badge.svg" alt="unit test badge" >
+<div align="center" >
+  <img src="https://raw.githubusercontent.com/kevbuh/ribbit/main/assets/froog.png" alt="froog the frog" height="200">
+  <br/>
+  ribbit: fast real-time optimization of gradients 
+  <br/>
+  a beautifully compact machine-learning library
+  <br/>
+  <a href="https://github.com/kevbuh/ribbit">homepage</a> | <a href="https://github.com/kevbuh/ribbit/tree/main/docs">documentation</a> | <a href="https://pypi.org/project/ribbit/">pip</a>
+  <br/>
+  <br/>
+</div>
+
+RIBBIT is a SUPER SIMPLE machine learning framework with the goal of creating tools with AI --> easily and efficiently.
+
+It's an end-to-end framework, encapsulating everything from ensemble trees to deep neural networks (still working on all that lol)
+
+# Installation
+```bash
+pip install ribbit
+```
+
+### Overview of Features
+- <a href="https://github.com/kevbuh/ribbit/blob/main/ribbit/tensor.py">Custom Tensors</a> 
+  - Backpropagation
+  - Automatic Differentiation (autograd)
+      - Forward and backward passes
+- <a href="https://github.com/kevbuh/ribbit/blob/main/ribbit/ops.py">ML Operations</a> 
+  - 2D Convolutions (im2col)
+  - Numerical gradient checking
+  - Acceleration methods (Adam)
+  - Avg & Max pooling
+- <a href="https://github.com/kevbuh/ribbit/blob/main/models/efficientnet.py">EfficientNet</a> inference
+- <a href="https://github.com/kevbuh/ribbit/blob/main/ribbit/ops_gpu.py">GPU Support</a> 
+- and a bunch <a href="https://github.com/kevbuh/ribbit/tree/main/ribbit">more</a> 
+
+### Sneak Peek
+```python
+from ribbit.tensor import Tensor
+from ribbit.utils import Linear
+import ribbit.optim as optim
+
+class mnistMLP:
+  def __init__(self):
+    self.l1 = Tensor(Linear(784, 128))
+    self.l2 = Tensor(Linear(128, 10))
+
+  def forward(self, x):
+    return x.dot(self.l1).relu().dot(self.l2).logsoftmax()
+
+model = mnistMLP()
+optim = optim.SGD([model.l1, model.l2], lr=0.001)
+```
+
+# Bounties
+THERES LOT OF STUFF TO WORK ON! VISIT THE <a href="https://github.com/kevbuh/ribbit/blob/main/docs/bounties.md">BOUNTY SHOP</a>
+
+Pull requests will be merged if they:
+* increase simplicity
+* increase functionality
+* increase efficiency
+
+more info on <a href="https://github.com/kevbuh/ribbit/blob/main/docs/contributing.md">contributing</a>

{froog-0.2.2 → froog-0.2.4}/froog.egg-info/SOURCES.txt

@@ -1,21 +1,21 @@
 LICENSE
 README.md
 setup.py
-froog/__init__.py
-froog/gradcheck.py
-froog/nn.py
-froog/ops.py
-froog/ops_gpu.py
-froog/optim.py
-froog/tensor.py
-froog/utils.py
 froog.egg-info/PKG-INFO
 froog.egg-info/SOURCES.txt
 froog.egg-info/dependency_links.txt
 froog.egg-info/requires.txt
 froog.egg-info/top_level.txt
+ribbit/__init__.py
+ribbit/gradcheck.py
+ribbit/nn.py
+ribbit/ops.py
+ribbit/ops_gpu.py
+ribbit/optim.py
+ribbit/tensor.py
+ribbit/utils.py
 tests/test_conv_speed.py
-tests/test_nn.py
+tests/test_models.py
 tests/test_ops.py
 tests/test_optim.py
 tests/test_tensor.py

{froog-0.2.2 → froog-0.2.4}/froog.egg-info/requires.txt

@@ -1,2 +1,3 @@
 numpy
 requests
+matplotlib

froog-0.2.4/froog.egg-info/top_level.txt

@@ -0,0 +1 @@
+ribbit

froog-0.2.4/ribbit/__init__.py

@@ -0,0 +1,3 @@
+import ribbit.optim
+import ribbit.tensor
+import ribbit.utils

{froog-0.2.2/froog → froog-0.2.4/ribbit}/gradcheck.py

@@ -7,8 +7,8 @@
 # |___|    |___|  |_||_______||_______||_______|
 
 import numpy as np
-from froog.tensor import Tensor
-from froog.utils import mask_like
+from ribbit.tensor import Tensor
+from ribbit.utils import mask_like
 
 def jacobian(model, input):
   output = model(input)
@@ -30,7 +30,7 @@ def numerical_jacobian(model, input, eps = 1e-6):
 #     Computes :
 #         First-order partial derivatives using Finite-Difference Approximation with Central Difference Method (CDM)
 #     Params:
-#         model : A froog model
+#         model : A ribbit model
 #         input : An input
 #         eps   : Perturbation step
 #     Returns:
@@ -58,7 +58,7 @@ def gradcheck(model, input, eps = 1e-06, atol = 1e-5, rtol = 0.001):
   """
   Checks whether computed gradient is close to numerical approximation of the Jacobian
   Params:
-    model       : froog model   
+    model       : ribbit model   
     eps         : eps used to see if gradient is within tolerances
     atol        : absolute tolerance
     rtol        : relative tolerance 

{froog-0.2.2/froog → froog-0.2.4/ribbit}/nn.py

@@ -6,7 +6,7 @@
 # |   |    |   |  | ||       ||       ||   |_| |
 # |___|    |___|  |_||_______||_______||_______|
 
-from froog.tensor import Tensor
+from ribbit.tensor import Tensor
 
 def swish(x):
   return x.mul(x.sigmoid())
@@ -44,7 +44,7 @@ class BatchNorm2D:
     # TODO: need running_mean and running_var
     self.running_mean = Tensor.zeros(sz)
     self.running_var = Tensor.zeros(sz)
-    self.num_batches_tracked = Tensor.zeros(0)
+    self.num_batches_tracked = Tensor.zeros(1)
 
   def __call__(self, x):
     x = x.sub(self.running_mean.reshape(shape=[1, -1, 1, 1]))

{froog-0.2.2/froog → froog-0.2.4/ribbit}/ops.py

@@ -7,8 +7,8 @@
 # |___|    |___|  |_||_______||_______||_______|
 
 import numpy as np
-from froog.tensor import Function, register
-from froog.utils import im2col, col2im
+from ribbit.tensor import Function, register
+from ribbit.utils import im2col, col2im
 
 # *****************************************************
 #     ____  ___   _____ __________   ____  ____  _____

{froog-0.2.2/froog → froog-0.2.4/ribbit}/ops_gpu.py

@@ -19,6 +19,12 @@ def buffer_new(ctx, shape):
   res_g.dtype = np.float32
   return res_g
 
+def buffer_zeros(ctx, shape):
+  res_g = cl.Buffer(ctx.cl_ctx, cl.mem_flags.WRITE_ONLY | cl.mem_flags.COPY_HOST_PTR, hostbuf=np.zeros(shape))
+  res_g.shape = shape
+  res_g.dtype = np.float32
+  return res_g
+
 def buffer_like(ctx, x):
   return buffer_new(ctx, x.shape)
 
@@ -27,35 +33,40 @@ def clbuild(cl_ctx, prg):
   return cl.Program(cl_ctx, prg).build()
 
 def binary_op(ctx, code, x, y): 
+  if x.shape != y.shape:
+    raise Exception(f"binary op shape mismatch: {x.shape} != {y.shape}")
   ret = buffer_like(ctx, x)
   prg = clbuild(ctx.cl_ctx, """
-  __kernel void add(
+  __kernel void binop(
       __global const float *a_g, __global const float *b_g, __global float *res_g)
   {
     int gid = get_global_id(0);
-    """+code+"""
+    float a = a_g[gid];
+    float b = b_g[gid];
+    res_g[gid] = """+code+""";
   }
   """)
-  prg.add(ctx.cl_queue, [np.prod(ret.shape)], None, x, y, ret) # (queue, size, ???, arg1, arg2, dest)
+  prg.binop(ctx.cl_queue, [np.prod(ret.shape)], None, x, y, ret) # (queue, size, ???, arg1, arg2, dest)
   return ret
 
 def unary_op(ctx, code, x):
   ret = buffer_like(ctx, x)
   prg = clbuild(ctx.cl_ctx, """
-  __kernel void relu(
+  __kernel void unop(
       __global const float *a_g, __global float *res_g)
   {
     int gid = get_global_id(0);
-    """+code+"""
+    float a = a_g[gid];
+    res_g[gid] = """+code+"""
   }
   """)
-  prg.relu(ctx.cl_queue, [np.prod(ret.shape)], None, x, ret)
+  prg.unop(ctx.cl_queue, [np.prod(ret.shape)], None, x, ret)
   return ret
 
 class Add(Function):
   @staticmethod
   def forward(ctx, x, y):
-    return binary_op(ctx, 'res_g[gid] = a_g[gid] + b_g[gid];', x, y)
+    return binary_op(ctx, 'a+b', x, y)
 
   @staticmethod
   def backward(ctx, grad_output):
@@ -65,11 +76,11 @@ register('add', Add, gpu=True)
 class Sub(Function):
   @staticmethod
   def forward(ctx, x, y):
-    return binary_op(ctx, 'res_g[gid] = a_g[gid] - b_g[gid];', x, y)
+    return binary_op(ctx, 'a-b', x, y)
 
   @staticmethod
   def backward(ctx, grad_output):
-    not_grad_output = unary_op(ctx, 'res_g[gid] = -a_g[gid];', grad_output)
+    not_grad_output = unary_op(ctx, '-a', grad_output)
     return grad_output, not_grad_output
 register('sub', Sub, gpu=True)
 
@@ -78,36 +89,27 @@ class Mul(Function):
   def forward(ctx, x, y):
     ctx.save_for_backward(x, y)
 
-    # HACK
-    if y.shape == (1,):
-      return binary_op(ctx, 'res_g[gid] = a_g[gid] * b_g[0];', x, y)
-    elif x.shape == y.shape:
-      return binary_op(ctx, 'res_g[gid] = a_g[gid] * b_g[gid];', x, y)
-    else:
-      raise Exception("mismatched shapes %r %r" % (x.shape, y.shape))
-
-    return ret
+    return binary_op(ctx, 'a*b', x, y)
 
   @staticmethod
   def backward(ctx, grad_output):
     x,y = ctx.saved_tensors
-    return binary_op(ctx, 'res_g[gid] = a_g[gid] * b_g[gid];', y, grad_output),\
-           binary_op(ctx, 'res_g[gid] = a_g[gid] * b_g[gid];', x, grad_output)
+    return binary_op(ctx, 'a*b', y, grad_output), binary_op(ctx, 'a*b', x, grad_output)
 register('mul', Mul, gpu=True)
 
 class Pow(Function):
   @staticmethod
   def forward(ctx, x, y):
     ctx.save_for_backward(x, y)
-    return binary_op(ctx, 'res_g[gid] = pow(a_g[gid], b_g[gid]);', x, y)
+    return binary_op(ctx, 'pow(a,b)', x, y)
 
   @staticmethod
   def backward(ctx, grad_output):
     x,y = ctx.saved_tensors
-    gradx = binary_op(ctx, 'res_g[gid] = a_g[gid] * b_g[gid];', grad_output,
-                      binary_op(ctx, 'res_g[gid] = b_g[gid] * (pow((float)a_g[gid], (float)(b_g[gid]-1.0)));', x, y))
-    grady = binary_op(ctx, 'res_g[gid] = a_g[gid] * b_g[gid];', grad_output,
-                      binary_op(ctx, 'res_g[gid] = pow((float)a_g[gid], (float)b_g[gid]) * log(a_g[gid]);', x, y))
+    gradx = binary_op(ctx, 'a*b', grad_output,
+                      binary_op(ctx, 'b * (pow((float)a, (float)(b-1.0)));', x, y))
+    grady = binary_op(ctx, 'a*b', grad_output,
+                      binary_op(ctx, 'pow((float)a, (float)b) * log(a);', x, y))
     return gradx, grady
 register('pow', Pow, gpu=True)
 
@@ -133,7 +135,17 @@ class Sum(Function):
   @staticmethod
   def backward(ctx, grad_output):
     input, = ctx.saved_tensors
-    return binary_op(ctx, 'res_g[gid] = b_g[0];', input, grad_output)  # Quick hack for fill
+    ret = buffer_like(ctx, input)
+    prg = clbuild(ctx.cl_ctx, """
+    __kernel void fill(
+        __global const float *a_g, __global float *res_g)
+    {
+      int gid = get_global_id(0);
+      res_g[gid] = a_g[0];
+    }
+    """)
+    prg.fill(ctx.cl_queue, [np.prod(ret.shape)], None, grad_output, ret)
+    return ret
 register('sum', Sum, gpu=True)
 
 class Dot(Function):
@@ -210,7 +222,18 @@ class Reshape(Function):
   @staticmethod
   def forward(ctx, x, shape):
     ctx.save_for_backward(x.shape)
-    x.shape = shape
+    ss = list(shape)
+
+    # ???
+    tsum = 1
+    for s in ss:
+      if s != -1:
+        tsum *= s
+    for i,s in enumerate(ss):
+      if s == -1:
+        ss[i] = np.prod(x.shape) // tsum
+    assert np.prod(x.shape) == np.prod(ss)
+    x.shape = tuple(ss)
     return x
 
   @staticmethod
@@ -226,12 +249,12 @@ class ReLU(Function):
   @staticmethod
   def forward(ctx, input):
     ctx.save_for_backward(input)
-    return unary_op(ctx, 'res_g[gid] = max(a_g[gid], (float)0.);', input)
+    return unary_op(ctx, 'max(a, (float)0.);', input)
 
   @staticmethod
   def backward(ctx, grad_output):
     input, = ctx.saved_tensors
-    return binary_op(ctx, 'res_g[gid] = a_g[gid] * (b_g[gid] >= 0);', grad_output, input)
+    return binary_op(ctx, 'a * (b >= 0);', grad_output, input)
 register('relu', ReLU, gpu=True)
 
 class LogSoftmax(Function):
@@ -294,3 +317,117 @@ class LogSoftmax(Function):
     return grad_input
 register('logsoftmax', LogSoftmax, gpu=True)
 
+# ***** CONV OPS ********
+
+class Conv2D(Function):
+  @staticmethod
+  def forward(ctx, x, w, stride=1, groups=1):
+    if type(ctx.stride) == int:     # ctx stores function params
+      ctx.stride = (ctx.stride, ctx.stride)
+
+    cout, cin, H, W = w.shape
+    y_stride, x_stride = ctx.stride
+    bs,cin_,iy,ix = x.shape
+    oy,ox = (iy-(H-y_stride))//y_stride, (ix-(W-x_stride))//x_stride
+    
+    assert cin*ctx.groups == cin_
+    assert cout % ctx.groups == 0
+
+    rcout = cout//ctx.groups
+
+    # output buffer
+    ret = buffer_new(ctx, (bs, cout, oy, ox))
+    prg = clbuild(ctx.cl_ctx, """
+
+    __kernel void conv(__global const float *input, __global const float *weight, __global float *output,
+      int H, int W, int groups, int rcout, int cin, int oy, int ox, int iy, int ix, int ys, int xs) {
+
+      int B = get_global_id(0);  // range 0-bs
+      int Y = get_global_id(1);  // range 0-oy
+      int X = get_global_id(2);  // range 0-ox
+      int IY = Y*ys;
+      int IX = X*xs;
+      
+      // input  = (bs, groups, cin, iy, ix)
+      // weight = (groups, rcout, cin, H, W)
+      // output = (bs, groups, rcout, oy, ox)
+      for (int g = 0; g < groups; g++) {
+        for (int c = 0; c < rcout; c++) {
+          float acc = 0.0;
+          for (int ci = 0; ci < cin; ci++) {
+            for (int y = IY; y < IY+H; y++) {
+              for (int x = IX; x < IX+W; x++) {
+                acc += input[B*groups*cin*iy*ix + g*cin*iy*ix + ci*iy*ix + y*ix + x] * \
+                  weight[g*rcout*cin*H*W + c*cin*H*W + ci*H*W + (y-IY)*W + (x-IX)];
+              }
+            }
+          }
+          output[B*groups*rcout*oy*ox + g*rcout*oy*ox + c*oy*ox + Y*ox + X] = acc;
+        }
+      }
+    }
+    """)
+
+    prg.conv(ctx.cl_queue, [bs, oy, ox], None,
+      x, w, ret,
+      np.int32(H), np.int32(W),
+      np.int32(groups), np.int32(rcout), np.int32(cin),
+      np.int32(oy), np.int32(ox), 
+      np.int32(iy), np.int32(ix),
+      np.int32(y_stride), np.int32(x_stride)
+    )
+    return ret
+
+  @staticmethod
+  def backward(ctx, grad_output):
+    raise Exception("not implemented")
+
+register('conv2d', Conv2D, gpu=True)
+
+class Pad2D(Function):
+  @staticmethod
+  def forward(ctx, x, padding=None):
+    bs,cin,iy,ix = x.shape
+    oy,ox = iy+padding[0]+padding[1], ix+padding[2]+padding[3] # top, bottom, left, right
+    ret = buffer_zeros(ctx, (bs, cin, oy, ox))
+
+    prg = clbuild(ctx.cl_ctx, """
+    __kernel void pad2d(
+        __global const float *input, __global float *output,
+        int cin, int py, int px, int oy, int ox, int iy, int ix
+      )
+    {
+      int B = get_global_id(0);
+      int C = get_global_id(1);
+      int Y = get_global_id(2);
+      int iptr = B*cin*iy*ix + C*iy*ix + Y*ix;
+      int optr = B*cin*oy*ox + C*oy*ox + (Y+py)*ox + px;
+      for (int x = 0; x < ix; x++) {
+        output[optr+x] = input[iptr+x];
+      }
+    }
+    """)
+    prg.pad2d(ctx.cl_queue, [bs, cin, iy], None,
+        x, ret,
+        np.int32(cin), np.int32(padding[0]), np.int32(padding[2]),
+        np.int32(oy), np.int32(ox), np.int32(iy), np.int32(ix)
+      )
+    return ret
+
+  @staticmethod
+  def backward(ctx, grad_output):
+    raise Exception("write this")
+register('pad2d', Pad2D, gpu=True)
+
+class Sigmoid(Function):
+  @staticmethod
+  def forward(ctx, input):
+    ret = unary_op(ctx, '1./(1+exp(-a))', input)
+    ctx.save_for_backward(ret)
+    return ret
+
+  @staticmethod
+  def backward(ctx, grad_output):
+    ret, = ctx.saved_tensors
+    return binary_op(ctx, 'a * (b * (1 - b));', grad_output, ret)
+register('sigmoid', Sigmoid, gpu=True)

{froog-0.2.2/froog → froog-0.2.4/ribbit}/optim.py

@@ -7,7 +7,7 @@
 # |___|    |___|  |_||_______||_______||_______|
 
 import numpy as np
-from froog.tensor import Tensor, GPU
+from ribbit.tensor import Tensor, GPU
 
 class Optimizer:
   def __init__(self, params):

{froog-0.2.2/froog → froog-0.2.4/ribbit}/tensor.py

@@ -145,7 +145,7 @@ class Tensor:
       init_gpu()
       assert self.data.dtype == np.float32 # GPU only allows float32
       # hostbuf is the data buffer on host machine with the data to be copied to the OpenCL buffer
-      data = cl.Buffer(cl_ctx, cl.mem_flags.READ_ONLY | cl.mem_flags.COPY_HOST_PTR, hostbuf=self.data) # from pyopencl docs
+      data = cl.Buffer(cl_ctx, cl.mem_flags.READ_ONLY | cl.mem_flags.COPY_HOST_PTR, hostbuf=self.data.ravel()) # from pyopencl docs
       data.shape = self.shape
       data.dtype = self.data.dtype
       ret = Tensor(data)
@@ -232,6 +232,6 @@ def register(name, fxn, gpu=False):
     setattr(Tensor, "__%s__" % name, dispatch)
     setattr(Tensor, "__i%s__" % name, lambda self,x: self.assign(dispatch(self,x)))
 
-import froog.ops # this registers all the operations
+import ribbit.ops # this registers all the operations
 if GPU:
-  import froog.ops_gpu
+  import ribbit.ops_gpu

{froog-0.2.2/froog → froog-0.2.4/ribbit}/utils.py

@@ -7,6 +7,7 @@
 # |___|    |___|  |_||_______||_______||_______|
 
 import numpy as np
+import os
 from functools import lru_cache
 
 def Linear(*tensor_size):
@@ -17,7 +18,7 @@ def Linear(*tensor_size):
 def fetch(url):
   import requests, os, hashlib, tempfile
   fp = os.path.join(tempfile.gettempdir(), hashlib.md5(url.encode('utf-8')).hexdigest())
-  if os.path.isfile(fp):
+  if os.path.isfile(fp) and os.stat(fp).st_size > 0:
     print(f"opening cache from {url}...")
     with open(fp, "rb") as f:
       dat = f.read()
@@ -52,7 +53,6 @@ def get_im2col_index(oy, ox, cin, H, W):
   idx = idx_channel * OY * OX + idx_y * OX + idx_x
   return idx
 
-# TODO: whats this doing? 
 @lru_cache
 def rearrange_col2im_index(oy, ox, cin, H, W):
   idx = get_im2col_index(oy, ox, cin, H, W)