heavyball 0.14.6__py3-none-any.whl → 0.15.0__py3-none-any.whl

heavyball/precond_schedule_sfpsoap.py

@@ -54,85 +54,73 @@ class PrecondScheduleSFPaLMSOAP(ScheduleFree):
         self._data_format = data_format
         self.rng = random.Random(0x120983109)
 
-    @torch.no_grad()
-    def step(self, closure=None):
-        """
-        Performs a single optimization step.
-
-        Arguments:
-            closure (`Callable`, *optional*): A closure that reevaluates the model and returns the loss.
-        """
-        if closure is None:
-            loss = None
-        else:
-            loss = closure()
-
-        for group in self.param_groups:
-            vals = []
-            max_precond_dim = group['max_precond_dim']
-            precondition_1d = group['precondition_1d']
-
-            step = group['step'] = group.get("step", -1) + 1
-
-            for p in group["params"]:
-                if p.grad is None:
-                    continue
-                grad = p.grad.float()
-                vals.append((p, grad))
-
-            p_list, grad = zip(*vals)
-            vals = []
-
-            # adaptive gradient clipping
-            adaptive_gradient_clipping_(p_list, grad, group["gradient_clip_val"], eps=group["eps"])
-
-            for p, g in split_p_and_g_in_group(group):
-                state = self.state_(p)
-
-                if "z" not in state:
-                    state["z"] = torch.clone(p.data)
-                    state["exp_avg_sq"] = torch.zeros_like(g, dtype=torch.float32)
-                    init_preconditioner(g, state, max_precond_dim, precondition_1d)
-                    update_preconditioner(g, state, max_precond_dim, precondition_1d, 0, True)
-                    continue  # first step is skipped so that we never use the current gradients in the projection.
-
-                # Projecting gradients to the eigenbases of Shampoo's preconditioner
-                # i.e. projecting to the eigenbases of matrices in state['GG']
-                grad_projected = project(g, state['Q'], False)
-                z, exp_avg_sq = state["z"], state["exp_avg_sq"]
-                vals.append((p, g, grad_projected, z, exp_avg_sq))
-
-            if not vals:
+    def _step(self, group):
+        vals = []
+        max_precond_dim = group['max_precond_dim']
+        precondition_1d = group['precondition_1d']
+
+        step = group['step'] = group.get("step", -1) + 1
+
+        for p in group["params"]:
+            if p.grad is None:
                 continue
+            grad = p.grad.float()
+            vals.append((p, grad))
+
+        if not vals:
+            return
+
+        p_list, grad = zip(*vals)
+        vals = []
+
+        # adaptive gradient clipping
+        adaptive_gradient_clipping_(p_list, grad, group["gradient_clip_val"], eps=group["eps"])
+
+        for p, g in split_p_and_g_in_group(group):
+            state = self.state_(p)
+
+            if "z" not in state:
+                state["z"] = torch.clone(p.data)
+                state["exp_avg_sq"] = torch.zeros_like(g, dtype=torch.float32)
+                init_preconditioner(g, state, max_precond_dim, precondition_1d)
+                update_preconditioner(g, state, max_precond_dim, precondition_1d, 0, True)
+                continue  # first step is skipped so that we never use the current gradients in the projection.
+
+            # Projecting gradients to the eigenbases of Shampoo's preconditioner
+            # i.e. projecting to the eigenbases of matrices in state['GG']
+            grad_projected = project(g, state['Q'], False)
+            z, exp_avg_sq = state["z"], state["exp_avg_sq"]
+            vals.append((p, g, grad_projected, z, exp_avg_sq))
 
-            p_list, grad, grad_projected, z, exp_avg_sq = zip(*vals)
-            del vals
+        if not vals:
+            return
 
-            beta2 = 1 - max(step, 1) ** -group['beta2_scale']
-            old_debiased2 = beta_debias(beta2, step)
+        p_list, grad, grad_projected, z, exp_avg_sq = zip(*vals)
+        del vals
 
-            # Decay the first and second moment running average coefficient
-            # In-place operations to update the averages at the same time
-            denom = exp_avg_sq_(exp_avg_sq, grad_projected, old_debiased2, group['eps'])
-            torch._foreach_div_(grad_projected, denom)
+        beta2 = 1 - max(step, 1) ** -group['beta2_scale']
+        old_debiased2 = beta_debias(beta2, step)
 
