froog 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

froog/utils.py

@@ -9,8 +9,9 @@
 import numpy as np
 from functools import lru_cache
 import pathlib, hashlib, os, tempfile, urllib
+from typing import Tuple
 
-def fetch(url):
+def fetch(url: str) -> pathlib.Path:
   if url.startswith(("/", ".")): return pathlib.Path(url)
   else: fp = pathlib.Path("_cache_dir") / "froog" / "downloads" / (hashlib.md5(url.encode('utf-8')).hexdigest())
   if not fp.is_file():
@@ -25,7 +26,7 @@ def fetch(url):
         pathlib.Path(f.name).rename(fp)
   return fp
 
-def fetch_mnist():
+def fetch_mnist() -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
   import gzip
   parse = lambda file: np.frombuffer(gzip.open(file).read(), dtype=np.uint8).copy()
   BASE_URL = "https://storage.googleapis.com/cvdf-datasets/mnist/"
@@ -35,13 +36,13 @@ def fetch_mnist():
   Y_test = parse(fetch(f"{BASE_URL}t10k-labels-idx1-ubyte.gz"))[8:].astype(np.int8)
   return X_train, Y_train, X_test, Y_test
 
-def mask_like(like, mask_inx, mask_value=1.0):
+def mask_like(like: np.ndarray, mask_inx: np.ndarray, mask_value: float = 1.0) -> np.ndarray:
   mask = np.zeros_like(like).reshape(-1) # flatten
   mask[mask_inx] = mask_value            # fill 
   return mask.reshape(like.shape)
 
 @lru_cache
-def get_im2col_index(oy, ox, cin, H, W):
+def get_im2col_index(oy: int, ox: int, cin: int, H: int, W: int) -> np.ndarray:
   idx_channel = np.tile(np.arange(cin).repeat(H*W), oy*ox)
   idx_y = np.tile(np.arange(H).repeat(W), oy*ox*cin) + np.arange(oy).repeat(ox*cin*H*W)
   idx_x = np.tile(np.arange(W), oy*ox*cin*H) + np.tile(np.arange(ox), oy).repeat(cin*H*W)
@@ -50,7 +51,7 @@ def get_im2col_index(oy, ox, cin, H, W):
   return idx
 
 @lru_cache
-def rearrange_col2im_index(oy, ox, cin, H, W):
+def rearrange_col2im_index(oy: int, ox: int, cin: int, H: int, W: int) -> np.ndarray:
   idx = get_im2col_index(oy, ox, cin, H, W)
   r_idx = np.zeros((np.max(idx)+1, H*W), dtype=idx.dtype)-1
   for i,x in enumerate(idx):
@@ -61,7 +62,7 @@ def rearrange_col2im_index(oy, ox, cin, H, W):
   return r_idx
 
 # im2col convolution helpers
-def im2col(x, H, W):
+def im2col(x: np.ndarray, H: int, W: int) -> np.ndarray:
   bs, cin, oy, ox = x.shape[0], x.shape[1], x.shape[2]-(H-1), x.shape[3]-(W-1)
   idx = get_im2col_index(oy, ox, cin, H, W)
   tx = x.reshape(bs, -1)[:, idx]
@@ -71,7 +72,7 @@ def im2col(x, H, W):
   tx = tx.ravel()
   return tx.reshape(-1, cin*W*H)
 
-def col2im(tx, H, W, OY, OX):
+def col2im(tx: np.ndarray, H: int, W: int, OY: int, OX: int) -> np.ndarray:
   oy, ox = OY-(H-1), OX-(W-1)
   bs = tx.shape[0] // (oy * ox)
   channels_in = tx.shape[1] // (H * W)

froog-0.5.0.dist-info/METADATA

