rb-deeplearning-lib 0.0.2__py3-none-any.whl → 0.1.1__py3-none-any.whl

rb_deeplearning_lib/__init__.py

@@ -1,3 +1,4 @@
-import autogradient
-import sequence
-import neural_net
+import autogradient
+import sequence
+import neural_net
+import optimizer

rb_deeplearning_lib/autogradient.py

@@ -1,275 +1,275 @@
-import numpy as np
-class Values:
-  def __init__(self, vals, grads = True):
-    self.vals = np.array(vals)
-    self._backward = lambda: None
-    self.grad = np.zeros_like(vals)
-    self.grad_flag = grads
-
-  #Gemini code that handles wierd broadcasting errors
-  @staticmethod
-  def _broadcast_grad(grad_from_output, original_shape):
-    """
-    Adjusts the gradient by summing over broadcasted dimensions to match the original shape.
-    Assumes `grad_from_output` has the shape of the broadcasted result.
-    `original_shape` is the shape of the tensor *before* broadcasting.
-    """
-
-    if grad_from_output.shape == original_shape:
-        return grad_from_output
-
-    # If original was a scalar, sum all dimensions of the gradient
-    if original_shape == (): # scalar
-        return np.sum(grad_from_output)
-
-    # Identify axes where original_shape has size 1 and grad_from_output has size > 1
-    axes_to_sum = []
-
-    # Handle cases where original_shape might have fewer dimensions than grad_from_output
-    # e.g., (D,) broadcast to (N, D). original_shape is padded implicitly with 1s on the left.
-    diff_ndim = grad_from_output.ndim - len(original_shape)
-    padded_original_shape = (1,) * diff_ndim + original_shape
-
-    for i in range(grad_from_output.ndim):
-        if padded_original_shape[i] == 1 and grad_from_output.shape[i] > 1:
-            axes_to_sum.append(i)
-
-    if axes_to_sum:
-        return np.sum(grad_from_output, axis=tuple(axes_to_sum), keepdims=True)
-
-    return grad_from_output # No broadcasting to sum over, or complex broadcasting not handled by this simple logic.
-
-  def __repr__(self):
-    return "vals: " + self.vals.__repr__() + "\ngrads: "+ self.grad.__repr__()
-
-  def __add__(self, other):
-    other = other if isinstance(other, Values) else Values(other)
-
-    out = Values(self.vals + other.vals)
-    def backward():
-      if self.grad_flag:
-        self_grad_to_add = Values._broadcast_grad(out.grad, self.vals.shape)
-        self.grad = self.grad + self_grad_to_add
-        self._backward()
-      if other.grad_flag:
-        other_grad_to_add = Values._broadcast_grad(out.grad, other.vals.shape)
-        other.grad = other.grad + other_grad_to_add
-        other._backward()
-
-    out._backward = backward
-    return out
-  def __radd__(self, other):
-    return self + other
-
-  def __neg__(self):
-    return self * -1
-
-  def __sub__(self, other):
-    return self + (-other)
-
-  def __rsub__(self, other):
-    return other + (-self)
-
-  def __mul__(self, other):
-    other = other if isinstance(other, Values) else Values(other)
-
-    out = Values(self.vals * other.vals)
-    def backward():
-      if self.grad_flag:
-        # Gradient for self is `other.vals * out.grad`
-        grad_term_for_self = other.vals * out.grad
-        self.grad =self.grad + Values._broadcast_grad(grad_term_for_self, self.vals.shape)
-      if other.grad_flag:
-        # Gradient for other is `self.vals * out.grad`
-        grad_term_for_other = self.vals * out.grad
-        other.grad =other.grad + Values._broadcast_grad(grad_term_for_other, other.vals.shape)
-        other._backward()
-      if self.grad_flag:
-        self._backward()
-
-    out._backward = backward
-    return out
-
-  def __rmul__(self, other): #other * self
-    return self * other
-
-  def __truediv__(self, other):
-    other = other if isinstance(other, Values) else Values(other)
-
-    out = Values(self.vals / other.vals)
-    def backward():
-      if self.grad_flag:
-        grad_term_for_self = out.grad / other.vals
-        self.grad = self.grad + Values._broadcast_grad(grad_term_for_self, self.vals.shape)
-      if other.grad_flag:
-        grad_term_for_other = -out.grad * self.vals / (other.vals**2)
-        other.grad = other.grad + Values._broadcast_grad(grad_term_for_other, other.vals.shape)
-        other._backward()
-      if self.grad_flag:
-        self._backward()
-    out._backward = backward
-    return out
-
-  def __rtruediv__(self, other):
-    return Values(other) / self
-
-  def __matmul__(self, other):
-    other = other if isinstance(other, Values) else Values(other)
-    out = Values(self.vals @ other.vals)
-    def backward():
-      if self.grad_flag:
-        # out.grad @ other.vals.T matches self.vals shape, so no broadcast_grad needed here.
-        self.grad = self.grad + out.grad @ other.vals.T
-      if other.grad_flag:
-        # self.vals.T @ out.grad matches other.vals shape, so no broadcast_grad needed here.
-        other.grad = other.grad + self.vals.T @ out.grad
-        other._backward()
-      if self.grad_flag:
-        self._backward()
-    out._backward = backward
-    return out
-
-  def __rmatmul__(self, other):
-    return Values(other) @ self
-
-  def exp(self):
-    out = Values(np.exp(self.vals))
-    def backward():
-      if self.grad_flag:
-        grad_term = out.vals * out.grad
-        self.grad = self.grad + Values._broadcast_grad(grad_term, self.vals.shape)
-        self._backward()
-    out._backward = backward
-    return out
-
-  def __pow__(self, other):
-    assert isinstance(other, (int, float)), "only supporting int/float powers for now"
-    out = Values(self.vals**other)
-    def backward():
-      if self.grad_flag:
-        grad_term = other * (self.vals**(other - 1)) * out.grad
-        self.grad =self.grad + Values._broadcast_grad(grad_term, self.vals.shape)
-        self._backward()
-    out._backward = backward
-    return out
-
-  def log(self):
-    out = Values(np.log(self.vals))
-    def backward():
-      if self.grad_flag:
-        grad_term = self.vals**-1 *out.grad
-        self.grad = self.grad + Values._broadcast_grad(grad_term, self.vals.shape)
-        self._backward()
-    out._backward = backward
-    return out
-
-  def relu(self):
-    out = Values(np.maximum(0,self.vals))
-    def backward():
-      if self.grad_flag:
-        grad_term = out.grad * (self.vals > 0)
-        self.grad = self.grad + Values._broadcast_grad(grad_term, self.vals.shape)
-        self._backward()
-    out._backward = backward
-    return out
-
-  def abs(self):
-    out = Values(np.abs(self.vals))
-    def backward():
-      if self.grad_flag:
-        # Gradient of abs(x) is np.sign(x)
-        grad_term = out.grad * np.sign(self.vals)
-        self.grad = self.grad + Values._broadcast_grad(grad_term, self.vals.shape)
-        self._backward()
-    out._backward = backward
-    return out
-
-  def sum(self, axis=None, keepdims=False):
-    out_vals = np.sum(self.vals, axis=axis, keepdims=keepdims)
-    out = Values(out_vals)
-    saved_axis = axis
-    saved_keepdims = keepdims
-    original_shape = self.vals.shape
-
-    def backward():
-        if self.grad_flag:
-            grad_to_distribute = out.grad
-
-            if saved_axis is not None and not saved_keepdims:
-                new_shape = list(original_shape)
-                if isinstance(saved_axis, int):
-                    new_shape[saved_axis] = 1
-                else:
-                    for ax in saved_axis:
-                        new_shape[ax] = 1
-                grad_to_distribute = grad_to_distribute.reshape(new_shape)
-
-            self.grad = self.grad + Values._broadcast_grad(grad_to_distribute, self.vals.shape)
-            self._backward()
-    out._backward = backward
-    return out
-
-  def softmax(self, axis=-1):
-    max_val = self.vals.max(axis=axis, keepdims=True)
-    exp_vals = (self - max_val).exp()
-    sum_exp_vals = exp_vals.sum(axis=axis, keepdims=True)
-    out = Values(exp_vals / sum_exp_vals)
-
-    def backward():
-        if self.grad_flag:
-            sum_grad_times_out = (out.vals * out.grad).sum(axis=axis, keepdims=True)
-            grad_term = out.vals * (out.grad - sum_grad_times_out)
-            self.grad = self.grad + Values._broadcast_grad(grad_term, self.vals.shape)
-            self._backward()
-    out._backward = backward
-    return out
-
-  def mean(self):
-    out = Values(np.mean(self.vals))
-    def backward():
-      if self.grad_flag:
-        # For mean, out.grad is a scalar. Adding a scalar to self.grad (an array)
-        # implicitly broadcasts the scalar across all elements, which is the correct behavior
-        # for the gradient of a mean operation.
-        self.grad = self.grad + (out.grad / self.vals.size)
-        self._backward()
-    out._backward = backward
-    return out
-
-  def __call__(self):
-    return self
-
-  def __getitem__(self, item):
-    out = Values(self.vals[item])
-    saved_item = item
-    def backward():
-        if self.grad_flag:
-            temp_grad = np.zeros_like(self.vals)
-            temp_grad[saved_item] = out.grad
-            self._backward()
-    out._backward = backward
-    return out
-
-  def backward(self):
-    self.grad = np.ones_like(self.vals)
-    self._backward()
-
-  def __getattr__(self, name):
-    if name == "_":
-      return self
-    if name == "T" or name == "transpose":
-      out = Values(self.vals.T)
-      def backward():
-        if self.grad_flag:
-          # out.grad is the shape of out.vals (transposed vals), so out.grad.T is the shape of self.vals.
-          # No broadcast_grad needed here.
-          self.grad = self.grad + out.grad.T
-          self._backward()
-        return
-      out._backward = backward
-      return out
-
-    if hasattr(self.vals, name) and not callable(getattr(self.vals, name)):
-      return getattr(self.vals, name)
-
-    raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}' or attribute is not supported for automatic differentiation.")
+import numpy as np
+class Values:
+  def __init__(self, vals, grads = True):
+    self.vals = np.array(vals)
+    self._backward = lambda: None
+    self.grad = np.zeros_like(vals)
+    self.grad_flag = grads
+
+  #Gemini code that handles wierd broadcasting errors
+  @staticmethod
+  def _broadcast_grad(grad_from_output, original_shape):
+    """
+    Adjusts the gradient by summing over broadcasted dimensions to match the original shape.
+    Assumes `grad_from_output` has the shape of the broadcasted result.
+    `original_shape` is the shape of the tensor *before* broadcasting.
+    """
+
+    if grad_from_output.shape == original_shape:
+        return grad_from_output
+
+    # If original was a scalar, sum all dimensions of the gradient
+    if original_shape == (): # scalar
+        return np.sum(grad_from_output)
+
+    # Identify axes where original_shape has size 1 and grad_from_output has size > 1
+    axes_to_sum = []
+
+    # Handle cases where original_shape might have fewer dimensions than grad_from_output
+    # e.g., (D,) broadcast to (N, D). original_shape is padded implicitly with 1s on the left.
+    diff_ndim = grad_from_output.ndim - len(original_shape)
+    padded_original_shape = (1,) * diff_ndim + original_shape
+
+    for i in range(grad_from_output.ndim):
+        if padded_original_shape[i] == 1 and grad_from_output.shape[i] > 1:
+            axes_to_sum.append(i)
+
+    if axes_to_sum:
+        return np.sum(grad_from_output, axis=tuple(axes_to_sum), keepdims=True)
+
+    return grad_from_output # No broadcasting to sum over, or complex broadcasting not handled by this simple logic.
+
+  def __repr__(self):
+    return "vals: " + self.vals.__repr__() + "\ngrads: "+ self.grad.__repr__()
+
+  def __add__(self, other):
+    other = other if isinstance(other, Values) else Values(other)
+
+    out = Values(self.vals + other.vals)
+    def backward():
+      if self.grad_flag:
+        self_grad_to_add = Values._broadcast_grad(out.grad, self.vals.shape)
+        self.grad = self.grad + self_grad_to_add
+        self._backward()
+      if other.grad_flag:
+        other_grad_to_add = Values._broadcast_grad(out.grad, other.vals.shape)
+        other.grad = other.grad + other_grad_to_add
+        other._backward()
+
+    out._backward = backward
+    return out
+  def __radd__(self, other):
+    return self + other
+
+  def __neg__(self):
+    return self * -1
+
+  def __sub__(self, other):
+    return self + (-other)
+
+  def __rsub__(self, other):
+    return other + (-self)
+
+  def __mul__(self, other):
+    other = other if isinstance(other, Values) else Values(other)
+
+    out = Values(self.vals * other.vals)
+    def backward():
+      if self.grad_flag:
+        # Gradient for self is `other.vals * out.grad`
+        grad_term_for_self = other.vals * out.grad
+        self.grad =self.grad + Values._broadcast_grad(grad_term_for_self, self.vals.shape)
+      if other.grad_flag:
+        # Gradient for other is `self.vals * out.grad`
+        grad_term_for_other = self.vals * out.grad
+        other.grad =other.grad + Values._broadcast_grad(grad_term_for_other, other.vals.shape)
+        other._backward()
+      if self.grad_flag:
+        self._backward()
+
+    out._backward = backward
+    return out
+
+  def __rmul__(self, other): #other * self
+    return self * other
+
+  def __truediv__(self, other):
+    other = other if isinstance(other, Values) else Values(other)
+
+    out = Values(self.vals / other.vals)
+    def backward():
+      if self.grad_flag:
+        grad_term_for_self = out.grad / other.vals
+        self.grad = self.grad + Values._broadcast_grad(grad_term_for_self, self.vals.shape)
+      if other.grad_flag:
+        grad_term_for_other = -out.grad * self.vals / (other.vals**2)
+        other.grad = other.grad + Values._broadcast_grad(grad_term_for_other, other.vals.shape)
+        other._backward()
+      if self.grad_flag:
+        self._backward()
+    out._backward = backward
+    return out
+
+  def __rtruediv__(self, other):
+    return Values(other) / self
+
+  def __matmul__(self, other):
+    other = other if isinstance(other, Values) else Values(other)
+    out = Values(self.vals @ other.vals)
+    def backward():
+      if self.grad_flag:
+        # out.grad @ other.vals.T matches self.vals shape, so no broadcast_grad needed here.
+        self.grad = self.grad + out.grad @ other.vals.T
+      if other.grad_flag:
+        # self.vals.T @ out.grad matches other.vals shape, so no broadcast_grad needed here.
+        other.grad = other.grad + self.vals.T @ out.grad
+        other._backward()
+      if self.grad_flag:
+        self._backward()
+    out._backward = backward
+    return out
+
+  def __rmatmul__(self, other):
+    return Values(other) @ self
+
+  def exp(self):
+    out = Values(np.exp(self.vals))
+    def backward():
+      if self.grad_flag:
+        grad_term = out.vals * out.grad
+        self.grad = self.grad + Values._broadcast_grad(grad_term, self.vals.shape)
+        self._backward()
+    out._backward = backward
+    return out
+
+  def __pow__(self, other):
+    assert isinstance(other, (int, float)), "only supporting int/float powers for now"
+    out = Values(self.vals**other)
+    def backward():
+      if self.grad_flag:
+        grad_term = other * (self.vals**(other - 1)) * out.grad
+        self.grad =self.grad + Values._broadcast_grad(grad_term, self.vals.shape)
+        self._backward()
+    out._backward = backward
+    return out
+
+  def log(self):
+    out = Values(np.log(self.vals))
+    def backward():
+      if self.grad_flag:
+        grad_term = self.vals**-1 *out.grad
+        self.grad = self.grad + Values._broadcast_grad(grad_term, self.vals.shape)
+        self._backward()
+    out._backward = backward
+    return out
+
+  def relu(self):
+    out = Values(np.maximum(0,self.vals))
+    def backward():
+      if self.grad_flag:
+        grad_term = out.grad * (self.vals > 0)
+        self.grad = self.grad + Values._broadcast_grad(grad_term, self.vals.shape)
+        self._backward()
+    out._backward = backward
+    return out
+
+  def abs(self):
+    out = Values(np.abs(self.vals))
+    def backward():
+      if self.grad_flag:
+        # Gradient of abs(x) is np.sign(x)
+        grad_term = out.grad * np.sign(self.vals)
+        self.grad = self.grad + Values._broadcast_grad(grad_term, self.vals.shape)
+        self._backward()
+    out._backward = backward
+    return out
+
+  def sum(self, axis=None, keepdims=False):
+    out_vals = np.sum(self.vals, axis=axis, keepdims=keepdims)
+    out = Values(out_vals)
+    saved_axis = axis
+    saved_keepdims = keepdims
+    original_shape = self.vals.shape
+
+    def backward():
+        if self.grad_flag:
+            grad_to_distribute = out.grad
+
+            if saved_axis is not None and not saved_keepdims:
+                new_shape = list(original_shape)
+                if isinstance(saved_axis, int):
+                    new_shape[saved_axis] = 1
+                else:
+                    for ax in saved_axis:
+                        new_shape[ax] = 1
+                grad_to_distribute = grad_to_distribute.reshape(new_shape)
+
+            self.grad = self.grad + Values._broadcast_grad(grad_to_distribute, self.vals.shape)
+            self._backward()
+    out._backward = backward
+    return out
+
+  def softmax(self, axis=-1):
+    max_val = self.vals.max(axis=axis, keepdims=True)
+    exp_vals = (self - max_val).exp()
+    sum_exp_vals = exp_vals.sum(axis=axis, keepdims=True)
+    out = Values(exp_vals / sum_exp_vals)
+
+    def backward():
+        if self.grad_flag:
+            sum_grad_times_out = (out.vals * out.grad).sum(axis=axis, keepdims=True)
+            grad_term = out.vals * (out.grad - sum_grad_times_out)
+            self.grad = self.grad + Values._broadcast_grad(grad_term, self.vals.shape)
+            self._backward()
+    out._backward = backward
+    return out
+
+  def mean(self):
+    out = Values(np.mean(self.vals))
+    def backward():
+      if self.grad_flag:
+        # For mean, out.grad is a scalar. Adding a scalar to self.grad (an array)
+        # implicitly broadcasts the scalar across all elements, which is the correct behavior
+        # for the gradient of a mean operation.
+        self.grad = self.grad + (out.grad / self.vals.size)
+        self._backward()
+    out._backward = backward
+    return out
+
+  def __call__(self):
+    return self
+
+  def __getitem__(self, item):
+    out = Values(self.vals[item])
+    saved_item = item
+    def backward():
+        if self.grad_flag:
+            temp_grad = np.zeros_like(self.vals)
+            temp_grad[saved_item] = out.grad
+            self._backward()
+    out._backward = backward
+    return out
+
+  def backward(self):
+    self.grad = np.ones_like(self.vals)
+    self._backward()
+
+  def __getattr__(self, name):
+    if name == "_":
+      return self
+    if name == "T" or name == "transpose":
+      out = Values(self.vals.T)
+      def backward():
+        if self.grad_flag:
+          # out.grad is the shape of out.vals (transposed vals), so out.grad.T is the shape of self.vals.
+          # No broadcast_grad needed here.
+          self.grad = self.grad + out.grad.T
+          self._backward()
+        return
+      out._backward = backward
+      return out
+
+    if hasattr(self.vals, name) and not callable(getattr(self.vals, name)):
+      return getattr(self.vals, name)
+
+    raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}' or attribute is not supported for automatic differentiation.")