-            update_precond = precond_schedule(step, group['precond_scheduler'], self.rng)
+        # Decay the first and second moment running average coefficient
+        # In-place operations to update the averages at the same time
+        denom = exp_avg_sq_(exp_avg_sq, grad_projected, old_debiased2, group['eps'])
+        torch._foreach_div_(grad_projected, denom)
 
-            for p, g, gp in zip(p_list, grad, grad_projected):
-                state = self.state_(p)
-                # Projecting back the preconditioned (by Adam) exponential moving average of gradients
-                # to the original space
-                set_(gp, project(gp, state['Q'], back=True))
+        update_precond = precond_schedule(step, group['precond_scheduler'], self.rng)
 
-                update_preconditioner(g, state, max_precond_dim, precondition_1d, old_debiased2,
-                                      update_precond)
+        for p, g, gp in zip(p_list, grad, grad_projected):
+            state = self.state_(p)
+            # Projecting back the preconditioned (by Adam) exponential moving average of gradients
+            # to the original space
+            set_(gp, project(gp, state['Q'], back=True))
 
-            # Weight decay calculated at y
-            if group["weight_decay"] > 0:
-                torch._foreach_add_(grad, p_list, alpha=group["weight_decay"])
+            update_preconditioner(g, state, max_precond_dim, precondition_1d, old_debiased2,
+                                  update_precond)
 
-            lr = warmup(group['lr'], step, group['warmup_steps'])
-            group['weight_sum'] = schedule_free_(lr, group['weight_lr_power'], group['weight_sum'], group['beta'],
-                                                 p_list, z, grad_projected, group['r'], step)
+        # Weight decay calculated at y
+        if group["weight_decay"] > 0:
+            torch._foreach_add_(grad, p_list, alpha=group["weight_decay"])
 
-        return loss
+        lr = warmup(group['lr'], step, group['warmup_steps'])
+        group['weight_sum'] = schedule_free_(lr, group['weight_lr_power'], group['weight_sum'], group['beta'],
+                                             p_list, z, grad_projected, group['r'], step)

heavyball/psgd_kron.py