@@ -0,0 +1,205 @@
+Metadata-Version: 2.1
+Name: froog
+Version: 0.5.0
+Summary: tensor library with opencl and metal support
+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
+Requires-Dist: numpy
+Requires-Dist: requests
+Requires-Dist: matplotlib
+
+# froog <img src="https://github.com/kevbuh/froog/actions/workflows/test.yml/badge.svg" alt="unit test badge" > <img src="https://static.pepy.tech/badge/froog" alt="num downloads badge">
+<div align="center" >
+  <img src="https://raw.githubusercontent.com/kevbuh/froog/main/assets/froog.png" alt="froog the frog" height="200">
+  <br/>
+  froog: fast real-time optimization of gradients 
+  <br/>
+  a beautifully compact tensor library
+  <br/>
+  <a href="https://github.com/kevbuh/froog">homepage</a> | <a href="https://github.com/kevbuh/froog/tree/main/DOCS.md">documentation</a> | <a href="https://pypi.org/project/froog/">pip</a>
+  <br/>
+  <br/>
+</div>
+
+```froog``` is an easy-to-read tensor library (<a href="https://www.pepy.tech/projects/froog">25k pip installs!</a>) with OpenCL support for GPU acceleration. Inspired by pytorch, tinygrad, and micrograd.
+
+# Installation
+```bash
+pip install froog
+```
+
+# Features
+- <a href="https://github.com/kevbuh/froog/blob/main/froog/tensor.py">Custom Tensors</a> 
+  - Backpropagation
+  - Automatic Differentiation (autograd)
+      - Forward and backward passes
+- <a href="https://github.com/kevbuh/froog/blob/main/froog/ops.py">ML Operations</a> 
+  - 2D Convolutions (im2col)
+  - Numerical gradient checking
+  - Acceleration methods (Adam)
+  - Avg & Max pooling
+- <a href="https://github.com/kevbuh/froog/blob/main/models/efficientnet.py">EfficientNet</a> inference
+- <a href="https://github.com/kevbuh/froog/blob/main/froog/gpu/ops_gpu.py">GPU Support</a> 
+- <a href="https://github.com/kevbuh/froog/blob/main/docs/env.md">Configuration via Environment Variables</a>
+- and a bunch <a href="https://github.com/kevbuh/froog/tree/main/froog">more</a> 
+
+# Example
+
+Here's how you set up a simple multilayer perceptron for classification on MNIST. Looks pretty similar to pytorch, right?
+
+```python
+from froog.tensor import Tensor
+from froog.nn import Linear
+import froog.optim as optim
+
+class mnistMLP:
+  def __init__(self):
+    self.l1 = Tensor(Linear(784, 128)) # layer 1
+    self.l2 = Tensor(Linear(128, 10))  # layer 2
+
+  def forward(self, x):
+    # forward pass through both layers and softmax for output probabilities
+    return x.dot(self.l1).relu().dot(self.l2).logsoftmax() 
+
+model = mnistMLP() # create model
+optim = optim.SGD([model.l1, model.l2], lr=0.001) # stochastic gradient descent optimizer
+```
+
+# GPU Support
+
+Device management is handled transparently and will automatically select one of ```[METAL, OPENCL, CPU]```. To use the GPU:
+
+```python
+from froog.tensor import Tensor
+from froog import get_device
+# Check if GPU is available
+has_gpu = get_device() is not None and get_device().name != "CPU"
+# Create a tensor
+x = Tensor([1, 2, 3])
+# Push to GPU if available
+if has_gpu: x = x.to_gpu()
+# Operations run on GPU automatically
+y = x + x
+z = y * y
+# Bring back to CPU when needed
+result = z.to_cpu()
+print(result.data)
+```
+
+You can also check what devices are available:
+
+```python
+from froog import get_available_devices
+available_devices = get_available_devices()
+print(f"Available devices: {available_devices}")
+```
+
+Or set a specific device:
+
+```python
+from froog import set_device
+set_device("METAL")  # or "OPENCL"
+```
+
+# EfficientNet in froog!
+
+<img src="assets/efficientnet_pug.png" alt="pug" height="300">
+
+We have an implementation of [EfficientNet v2](https://arxiv.org/abs/2104.00298) built entirely in ```froog``` using the official PyTorch weights! Run inference with:
+
+```bash
+python3 models/efficientnet.py <https://optional_image_url>
+
+***********output*************
+inference 4.34 s
+
+imagenet class: 254
+prediction    : pug, pug-dog
+probability   : 0.8902361
+******************************
+```
+
+I would recommend checking out the <a href="https://github.com/kevbuh/froog/blob/main/models/efficientnet.py">code</a>, it's highly documented and pretty cool.
+
+# Contributing
+<!-- THERES LOT OF STUFF TO WORK ON! VISIT THE <a href="https://github.com/kevbuh/froog/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/froog/blob/main/docs/contributing.md">contributing</a>. Make sure to run ```python -m pytest``` before creating a PR.
+
+# API
+
+## Basic Math Operations
+- ```.add(y)``` - Addition with y
+- ```.sub(y)``` - Subtraction with y
+- ```.mul(y)``` - Multiplication with y
+- ```.div(y)``` - Division by y
+- ```.pow(y)``` - Power function (raise to power y)
+- ```.sum()``` - Sum all elements
+- ```.mean()``` - Mean of all elements
+- ```.sqrt()``` - Square root
+
+## Linear Algebra Operations
+- ```.dot(y)``` - Matrix multiplication with y
+- ```.matmul(y)``` - Alias for dot
+
+## Neural Network Operations
+- ```.relu()``` - Rectified Linear Unit activation
+- ```.sigmoid()``` - Sigmoid activation
+- ```.dropout(p=0.5, training=True)``` - Dropout regularization
+- ```.logsoftmax()``` - Log softmax function
+- ```.swish()``` - Swish activation function (x * sigmoid(x))
+- ```.conv2d(w, stride=1, groups=1)``` - 2D convolution
+- ```.im2col2dconv(w)``` - Image to column for convolution
+
+## Pooling Operations
+- ```.max_pool2d(kernel_size=(2,2))``` - 2D max pooling
+- ```.avg_pool2d(kernel_size=(2,2))``` - 2D average pooling
+
+## Tensor Manipulation
+- ```.reshape(*shape)``` - Change tensor shape
+- ```.view(*shape)``` - Alternative to reshape
+- ```.pad2d(padding=None)``` - Pad 2D tensors
+- ```.flatten()``` - Returns a flattened 1D copy of the tensor
+- ```.unsqueeze(dim)``` - Add dimension of size 1 at specified position
+- ```.squeeze(dim=None)``` - Remove dimensions of size 1
+- ```.detach()``` - Returns a tensor detached from computation graph
+- ```.assign(x)``` - Assign values from tensor x to this tensor
+
+## Tensor Properties
+- ```.shape``` - The shape of the tensor as a tuple
+- ```.size``` - Total number of elements in the tensor
+- ```.ndim``` - Number of dimensions (rank) of the tensor
+- ```.transpose``` - Transpose of the tensor
+- ```.dtype``` - Data type of the tensor
+- ```.is_gpu``` - Whether tensor is on GPU
+- ```.grad``` - Gradient of tensor with respect to some scalar value
+- ```.data``` - Underlying NumPy array (or GPU buffer)
+
+## Device Management
+- ```.to_cpu()``` - Moves tensor to CPU
+- ```.to_gpu()``` - Moves tensor to GPU 
+- ```.gpu_()``` - In-place GPU conversion (modifies tensor)
+
+## Data Type Conversion
+- ```.to_float()``` - Converts tensor to float32 data type
+- ```.to_int()``` - Converts tensor to int32 data type
+- ```.to_bool()``` - Converts tensor to boolean data type
+
+## Autograd Operations
+- ```.backward(allow_fill=True)``` - Performs backpropagation
+
+## Tensor Creation Methods
+- ```Tensor.zeros(*shape)``` - Create tensor of zeros
+- ```Tensor.ones(*shape)``` - Create tensor of ones
+- ```Tensor.randn(*shape)``` - Create tensor with random normal values
+- ```Tensor.eye(dim)``` - Create identity matrix
+- ```Tensor.arange(start, stop=None, step=1)``` - Create tensor with evenly spaced values

froog-0.5.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+froog/__init__.py,sha256=kPFrHYPINIUmboWdWHWziYU7FRZhWCzrMjHKvusfvh0,1004
+froog/gradient.py,sha256=QeSPpgMSOOSZnVghwYIvTtt1HVVsrc4eDr73uXFkE-M,2626
+froog/ops.py,sha256=6CJWxZi9ksSVC_AWrXRBz_ndXC_b7lC206AbeaNYsdc,26241
+froog/optim.py,sha256=rkibUce0rG5O1O4fLsNuS54fd3fzdjQarAyTqK61-1I,5443
+froog/tensor.py,sha256=jD8rspVMFI__sFMAeKEu_hVhhnfvtgc92oAkNJVKEJg,9688
+froog/utils.py,sha256=SUXMWOka-yJmib1jeC6KgHI_hOtSzgrakiRA0tCk4vc,3657
+froog-0.5.0.dist-info/METADATA,sha256=8mSdbDlPXWl3ZzGTtPgTOGM0rwZ7zNlE-hOs1gt4s2c,7342
+froog-0.5.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+froog-0.5.0.dist-info/top_level.txt,sha256=XPz35C_JWu20LlsVxIMdMZn8DD58Ak78LwgWFBGYZwY,6
+froog-0.5.0.dist-info/RECORD,,

froog/nn.py

@@ -1,60 +0,0 @@
-#  _______  ______    _______  _______  _______ 
-# |       ||    _ |  |       ||       ||       |
-# |    ___||   | ||  |   _   ||   _   ||    ___|
-# |   |___ |   |_||_ |  | |  ||  | |  ||   | __ 
-# |    ___||    __  ||  |_|  ||  |_|  ||   ||  |
-# |   |    |   |  | ||       ||       ||   |_| |
-# |___|    |___|  |_||_______||_______||_______|
-
-from froog.tensor import Tensor
-import numpy as np
-
-def Linear(*x):
-  # random Glorot initialization
-  ret = np.random.uniform(-1., 1., size=x)/np.sqrt(np.prod(x))
-  return ret.astype(np.float32)
-
-def swish(x):
-  return x.mul(x.sigmoid())
-
-# *************************************
-#     _   ___   __   ____  ____  _____
-#    / | / / | / /  / __ \/ __ \/ ___/
-#   /  |/ /  |/ /  / / / / /_/ /\__ \ 
-#  / /|  / /|  /  / /_/ / ____/___/ / 
-# /_/ |_/_/ |_/   \____/_/    /____/  
-#
-# ************* nn ops ************   
-
-class BatchNorm2D:
-  """
-  __call__ follows the formula from the link below
-  pytorch version: https://pytorch.org/docs/stable/generated/torch.nn.BatchNorm2d.html
-
-  self.weight       = γ
-  self.bias         = β
-  self.running_mean = E[x] 
-  self.running_var  = Var[x]
-
-  the reshaping step ensures that each channel of the input has its 
-  own separate set of parameters (mean, variance, weight, and bias)
-
-  self.running_mean has shape [num_channels].
-  self.running_mean.reshape(shape=[1, -1, 1, 1]) reshapes it to [1, num_channels, 1, 1]
-  """
-  def __init__(self, sz, eps=0.001):
-    self.eps = eps
-    self.weight = Tensor.zeros(sz)
-    self.bias = Tensor.zeros(sz)
-
-    # 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(1)
-
-  def __call__(self, x):
-    x = x.sub(self.running_mean.reshape(shape=[1, -1, 1, 1]))
-    x = x.mul(self.weight.reshape(shape=[1, -1, 1, 1]))
-    x = x.div(self.running_var.add(Tensor([self.eps], gpu=x.gpu)).reshape(shape=[1, -1, 1, 1]).sqrt())
-    x = x.add(self.bias.reshape(shape=[1, -1, 1, 1]))
-    return x