rb_deeplearning_lib/neural_net.py

@@ -1,194 +1,199 @@
-class Layer:
-  def __init__(self, input,out,activ="_",rangeW=(-1,1),rangeB=(-1,1)):
-    self.weights = Values((rangeW[0]-rangeW[1])*np.random.rand(input,out)+rangeW[1])
-    self.bias = Values((rangeB[0]-rangeB[1])*np.random.rand(1,out)+rangeB[1])
-    self.activation = activ
-
-  def __call__(self, x):
-    y = x @ self.weights + self.bias
-    if self.activation == "_": # No activation function
-        return y
-    else:
-        # Get the method corresponding to the activation string and call it.
-        # This will now correctly find methods like y.relu() or y.softmax().
-        # If self.activation is not a valid method name, it will raise an AttributeError.
-        activation_func = getattr(y, self.activation)
-        return activation_func()
-
-  def params(self):
-    return self.weights, self.bias
-
-  def updateParams(self, l_rate):
-    self.weights.vals = self.weights.vals - l_rate * self.weights.grad
-    self.bias.vals = self.bias.vals - l_rate * self.bias.grad
-    self.weights.grad = self.weights.grad * 0
-    self.bias.grad = self.bias.grad * 0
-
-class Dense:
-  def __init__(self, layNum, inL, midL, outL, activ="_",f_activ="_",rangeW=(-0.1,0.1),rangeB=(-0.1,0.1)):
-    if layNum < 1:
-      print("Dense can't have 0 layers or below.")
-    elif layNum == 1:
-      self.seq = Sequence([Layer(inL,outL,f_activ,rangeW,rangeB)])
-    else:
-      lays = []
-      for i in range(layNum):
-        if i == 0:
-          lays.append(Layer(inL,midL,activ,rangeW,rangeB))
-        elif i == layNum-1:
-          lays.append(Layer(midL,outL,f_activ,rangeW,rangeB))
-        else:
-          lays.append(Layer(midL,midL,activ,rangeW,rangeB))
-      self.seq = Sequence(lays)
-
-  def __call__(self, x):
-      return self.seq(x)
-
-  def params(self):
-      return self.seq.params()
-  def updateParams(self, l_rate):
-    self.seq.updateParams(l_rate)
-
-class Dropout:
-  def __init__(self, size, chance):
-    self.size = size
-    self.rate = chance
-    self.inTrain = False
-
-  def __call__(self, x):
-    r = self.rate
-    if r <= 0.0 or not self.inTrain:
-      return x
-    elif r >= 1.0:
-      return Values(np.zeros_like(x.vals))
-
-    do = Values(np.random.choice([0,1/(1-r)],size=(self.size,),p=[r, 1-r]))
-    return x * do
-
-  def updateParams(self, l_rate): #here so errors don't occur when update params is called for the whole sequence
-    return
-
-#loss functions
-def cross_entropy_loss(y_true, y_pred):
-  loss = -(y_true * y_pred.log()).sum(axis=1).mean()
-  return loss
-
-def mse_loss(y_true, y_pred):
-  loss = ((y_true - y_pred)**2).mean()
-  return loss
-
-
-
-
-class Model:
-  def __init__(self, blocks, regu = "", train = True, loss_fn=None, pen_fn = None):
-    self.blocks = Sequence(blocks)
-    self.regu = regu
-    self.inTrain = train
-    self.train_loss = []
-    self.val_loss = []
-    # Set default loss function to cross-entropy if not provided
-    if loss_fn is None:
-        self.loss_fn = cross_entropy_loss
-    else:
-        self.loss_fn = loss_fn
-
-    if pen_fn is None:
-      def emptyPenFn(loss_prev, model, _lambda):
-        return loss_prev
-      pen_fn = emptyPenFn
-    self.pen_fn = pen_fn
-
-  def __call__(self, x):
-    x_ = x if isinstance(x, Values) else Values(x)
-    return self.blocks(x_)
-
-  def train(self, epochs, x_t, y_t, x_v, y_v, val_run=1, l_rate=0.01, _lambda=0.1, batch_size = None):
-    x_trn = x_t if isinstance(x_t, Values) else Values(x_t)
-    y_trn = y_t if isinstance(y_t, Values) else Values(y_t)
-    x_vl = x_v if isinstance(x_v, Values) else Values(x_v)
-    y_vl = y_v if isinstance(y_v, Values) else Values(y_v)
-    x_trn.grad_flag = y_trn.grad_flag = x_vl.grad_flag = y_vl.grad_flag = False
-
-    for l in self.blocks.arr:
-      if isinstance(l, Dropout):
-        l.inTrain = True
-
-    if not batch_size:
-      batch_size = len(x_trn.vals)
-
-    batches = 0
-    if len(x_trn.vals) % batch_size == 0:
-      batches = int(len(x_trn.vals) / batch_size)
-    else:
-      batches = int(len(x_trn.vals) / batch_size + 1)
-
-    bat = np.array(range(batches))
-
-
-    loss_strt = len(self.train_loss)
-    if loss_strt != 0:
-      loss_strt = int(self.train_loss[-1][0] + 1)
-    for i in range(epochs):
-      if i % val_run == 0:
-          for l in self.blocks.arr:
-            if isinstance(l, Dropout):
-              l.inTrain = False
-          y_val_hat = self.__call__(x_vl)
-          val_loss_value = self.loss_fn(y_vl, y_val_hat).vals
-          print(f"epoch: {i} \t loss: {val_loss_value}")
-          self.val_loss.append((loss_strt+i,val_loss_value))
-          for l in self.blocks.arr:
-            if isinstance(l, Dropout):
-              l.inTrain = True
-      np.random.shuffle(bat)
-      for b in range(batches):
-        print(f"\rep{i}: b{b}/{batches}", end="")
-        x_train_batch = x_trn[bat[b]*batch_size:(bat[b]+1)*batch_size]
-        y_train_batch = y_trn[bat[b]*batch_size:(bat[b]+1)*batch_size]
-
-        y_hat = self.__call__(x_train_batch)
-
-        # Calculate loss using the specified loss_fn
-        current_loss = self.loss_fn(y_train_batch, y_hat)
-
-        self.train_loss.append((loss_strt+i + 1.0*b/batches,current_loss.vals))
-        penalized_loss = self.pen_fn(current_loss,self,_lambda)
-        penalized_loss.grad = np.ones_like(penalized_loss.vals)
-        penalized_loss.backward()
-        self.blocks.updateParams(l_rate)
-      print("\r", end="")
-
-    for l in self.blocks.arr:
-      if isinstance(l, Dropout):
-        l.inTrain = False
-
-    loss_strt = len(self.train_loss)
-    if loss_strt != 0:
-      loss_strt = int(self.train_loss[-1][0] + 1)
-
-    y_val_hat = self.__call__(x_vl)
-    val_loss_value = self.loss_fn(y_vl, y_val_hat).vals # Use loss_fn for validation too
-    print(f"epoch: {epochs} \t loss: {val_loss_value}") # Generic 'loss' instead of 'cross_entropy loss'
-    self.val_loss.append((loss_strt,val_loss_value))
-
-#penalty functions
-def l2_reg(loss_prev, model, _lambda):
-  l2_pen = Values(0.0)
-
-  for block in model.blocks.arr:
-    if isinstance(block, Dense) or isinstance(block, Layer):
-      weights, _ = block.params()
-      for weis in weights:
-        l2_pen = l2_pen + (weis**2).sum()
-  return loss_prev + _lambda * l2_pen
-
-def l1_reg(loss_prev, model, _lambda):
-  l1_pen = Values(0.0)
-
-  for block in model.blocks.arr:
-    if isinstance(block, Dense) or isinstance(block, Layer):
-      weights, _ = block.params()
-      for weis in weights:
-        l1_pen = l1_pen + (weis.abs()).sum()
-  return loss_prev + _lambda * l1_pen
+import optimizer
+import sequence
+
+class Layer:
+  def __init__(self, input,out,activ="_",rangeW=(-1,1),rangeB=(-1,1)):
+    self.weights = Values((rangeW[0]-rangeW[1])*np.random.rand(input,out)+rangeW[1])
+    self.bias = Values((rangeB[0]-rangeB[1])*np.random.rand(1,out)+rangeB[1])
+    self.activation = activ
+
+  def __call__(self, x):
+    y = x @ self.weights + self.bias
+    if self.activation == "_": # No activation function
+        return y
+    else:
+        # Get the method corresponding to the activation string and call it.
+        # This will now correctly find methods like y.relu() or y.softmax().
+        # If self.activation is not a valid method name, it will raise an AttributeError.
+        activation_func = getattr(y, self.activation)
+        return activation_func()
+
+  def params(self):
+    return self.weights, self.bias
+  
+class Dense:
+  def __init__(self, layNum, inL, midL, outL, activ="_",f_activ="_",rangeW=(-0.1,0.1),rangeB=(-0.1,0.1)):
+    if layNum < 1:
+      print("Dense can't have 0 layers or below.")
+    elif layNum == 1:
+      self.seq = Sequence([Layer(inL,outL,f_activ,rangeW,rangeB)])
+    else:
+      lays = []
+      for i in range(layNum):
+        if i == 0:
+          lays.append(Layer(inL,midL,activ,rangeW,rangeB))
+        elif i == layNum-1:
+          lays.append(Layer(midL,outL,f_activ,rangeW,rangeB))
+        else:
+          lays.append(Layer(midL,midL,activ,rangeW,rangeB))
+      self.seq = Sequence(lays)
+
+  def __call__(self, x):
+      return self.seq(x)
+
+  def params(self):
+      return self.seq.params()
+
+class Dropout:
+  def __init__(self, size, chance):
+    self.size = size
+    self.rate = chance
+    self.inTrain = False
+
+  def __call__(self, x):
+    r = self.rate
+    if r <= 0.0 or not self.inTrain:
+      return x
+    elif r >= 1.0:
+      return Values(np.zeros_like(x.vals))
+
+    do = Values(np.random.choice([0,1/(1-r)],size=(self.size,),p=[r, 1-r]))
+    return x * do
+
+  def updateParams(self, l_rate): #here so errors don't occur when update params is called for the whole sequence
+    return
+
+#loss functions
+def cross_entropy_loss(y_true, y_pred):
+  loss = -(y_true * y_pred.log()).sum(axis=1).mean()
+  return loss
+
+def mse_loss(y_true, y_pred):
+  loss = ((y_true - y_pred)**2).mean()
+  return loss
+
+
+
+
+class Model:
+  def __init__(self, blocks, regu = "", train = True, loss_fn=None, pen_fn = None, optimizer=None):
+    self.blocks = Sequence(blocks)
+
+    # Handle optimizer instantiation
+    if optimizer is None:
+        self.optimizer = Optimizer()
+    else:
+        self.optimizer = optimizer
+
+    self.regu = regu
+    self.inTrain = train
+    self.train_loss = []
+    self.val_loss = []
+    # Set default loss function to cross-entropy if not provided
+    if loss_fn is None:
+        self.loss_fn = cross_entropy_loss
+    else:
+        self.loss_fn = loss_fn
+
+    if pen_fn is None:
+      def emptyPenFn(loss_prev, model, _lambda):
+        return loss_prev
+      pen_fn = emptyPenFn
+    self.pen_fn = pen_fn
+
+  def __call__(self, x):
+    x_ = x if isinstance(x, Values) else Values(x)
+    return self.blocks(x_)
+
+  def train(self, epochs, x_t, y_t, x_v, y_v, l_rate=0.01, val_run=1, _lambda=0.1, batch_size = None):
+    x_trn = x_t if isinstance(x_t, Values) else Values(x_t)
+    y_trn = y_t if isinstance(y_t, Values) else Values(y_t)
+    x_vl = x_v if isinstance(x_v, Values) else Values(x_v)
+    y_vl = y_v if isinstance(y_v, Values) else Values(y_v)
+    x_trn.grad_flag = y_trn.grad_flag = x_vl.grad_flag = y_vl.grad_flag = False
+
+    for l in self.blocks.arr:
+      if isinstance(l, Dropout):
+        l.inTrain = True
+
+    if not batch_size:
+      batch_size = len(x_trn.vals)
+
+    batches = 0
+    if len(x_trn.vals) % batch_size == 0:
+      batches = int(len(x_trn.vals) / batch_size)
+    else:
+      batches = int(len(x_trn.vals) / batch_size + 1)
+
+    bat = np.array(range(batches))
+
+
+    loss_strt = len(self.train_loss)
+    if loss_strt != 0:
+      loss_strt = int(self.train_loss[-1][0] + 1)
+    for i in range(epochs):
+      if i % val_run == 0:
+          for l in self.blocks.arr:
+            if isinstance(l, Dropout):
+              l.inTrain = False
+          y_val_hat = self.__call__(x_vl)
+          val_loss_value = self.loss_fn(y_vl, y_val_hat).vals
+          print(f"epoch: {i} \t loss: {val_loss_value}")
+          self.val_loss.append((loss_strt+i,val_loss_value))
+          for l in self.blocks.arr:
+            if isinstance(l, Dropout):
+              l.inTrain = True
+      np.random.shuffle(bat)
+      for b in range(batches):
+        print(f"\rep{i}: b{b}/{batches}", end="")
+        x_train_batch = x_trn[bat[b]*batch_size:(bat[b]+1)*batch_size]
+        y_train_batch = y_trn[bat[b]*batch_size:(bat[b]+1)*batch_size]
+
+        y_hat = self.__call__(x_train_batch)
+
+        # Calculate loss using the specified loss_fn
+        current_loss = self.loss_fn(y_train_batch, y_hat)
+
+        self.train_loss.append((loss_strt+i + 1.0*b/batches,current_loss.vals))
+        penalized_loss = self.pen_fn(current_loss,self,_lambda)
+        penalized_loss.grad = np.ones_like(penalized_loss.vals)
+        penalized_loss.backward()
+        # Use the optimizer to step and clear gradients
+        # Retrieve parameters within the training loop before each optimization step
+        all_params = self.blocks.params()
+        self.optimizer.step(all_params, l_rate)
+      print("\r", end="")
+
+    for l in self.blocks.arr:
+      if isinstance(l, Dropout):
+        l.inTrain = False
+
+    loss_strt = len(self.train_loss)
+    if loss_strt != 0:
+      loss_strt = int(self.train_loss[-1][0] + 1)
+
+    y_val_hat = self.__call__(x_vl)
+    val_loss_value = self.loss_fn(y_vl, y_val_hat).vals # Use loss_fn for validation too
+    print(f"epoch: {epochs} \t loss: {val_loss_value}") # Generic 'loss' instead of 'cross_entropy loss'
+    self.val_loss.append((loss_strt,val_loss_value))
+
+#penalty functions
+def l2_reg(loss_prev, model, _lambda):
+  l2_pen = Values(0.0)
+
+  for block in model.blocks.arr:
+    if isinstance(block, Dense) or isinstance(block, Layer):
+      weights, _ = block.params()
+      for weis in weights:
+        l2_pen = l2_pen + (weis**2).sum()
+  return loss_prev + _lambda * l2_pen
+
+def l1_reg(loss_prev, model, _lambda):
+  l1_pen = Values(0.0)
+
+  for block in model.blocks.arr:
+    if isinstance(block, Dense) or isinstance(block, Layer):
+      weights, _ = block.params()
+      for weis in weights:
+        l1_pen = l1_pen + (weis.abs()).sum()
+  return loss_prev + _lambda * l1_pen