@@ -4,9 +4,10 @@ Modified under Creative Commons Attribution 4.0 International
 Source available at https://github.com/evanatyourservice/kron_torch/blob/97a2b5ee8a1a4c29e4780bbf6c521e545189eff9/kron_torch/kron.py
 """
 
-import torch
 from typing import Optional
 
+import torch
+
 from .utils import update_param_, warmup, psgd_precond_grad, init_Q_exprs, trust_region_clip_, PSGDBase, \
     precond_update_prob_schedule, split_p_and_g_in_group, line_to_triu, triu_to_line, set_
 
@@ -62,13 +63,7 @@ class ForeachPSGDKron(PSGDBase):
 
         self._prob_step = 0
 
-    @torch.no_grad()
-    def step(self, closure=None):
-        loss = None
-        if closure is not None:
-            with torch.enable_grad():
-                loss = closure()
-
+    def _step(self, group):
         # update preconditioners all together
         update_prob = self.preconditioner_update_probability
         if callable(update_prob):
@@ -76,54 +71,51 @@ class ForeachPSGDKron(PSGDBase):
         do_update = self.rng.random() < update_prob
         self._prob_step += 1
 
-        for group in self.param_groups:
-            momentum_into_precond_update = group.get("momentum_into_precond_update", True)
-            precond_init_scale = group['precond_init_scale']
-            max_size_triangular = group['max_size_triangular']
-            min_ndim_triangular = group['min_ndim_triangular']
-            memory_save_mode = group['memory_save_mode']
-            precond_lr = group['precond_lr']
-            weight_decay = group['weight_decay']
-            lr = group['lr']
-            beta = group['beta']
-
-            vals = []
+        momentum_into_precond_update = group.get("momentum_into_precond_update", True)
+        precond_init_scale = group['precond_init_scale']
+        max_size_triangular = group['max_size_triangular']
+        min_ndim_triangular = group['min_ndim_triangular']
+        memory_save_mode = group['memory_save_mode']
+        precond_lr = group['precond_lr']
+        weight_decay = group['weight_decay']
+        lr = group['lr']
+        beta = group['beta']
 
-            for p, g in split_p_and_g_in_group(group):
-                state = self.state_(p)
+        vals = []
 
-                if 'Q' not in state:
-                    state["exp_avg"] = torch.zeros_like(g)
-                    Q, state["exprs"] = init_Q_exprs(p, precond_init_scale, max_size_triangular, min_ndim_triangular,
-                                                     memory_save_mode, dtype=g.dtype)
-                    state['Q'] = triu_to_line(Q)
+        for p, g in split_p_and_g_in_group(group):
+            state = self.state_(p)
 
-                vals.append((p, g, state["exp_avg"], state["Q"]))
+            if 'Q' not in state:
+                state["exp_avg"] = torch.zeros_like(g)
+                Q, state["exprs"] = init_Q_exprs(p, precond_init_scale, max_size_triangular, min_ndim_triangular,
+                                                 memory_save_mode, dtype=g.dtype)
+                state['Q'] = triu_to_line(Q)
 
-            if not vals:
-                continue
+            vals.append((p, g, state["exp_avg"], state["Q"]))
 
-            p_list, grad_list, exp_avg_list, Q_list = zip(*vals)
-            del vals
+        if not vals:
+            return
 
-            group["step"] += 1
+        p_list, grad_list, exp_avg_list, Q_list = zip(*vals)
+        del vals
 
-            torch._foreach_lerp_(exp_avg_list, grad_list, (1 - beta) / (1 - beta ** group["step"]))
+        group["step"] += 1
 
-            grad_list, Q_list, exp_avg_list = list(grad_list), list(Q_list), list(exp_avg_list)
-            for i, (p, g) in enumerate(zip(p_list, grad_list)):
-                q_orig = Q_list.pop(0)
-                ea = exp_avg_list.pop(0)
-                q = line_to_triu(q_orig)
+        torch._foreach_lerp_(exp_avg_list, grad_list, (1 - beta) / (1 - beta ** group["step"]))
 
-                self.balance(do_update, [g], [q])
-                if do_update:
-                    self.do_update([p], [ea if momentum_into_precond_update else g], [q], precond_lr, [q_orig])
-                set_(g, psgd_precond_grad(q, self.state_(p)["exprs"], ea))
+        grad_list, Q_list, exp_avg_list = list(grad_list), list(Q_list), list(exp_avg_list)
+        for i, (p, g) in enumerate(zip(p_list, grad_list)):
+            q_orig = Q_list.pop(0)
+            ea = exp_avg_list.pop(0)
+            q = line_to_triu(q_orig)
 
-            grad_list = self.clip_fn(grad_list)
+            self.balance(do_update, [g], [q])
+            if do_update:
+                self.do_update([p], [ea if momentum_into_precond_update else g], [q], precond_lr, [q_orig])
+            set_(g, psgd_precond_grad(q, self.state_(p)["exprs"], ea))
 
-            lr = -warmup(lr, group['step'], group['warmup_steps'])
-            update_param_(p_list, grad_list, lr, weight_decay)
+        grad_list = self.clip_fn(grad_list)
 
-        return loss
+        lr = -warmup(lr, group['step'], group['warmup_steps'])
+        update_param_(p_list, grad_list, lr, weight_decay)

heavyball/pure_psgd.py

@@ -59,13 +59,7 @@ class ForeachPurePSGD(PSGDBase):
 
         self._prob_step = 0
 
-    @torch.no_grad()
-    def step(self, closure=None):
-        loss = None
-        if closure is not None:
-            with torch.enable_grad():
-                loss = closure()
-
+    def _step(self, group):
         # update preconditioners all together
         update_prob = self.preconditioner_update_probability
         if callable(update_prob):
@@ -73,48 +67,45 @@ class ForeachPurePSGD(PSGDBase):
         do_update = self.rng.random() < update_prob
         self._prob_step += 1
 
-        for group in self.param_groups:
-            precond_init_scale = group['precond_init_scale']
-            max_size_triangular = group['max_size_triangular']
-            min_ndim_triangular = group['min_ndim_triangular']
-            memory_save_mode = group['memory_save_mode']
-            precond_lr = group['precond_lr']
-            weight_decay = group['weight_decay']
-            lr = group['lr']
-
-            vals = []
+        precond_init_scale = group['precond_init_scale']
+        max_size_triangular = group['max_size_triangular']
+        min_ndim_triangular = group['min_ndim_triangular']
+        memory_save_mode = group['memory_save_mode']
+        precond_lr = group['precond_lr']
+        weight_decay = group['weight_decay']
+        lr = group['lr']
 
-            for p, g in split_p_and_g_in_group(group):
-                state = self.state_(p)
+        vals = []
 
-                if 'Q' not in state:
-                    Q, state["exprs"] = init_Q_exprs(p, precond_init_scale, max_size_triangular, min_ndim_triangular,
-                                                     memory_save_mode, dtype=g.dtype)
-                    state['Q'] = triu_to_line(Q)
+        for p, g in split_p_and_g_in_group(group):
+            state = self.state_(p)
 
-                vals.append((p, g, state["Q"]))
+            if 'Q' not in state:
+                Q, state["exprs"] = init_Q_exprs(p, precond_init_scale, max_size_triangular, min_ndim_triangular,
+                                                 memory_save_mode, dtype=g.dtype)
+                state['Q'] = triu_to_line(Q)
 
-            if not vals:
-                continue
+            vals.append((p, g, state["Q"]))
 
-            p_list, grad_list, Q_list = zip(*vals)
-            del vals
+        if not vals:
+            return
 
-            group["step"] += 1
+        p_list, grad_list, Q_list = zip(*vals)
+        del vals
 
-            Q_list = list(Q_list)
-            for i, (p, g) in enumerate(zip(p_list, grad_list)):
-                q_orig = Q_list.pop(0)
-                q = line_to_triu(q_orig)
+        group["step"] += 1
 
-                self.balance(do_update, [g], [q])
-                if do_update:
-                    self.do_update([p], [g], [q], precond_lr, [q_orig])
-                psgd_precond_grad(q, self.state_(p)["exprs"], g, inplace=True)
+        Q_list = list(Q_list)
+        for i, (p, g) in enumerate(zip(p_list, grad_list)):
+            q_orig = Q_list.pop(0)
+            q = line_to_triu(q_orig)
 
-            grad_list = self.clip_fn(grad_list)
+            self.balance(do_update, [g], [q])
+            if do_update:
+                self.do_update([p], [g], [q], precond_lr, [q_orig])
+            psgd_precond_grad(q, self.state_(p)["exprs"], g, inplace=True)
 
-            lr = -warmup(lr, group['step'], group['warmup_steps'])
-            update_param_(p_list, grad_list, lr, weight_decay)
+        grad_list = self.clip_fn(grad_list)
 
-        return loss
+        lr = -warmup(lr, group['step'], group['warmup_steps'])
+        update_param_(p_list, grad_list, lr, weight_decay)

heavyball/schedule_free_palm_foreach_soap.py

@@ -46,84 +46,73 @@ class SFPaLMForeachSOAP(ScheduleFree):
         self._data_format = data_format
         self.rng = random.Random(0x120983109)
 
-    @torch.no_grad()
-    def step(self, closure=None):
-        """
-        Performs a single optimization step.
-
-        Arguments:
-            closure (`Callable`, *optional*): A closure that reevaluates the model and returns the loss.
-        """
-        if closure is None:
-            loss = None
-        else:
-            loss = closure()
-
-        for group in self.param_groups:
-            vals = []
-            max_precond_dim = group['max_precond_dim']
-            precondition_1d = group['precondition_1d']
-
-            step = group['step'] = group.get("step", -1) + 1
-
-            for p in group["params"]:
-                if p.grad is None:
-                    continue
-                grad = p.grad.float()
-                vals.append((p, grad))
-
-            p_list, grad = zip(*vals)
-
-            adaptive_gradient_clipping_(p_list, grad, group["gradient_clip_val"], eps=group["eps"])
-
-            vals = []
-
-            for p, g in split_p_and_g_in_group(group):
-                state = self.state_(p)
-
-                if "z" not in state:
-                    state["z"] = torch.clone(p).float()
-                    state["exp_avg_sq"] = torch.zeros_like(g, dtype=torch.float32)
-                    init_preconditioner(g, state, max_precond_dim, precondition_1d)
-                    update_preconditioner(g, state, max_precond_dim, precondition_1d, 0, True)
-                    continue  # first step is skipped so that we never use the current gradients in the projection.
-
-                # Projecting gradients to the eigenbases of Shampoo's preconditioner
-                # i.e. projecting to the eigenbases of matrices in state['GG']
-                grad_projected = project(g, state['Q'], False)
-                z, exp_avg_sq = state["z"], state["exp_avg_sq"]
-                vals.append((p, g, grad_projected, z, exp_avg_sq))
-
-            if not vals:
+    def _step(self, group):
+        vals = []
+        max_precond_dim = group['max_precond_dim']
+        precondition_1d = group['precondition_1d']
+
+        step = group['step'] = group.get("step", -1) + 1
+
+        for p in group["params"]:
+            if p.grad is None:
                 continue
+            grad = p.grad.float()
+            vals.append((p, grad))
+
+        if not vals:
+            return
+
+        p_list, grad = zip(*vals)
+
+        adaptive_gradient_clipping_(p_list, grad, group["gradient_clip_val"], eps=group["eps"])
+
+        vals = []
+
+        for p, g in split_p_and_g_in_group(group):
+            state = self.state_(p)
+
+            if "z" not in state:
+                state["z"] = torch.clone(p).float()
+                state["exp_avg_sq"] = torch.zeros_like(g, dtype=torch.float32)
+                init_preconditioner(g, state, max_precond_dim, precondition_1d)
+                update_preconditioner(g, state, max_precond_dim, precondition_1d, 0, True)
+                continue  # first step is skipped so that we never use the current gradients in the projection.
+
+            # Projecting gradients to the eigenbases of Shampoo's preconditioner
+            # i.e. projecting to the eigenbases of matrices in state['GG']
+            grad_projected = project(g, state['Q'], False)
+            z, exp_avg_sq = state["z"], state["exp_avg_sq"]
+            vals.append((p, g, grad_projected, z, exp_avg_sq))
+
+        if not vals:
+            return
 
-            p_list, grad, grad_projected, z, exp_avg_sq = zip(*vals)
+        p_list, grad, grad_projected, z, exp_avg_sq = zip(*vals)
 
-            beta2 = 1 - max(step, 1) ** -group['beta2_scale']
-            new_debiased2 = beta_debias(beta2, step)
+        beta2 = 1 - max(step, 1) ** -group['beta2_scale']
+        new_debiased2 = beta_debias(beta2, step)
 
-            # Decay the first and second moment running average coefficient
-            # In-place operations to update the averages at the same time
-            denom = exp_avg_sq_(exp_avg_sq, grad, new_debiased2, group["eps"])
-            torch._foreach_div_(grad_projected, denom)
+        # Decay the first and second moment running average coefficient
+        # In-place operations to update the averages at the same time
+        denom = exp_avg_sq_(exp_avg_sq, grad, new_debiased2, group["eps"])
+        torch._foreach_div_(grad_projected, denom)
 
-            update_precond = group['step'] > 0 and group['step'] % group['precondition_frequency'] == 0
+        update_precond = group['step'] > 0 and group['step'] % group['precondition_frequency'] == 0
 
-            for p, g, gp in zip(p_list, grad, grad_projected):
-                state = self.state_(p)
-                # Projecting back the preconditioned (by Adam) exponential moving average of gradients
-                # to the original space
-                # CANT DO /= HERE AS EXP_AVG MAY POINT TO THE BUFFER
-                set_(gp, project(gp, state['Q'], back=True))
+        for p, g, gp in zip(p_list, grad, grad_projected):
+            state = self.state_(p)
+            # Projecting back the preconditioned (by Adam) exponential moving average of gradients
+            # to the original space
+            # CANT DO /= HERE AS EXP_AVG MAY POINT TO THE BUFFER
+            set_(gp, project(gp, state['Q'], back=True))
 
-                update_preconditioner(g, state, max_precond_dim, precondition_1d, 1 - new_debiased2,
-                                      update_precond)
+            update_preconditioner(g, state, max_precond_dim, precondition_1d, 1 - new_debiased2,
+                                  update_precond)
 
-            # Weight decay calculated at y
-            if group["weight_decay"] > 0:
-                torch._foreach_add_(grad, p_list, alpha=group["weight_decay"])
+        # Weight decay calculated at y
+        if group["weight_decay"] > 0:
+            torch._foreach_add_(grad, p_list, alpha=group["weight_decay"])
 
-            lr = warmup(group['lr'], step, group['warmup_steps'])
-            group['weight_sum'] = schedule_free_(lr, group['weight_lr_power'], group['weight_sum'], group['beta'],
-                                                 p_list, z, grad_projected, group['r'], step)
-        return loss
+        lr = warmup(group['lr'], step, group['warmup_steps'])
+        group['weight_sum'] = schedule_free_(lr, group['weight_lr_power'], group['weight_sum'], group['beta'],
+                                             p_list, z, grad_projected, group['r'], step)

heavyball/utils.py

@@ -3,7 +3,7 @@ import gc
 import math
 import random
 import string
-from typing import List, Optional, Tuple
+from typing import List, Optional, Tuple, Callable
 
 import numpy as np
 import torch
@@ -399,6 +399,20 @@ class StatefulOptimizer(torch.optim.Optimizer):
                 tree_map(_add, self.state_(p))
         return total_bytes
 
+    def _step(self, group):
+        raise NotImplementedError
+
+    def step(self, closure: Optional[Callable] = None):
+        if closure is None:
+            loss = None
+        else:
+            with torch.enable_grad():
+                loss = closure()
+        with torch.no_grad():
+            for group in self.param_groups:
+                self._step(group)
+        return loss
+
 
 class ScheduleFree(StatefulOptimizer):
     def eval(self):
@@ -570,7 +584,6 @@ def psgd_balance_Q(Q_in):
 
 
 def psgd_calc_A_and_conjB(exprA, G, Q, V):
-    print([q.shape for q in Q], G.shape, V.shape, exprA)
     A = torch.einsum(exprA, *Q, G)
     order = G.dim()
     p = list(range(order))
@@ -685,9 +698,11 @@ def a_law_compress(x, A=87.6):
     torch._foreach_mul_(xa, 1 / (1 + math.log(A)))
     return xa
 
+
 def identity(x):
     return x
 
+
 def trust_region_clip_(grad, lerp: float = 0.9, scale: float = 1.5):
     torch._foreach_mul_(grad, 1 / scale)
     tanh = torch._foreach_tanh(grad)

{heavyball-0.14.6.dist-info → heavyball-0.15.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: heavyball
-Version: 0.14.6
+Version: 0.15.0
 Summary: Efficient optimizers
 Home-page: https://github.com/clashluke/heavyball
 Author: Lucas Nestler

heavyball-0.15.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+heavyball/__init__.py,sha256=AGNWRYDkPFZ9Px3117ChPgUgEk2gqflWWXO4UxHlmYc,1156
+heavyball/delayed_psgd.py,sha256=28osHU-2khgdQ1ASglxTtA5MA1j2GiYP3OmNirkqMso,5574
+heavyball/foreach_adamw.py,sha256=NSzoIgNm7eavzbJgkAF0k7TUEnWAgOpt9-4juIFoaSA,1729
+heavyball/foreach_adopt.py,sha256=WA07m5jocLfb1GPU8s6mJ2PteS-03ronkKm-VJrAm5I,1863
+heavyball/foreach_laprop.py,sha256=mE2NDGX9XgvRhsewcWnk_-FulZPqGA65ejYF_9-A1Xk,1768
+heavyball/foreach_sfadamw.py,sha256=ussHfPd99u3RTfMrCuu5oIbwNFLXK19wO1Fbz3JShlc,2097
+heavyball/foreach_soap.py,sha256=WWvssYKg607uoEJHftp8ag8mtKSKSeHrT0QTgqBucVg,4587
+heavyball/p_adam.py,sha256=xOJuws2ELPcL-TUyH-2fPvwRdBNZUmaqiKDJFK33bPM,5694
+heavyball/palm_foreach_sfadamw.py,sha256=wjUb_fNZNUmzWXyKvwB0unP9lvNMmaYSQo5YoeS5cj0,2200
+heavyball/palm_foreach_soap.py,sha256=2Sb4hUHQeexJcCgjHeQM_ENkZ6lG1DVxW72ryrvR6iY,5890
+heavyball/precond_schedule_foreach_soap.py,sha256=bHsDyh-UvHpHjumjqqy0PePoR1ZMsJV6o5wWvpLAA04,4815
+heavyball/precond_schedule_palm_foreach_soap.py,sha256=myLTJNQKLtZ3Xi3MVTB-RYtx_XeMRJw5CIMJW75ndUY,6163
+heavyball/precond_schedule_sfpsoap.py,sha256=xeNWetBzBEYqfOSzl98aAVJsHk43QkrUUhHH_YD_mS4,6740
+heavyball/psgd_kron.py,sha256=7PxvVNeXQcxHMDdn0hFn4psEH89xOctflKt5sKjryMU,5554
+heavyball/pure_psgd.py,sha256=1vafWGQ5vtEE01T1qhI9GDXvzFw5zzq0rJrewa1jY4E,4847
+heavyball/schedule_free_palm_foreach_soap.py,sha256=w0P7lMmoijTpL9V7NwOHcNBFJQ7S1TS9aCiwPhY2yVw,6319
+heavyball/utils.py,sha256=xNqBJBZyK5n5EKy2g4qkXf342uGPGvk6pzjFPzeBncM,27861
+heavyball-0.15.0.dist-info/LICENSE,sha256=CGdGJim64YifGmUVPaeyRsxkvyExtClswhRNIp8FY_U,1322
+heavyball-0.15.0.dist-info/METADATA,sha256=CuUQyfkSwtwfsnVo6vLM_0hIMwJfB_J26-baYAlqDvM,11667
+heavyball-0.15.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+heavyball-0.15.0.dist-info/top_level.txt,sha256=SzCxSVg_qCUPA4kZObW3Zyo4v-d_mMOD-p7a-WXTl2E,10
+heavyball-0.15.0.dist-info/RECORD,,

heavyball-0.14.6.dist-info/RECORD

@@ -1,22 +0,0 @@
-heavyball/__init__.py,sha256=ef7IWcPF8Uh3WQHzMiMqOFvUnU_LdG7BO9XVecJOph4,1156
-heavyball/delayed_psgd.py,sha256=Gfa1ogkFPPL7ohayYAwbugB8hyLRUI5FgcJfsK69KGI,5936
-heavyball/foreach_adamw.py,sha256=L727chOuVqdiVbYYzloy4g3oKH2FmQh40o_bqWeZtk8,2106
-heavyball/foreach_adopt.py,sha256=M4zZVcYlhGjqO6qekivCuYfX6JtMcp4cJi_RrSHT3H8,2268
-heavyball/foreach_laprop.py,sha256=htYGqgvlZsF_JpILdPMTnX72SqfrokBJ2J4nDeT0JVU,2157
-heavyball/foreach_sfadamw.py,sha256=KIGol7Phfq1DHE_nEle4wDuqNdbGsT3kUcMKzJX3msg,2498
-heavyball/foreach_soap.py,sha256=Ccz9Mc_xaHnrJ_7jUq9ZVxyR0WEqopzOXTUqUY-V8G8,5137
-heavyball/p_adam.py,sha256=jQgTkKekqnLj1XPA4-fgpWG8P_BtUq2976zEt2QymTo,6060
-heavyball/palm_foreach_sfadamw.py,sha256=8IGlRCdkfMzUqcSfmTM3Ce04NLNyrT2xfiBcPkrWwqc,2605
-heavyball/palm_foreach_soap.py,sha256=NEJ3Xeh7pqURUk3cAP2qJe8z2WzYKg60pQe4bsGiaY4,6441
-heavyball/precond_schedule_foreach_soap.py,sha256=H6Oc5IAL5MR-fgu92AboPs3Xm8mBmYUMPLsEcuJ12VI,5370
-heavyball/precond_schedule_palm_foreach_soap.py,sha256=v81hRjcqS6Mm-KxT5Rk3TEiKAE8WI2IbmVbSa-YfBkE,6760
-heavyball/precond_schedule_sfpsoap.py,sha256=7ScnN0in8u9hPiJE7QnOoZOH6Tn-6HeVy4f-bO3bHzY,7279
-heavyball/psgd_kron.py,sha256=AH8ugd_IxKGVtY9y_Ot7myVSxFDbLlRJIqr2bBlAYy8,5911
-heavyball/pure_psgd.py,sha256=jp5fnawUdgccEFlZDPrZr4ZbxYV85IIrev4tybZxBVU,5185
-heavyball/schedule_free_palm_foreach_soap.py,sha256=bV7H-FNNoH5WpposLrNhkqU7mBicMorqKEALBSdROEM,6853
-heavyball/utils.py,sha256=WfvymrU9Xv7PMfitXZvm-4XklCy6wK0tWqOXKt96Tww,27521
-heavyball-0.14.6.dist-info/LICENSE,sha256=CGdGJim64YifGmUVPaeyRsxkvyExtClswhRNIp8FY_U,1322
-heavyball-0.14.6.dist-info/METADATA,sha256=RWQo73o1ajPpDO8uJNOhdV5d4uFdkycXRCtHrM-KfDw,11667
-heavyball-0.14.6.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-heavyball-0.14.6.dist-info/top_level.txt,sha256=SzCxSVg_qCUPA4kZObW3Zyo4v-d_mMOD-p7a-WXTl2E,10
-heavyball-0.14.6.dist-info/RECORD,,