rb_deeplearning_lib/optimizer.py

@@ -0,0 +1,100 @@
+import numpy as np
+import autogradient
+
+class Optimizer:
+  def __init__(self):
+    pass
+
+  def step(self, params, learning_rate):
+    for p in params:
+      p.vals = p.vals - learning_rate * p.grad
+      p.grad = np.zeros_like(p.grad)
+
+class Optim_SGD(Optimizer):
+  def __init__(self, finitters, fin_l_rate):
+    self.t = 0
+    self.finitter = finitters
+    self.fin_l_rate = fin_l_rate
+
+  def step(self, params, learning_rate):
+    self.t += 1
+    t = self.t
+    alpha = t/self.finitters
+    if(alpha < 1):
+      l_rate = learning_rate*(1-alpha) + alpha*self.fin_l_rate
+    else:
+      l_rate = self.fin_l_rate
+    for p in params:
+      p.vals = p.vals - l_rate * p.grad
+      p.grad = np.zeros_like(p.grad)
+
+class Optim_SGD_Momentum(Optimizer):
+  def __init__(self,mom_beta=0.9):
+    self.v = {}
+    self.beta = mom_beta
+
+  def step(self, params, learning_rate):
+    v = self.v
+    for p in params:
+      if p not in self.v:
+        v[p] = np.zeros_like(p.vals)
+      v[p] = self.beta*v[p] - learning_rate*p.grad
+      p.vals = p.vals + self.v[p]
+      p.grad = np.zeros_like(p.grad)
+    self.v = v
+
+class Optim_AdaGrad(Optimizer):
+  def __init__(self, gamma=0.0000001):
+    self.gamma = gamma
+    self.r = {}
+
+  def step(self, params, l_rate):
+    for p in params:
+      if p not in self.r:
+        self.r[p] = np.zeros_like(p.vals)
+      self.r[p] = self.r[p] + p.grad**2
+      p.vals = p.vals - l_rate * p.grad / (self.gamma + self.r[p]**0.5)
+      p.grad = np.zeros_like(p.grad)
+
+class Optim_RMSPropclass(Optimizer):
+  def __init__(self,decay_rate, gamma=0.000001):
+    self.decay_rate = decay_rate
+    self.gamma = gamma
+    self.r = {}
+  def step(self, params, l_rate):
+    dr = self.decay_rate
+    for p in params:
+      if p not in self.r:
+        self.r[p] = np.zeros_like(p.vals)
+      self.r[p] = dr*self.r[p] + (1-dr)*p.grad**2
+      p.vals = p.vals - l_rate*p.grad/(self.gamma + self.r[p]**0.5)
+      p.grad = np.zeros_like(p.grad)
+
+class Optim_Adam(Optimizer):
+  def __init__(self, beta1, beta2, gamma = 0.000001):
+    self.b1 = beta1
+    self.b2 = beta2
+    self.gamma = gamma
+    self.r = {}
+    self.s = {}
+    self.t = 0
+
+  def step(self, params, l_rate):
+    self.t += 1
+    t = self.t
+    beta1 = self.b1
+    beta2 = self.b2
+    for p in params:
+      if p not in self.r:
+        self.r[p] = np.zeros_like(p.vals)
+      if p not in self.s:
+        self.s[p] = np.zeros_like(p.vals)
+
+      self.s[p] = beta1*self.s[p] + (1-beta1)*p.grad
+      self.r[p] = beta2*self.r[p] + (1-beta2)*p.grad**2
+
+      s_hat = self.s[p]/(1-beta1**t)
+      r_hat = self.r[p]/(1-beta2**t)
+
+      p.vals = p.vals - l_rate*s_hat/(self.gamma + r_hat**0.5)
+      p.grad = np.zeros_like(p.grad)

rb_deeplearning_lib/sequence.py

@@ -1,23 +1,23 @@
-class Sequence:
-  def __init__(self, arr):
-    self.arr = arr
-
-  def __call__(self, x):
-    x_i = x
-    for item in self.arr:
-      x_i = item(x_i)
-    return x_i
-
-  def params(self):
-    weis = []
-    biases = []
-    for l in self.arr:
-      w, b = l.params()
-      weis.append(w)
-      biases.append(b)
-
-    return weis, biases
-
-  def updateParams(self, l_rate):
-    for l in self.arr:
-      l.updateParams(l_rate)
+class Sequence:
+  def __init__(self, arr):
+    self.arr = arr
+
+  def __call__(self, x):
+    x_i = x
+    for item in self.arr:
+      x_i = item(x_i)
+    return x_i
+
+  def params(self):
+    weis = []
+    biases = []
+    for l in self.arr:
+      w, b = l.params()
+      weis.append(w)
+      biases.append(b)
+
+    return weis, biases
+
+  def updateParams(self, l_rate):
+    for l in self.arr:
+      l.updateParams(l_rate)

{rb_deeplearning_lib-0.0.2.dist-info → rb_deeplearning_lib-0.1.1.dist-info}/METADATA

@@ -1,37 +1,38 @@
-Metadata-Version: 2.4
-Name: rb-deeplearning-lib
-Version: 0.0.2
-Summary: This is a machine learning--more specifically deep learning--library from my independent study on deep learning. This library is both a result of my learning and a tool for AI development.
-License-Expression: MIT
-Project-URL: Homepage, https://github.com/rylan-berry/DeepLearningIndependentStudy/tree/main/deeplearning_package
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy>=2.0
-Dynamic: license-file
-
-# Deeplearning Package
-
-## Overview
-
-This package is designed to be similar to the PyTorch system of a building block system. Providing the functions that can be mixed, matched, and customized as pleased for any given model. This library is bare bones and only includes the few methods and ideas I learned about while studying *Deep Learning* by Ian Goodfellow et. al.. AI was used in the project, but it was used sparingly.
-
-## Modules
-
-This project has three main modules:
-
-* `autogradient.py`  
-* `sequence.py`  
-* `neural_net.py`
-
-All of which are automatically part of the initial import of the package.
-
-## Making and Running a Model
-
-When creating a model, use the Model class, which runs most of the functions included in the package itself. The first argument is a list of layers or blocks, each element is the steps in the network. These steps can be a Dense, Layer, or Dropout blocks (more will be made), a Dense is just multiple layers stacked back to back.   
-Training a model is done through: def train(epochs, x\_t, y\_t, x\_v, y\_v, val\_run=1, l\_rate=0.01, \_lambda\=0.1, batch\_size \= None)  
-Where epochs is the number of times you train through the data, the \#\_t means training data and \#\_v means validation data, x means input, y means output, val\_run is the epochs between when you want to test the validation data, l\_rate is the learn rate, \_lambda is a hyperparameter that determines the strength of the penalty functions, and batch\_size determines how large batches will be (if the batch size isn’t a multiple of the data size then it will still run, there is just a smaller batch then the others). 
-
-## Dependencies
-
-The auto gradient–which is used for back propagation–relies heavily on **numpy**.
+Metadata-Version: 2.4
+Name: rb-deeplearning-lib
+Version: 0.1.1
+Summary: This is a machine learning--more specifically deep learning--library from my independent study on deep learning. This library is both a result of my learning and a tool for AI development.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/rylan-berry/DeepLearningIndependentStudy/tree/main/deeplearning_package
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.0
+Dynamic: license-file
+
+# Deeplearning Package
+
+## Overview
+
+This package is designed to be similar to the PyTorch system of a building block system. Providing the functions that can be mixed, matched, and customized as pleased for any given model. This library is bare bones and only includes the few methods and ideas I learned about while studying *Deep Learning* by Ian Goodfellow et. al.. AI was used in the project, but it was used sparingly.
+
+## Modules
+
+This project has four main modules:
+
+* `autogradient.py`  
+* `sequence.py`
+* `optimizer.py`
+* `neural_net.py`
+
+All of which are automatically part of the initial import of the package.
+
+## Making and Running a Model
+
+When creating a model, use the Model class, which runs most of the functions included in the package itself. The first argument is a list of layers or blocks, each element is the steps in the network. These steps can be a Dense, Layer, or Dropout blocks (more will be made), a Dense is just multiple layers stacked back to back.   
+Training a model is done through: `def train(epochs, x_t, y_t, x_v, y_v, val_run=1, l_rate=0.01, _lambda=0.1, batch_size = None) ` 
+Where epochs is the number of times you train through the data, the `#_t` means training data and `#_v` means validation data, `x` means input, `y` means output, `val_run` is the epochs between when you want to test the validation data, `l_rate` is the learn rate, `_lambda` is a hyperparameter that determines the strength of the penalty functions, and `batch_size` determines how large batches will be (if the batch size isn’t a multiple of the data size then it will still run, there is just a smaller batch then the others). 
+
+## Dependencies
+
+The auto gradient–which is used for back propagation–relies heavily on `numpy`.

rb_deeplearning_lib-0.1.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+rb_deeplearning_lib/__init__.py,sha256=AcFuV_PoQCmRt8Ag7BW0TXGCQuqBNHrw6iYwYmd3AaY,71
+rb_deeplearning_lib/autogradient.py,sha256=woXGKi1EZ1QobvRbPMtj4WQqdkOCr7Xk_KeG8WE1d6k,9388
+rb_deeplearning_lib/neural_net.py,sha256=nwC4bdEYSYRtylqe7p68SFlRJKc1htBB-sMJGiFl8fk,6478
+rb_deeplearning_lib/optimizer.py,sha256=OI2x7xrna4ksbaprNgIx25jogVM10OGfNYKpwetRc7o,2690
+rb_deeplearning_lib/sequence.py,sha256=As8FiHVrcN2w0xXV8Vt_eHhNh1vDWDM3oIfrZMUkZ5g,417
+rb_deeplearning_lib-0.1.1.dist-info/licenses/LICENSE,sha256=RGN7cN89q7JPnZj-z1KSZT9M3zcJPwjzb-gEOt6SCCA,1069
+rb_deeplearning_lib-0.1.1.dist-info/METADATA,sha256=BmS_hqF2-rcQgBE9iKrjGR0iDnjsi7quXNYrkstYCRM,2286
+rb_deeplearning_lib-0.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+rb_deeplearning_lib-0.1.1.dist-info/top_level.txt,sha256=oK1ClPmIXDzAbwPHl69BE88PFjpsYta_a5vNEa5WJoA,20
+rb_deeplearning_lib-0.1.1.dist-info/RECORD,,

{rb_deeplearning_lib-0.0.2.dist-info → rb_deeplearning_lib-0.1.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{rb_deeplearning_lib-0.0.2.dist-info → rb_deeplearning_lib-0.1.1.dist-info}/licenses/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Rylan L Berry
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2026 Rylan L Berry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

rb_deeplearning_lib-0.0.2.dist-info/RECORD

@@ -1,9 +0,0 @@
-rb_deeplearning_lib/__init__.py,sha256=ocbbPLbgvqPWapKJCbutXdhg2qS2TCeOySmvyLXqJW8,57
-rb_deeplearning_lib/autogradient.py,sha256=ZZdXnyPirx_A3xLexiqQ2p26Iu2zulXTDJyuiNHR3p0,9663
-rb_deeplearning_lib/neural_net.py,sha256=EyPhJaZWV0D_-0gZLY_xo_tGcprdBBc8dzsPByUjx_k,6605
-rb_deeplearning_lib/sequence.py,sha256=qxMiJvadFGXRXF5R3JgnAELzQQUGftpZRIYZ_bYdHt0,440
-rb_deeplearning_lib-0.0.2.dist-info/licenses/LICENSE,sha256=KaPiob6jyYzac2fmuJ_u3xCaXWekJCvppmg95sC76as,1089
-rb_deeplearning_lib-0.0.2.dist-info/METADATA,sha256=wU9M8c80776HGyjZgXXosbEzb02SFAGqcZ2Hv9rQfOw,2311
-rb_deeplearning_lib-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rb_deeplearning_lib-0.0.2.dist-info/top_level.txt,sha256=oK1ClPmIXDzAbwPHl69BE88PFjpsYta_a5vNEa5WJoA,20
-rb_deeplearning_lib-0.0.2.dist-info/RECORD,,