Make this code as base: import math import matplotlib.pyplot as plt import numpy as np…
- User
Make this code as base: import math
import matplotlib.pyplot as plt import numpy as np import torch from hyperopt import fmin, hp, tpe
import torch from torch.optim import Optimizer import warnings import math
plt.style.use("seaborn-v0_8-white")
def rosenbrock(tensor): # https://en.wikipedia.org/wiki/Test_functions_for_optimization x, y = tensor return (1 - x) ** 2 + 100 * (y - x ** 2) ** 2
def execute_steps(func, initial_state, optimizer_class, optimizer_config, num_iter=500): x = torch.Tensor(initial_state).requires_grad_(True) optimizer = optimizer_class([x], **optimizer_config) steps = [] steps = np.zeros((2, num_iter + 1)) steps[:, 0] = np.array(initial_state) for i in range(1, num_iter + 1): optimizer.zero_grad() f = func(x) f.backward() torch.nn.utils.clip_grad_norm_(x, 1.0) optimizer.step() steps[:, i] = x.detach().numpy() return steps
def objective_rosenbrok(params): lr = params["lr"] optimizer_class = params["optimizer_class"] minimum = (1.0, 1.0) initial_state = (-2.0, 2.0) optimizer_config = dict(lr=lr) num_iter = 400 steps = execute_steps(rosenbrock, initial_state, optimizer_class, optimizer_config, num_iter) return (steps[0][-1] - minimum[0]) ** 2 + (steps[1][-1] - minimum[1]) ** 2
def plot_rosenbrok(grad_iter, optimizer_name, lr): x = np.linspace(-2, 2, 250) y = np.linspace(-1, 3, 250) minimum = (1.0, 1.0)
X, Y = np.meshgrid(x, y) Z = rosenbrock([X, Y]) iter_x, iter_y = grad_iter[0, :], grad_iter[1, :] fig = plt.figure(figsize=(8, 8)) ax = fig.add_subplot(1, 1, 1) ax.contour(X, Y, Z, 90, cmap="jet") ax.plot(iter_x, iter_y, color="r", marker="x") ax.set_title("Rosenbrock func: {} with {} " "iterations, lr={:.6}".format(optimizer_name, len(iter_x), lr)) plt.plot(*minimum, "gD") plt.plot(iter_x[-1], iter_y[-1], "rD") plt.savefig("../docs/rosenbrock_{}.png".format(optimizer_name))def execute_experiments(optimizers, objective, func, plot_func, initial_state, seed=1): seed = seed for item in optimizers: optimizer_class, lr_low, lr_hi = item space = {"optimizer_class": hp.choice("optimizer_class", [optimizer_class]), "lr": hp.loguniform("lr", lr_low, lr_hi), } best = fmin(fn=objective, space=space, algo=tpe.suggest, max_evals=300, rstate=np.random.default_rng(seed)) print(best["lr"], optimizer_class)
steps = execute_steps(func, initial_state, optimizer_class, {"lr": best["lr"]}, num_iter=500, ) plot_func(steps, optimizer_class.__name__, best["lr"])class Lilith(Optimizer): def init(self, params, lr: float, eps: float = 1e-8, beta1_m: float = 0.9, beta2_m: float = 0.9, beta_v: float = 0.999, weight_decay: float = 0., m_norm_min: float = 1e-4, ratio_min: float = 1e-4, lookahead_k: int = 5, lookahead_beta: float = 0.5): defaults = dict(lr=lr, eps=eps, beta1_m=beta1_m, beta2_m=beta2_m, beta_v=beta_v, weight_decay=weight_decay, m_norm_min=m_norm_min, ratio_min=ratio_min, lookahead_k=lookahead_k, lookahead_beta=lookahead_beta)
super(Lilith, self).__init__(params, defaults) @torch.no_grad def step(self, closure=None): loss = None if closure is not None: loss = closure() for group in self.param_groups: for p in group['params']: if p.grad is None: continue grad = p.grad.data state = self.state[p] if len(state) == 0: state['step'] = 0 state['m_avg1'] = torch.zeros_like(grad) state['m_avg2'] = torch.zeros_like(grad) state['v_avg'] = torch.zeros_like(grad) state['ema'] = p.data.clone() state['step'] += 1 if sum(grad.shape) > 1: trust_ratio = (p.data.norm() / grad.norm().clip(min=1e-4)).clip(min=group['ratio_min']) grad.sub_(grad.mean(dim=tuple(range(1, len(grad.shape))), keepdim=True)) grad.mul_(trust_ratio) m_avg1_prev = state['m_avg1'].clone() state['m_avg1'].add_(state['m_avg2']).lerp_(grad, 1 - group['beta1_m']) state['m_avg2'].lerp_(state['m_avg1'] - m_avg1_prev, 1 - group['beta2_m']) u = state['m_avg1'] + state['m_avg2']200 state['v_avg'].lerp_(u.square(), 1 - group['beta_v']) u.div_(state['v_avg'].sqrt() + group['eps']) u.add_(p, alpha=group['weight_decay']) p.data.add_(u, alpha=-group['lr']) if group['lookahead_k'] > 0: if state['step'] % group['lookahead_k'] == 0: state['ema'].lerp_(p.data, 1 - group['lookahead_beta']) p.data.copy_(state['ema']) return lossdef lilith_no_lookahead(*args, **kwargs): return Lilith(*args, **kwargs, lookahead_k=0)
if name == "main": # python examples/viz_optimizers.py
# Each optimizer has tweaked search space to produce better plots and # help to converge on better lr faster. optimizers = [(Lilith, -16, 0), (lilith_no_lookahead, -16, 0)] execute_experiments(optimizers, objective_rosenbrok, rosenbrock, plot_rosenbrok, (-2.0, 2.0), )Now make necessary changes to this code to make animation: from matplotlib.animation import FuncAnimation import matplotlib.pyplot as plt import numpy as np import torch from torch.optim import Adam, SGD, Adagrad, Adadelta, AdamW, radam, RMSprop from tqdm import tqdm
Define the Rosenbrock function
def rosenbrock(xy): x, y = xy return (1 - x) ** 2 + 100 * (y - x ** 2) ** 2
def run_optimization(xy_init, optimizer_class, n_iter, function, **optimizer_kwargs): xy_t = torch.tensor(xy_init, requires_grad=True) optimizer = optimizer_class([xy_t], **optimizer_kwargs)
path = np.empty((n_iter + 1, 2)) path[0, :] = xy_init for i in tqdm(range(1, n_iter + 1)): optimizer.zero_grad() loss = function(xy_t) loss.backward() torch.nn.utils.clip_grad_norm_(xy_t, 1.0) optimizer.step() path[i, :] = xy_t.detach().numpy() return pathdef create_animation(paths, colors, names, function, function_name, figsize=(12, 12), x_lim=(-2, 2), y_lim=(-2, 2), n_seconds=15): if not (len(paths) == len(colors) == len(names)): raise ValueError
path_length = max(len(path) for path in paths) n_points = 1000 x = np.linspace(*x_lim, n_points) y = np.linspace(*y_lim, n_points) X, Y = np.meshgrid(x, y) if function_name == "Rosenbrock": Z = rosenbrock([X, Y]) minimum = (1.0, 1.0) fig, ax = plt.subplots(figsize=figsize) ax.contour(X, Y, Z, 90, cmap="jet") scatters = [ax.scatter(None, None, label=label, c=c) for c, label in zip(colors, names)] ax.legend(prop={"size": 50}) ax.plot(*minimum, "rD") def animate(i): for path, scatter in zip(paths, scatters): scatter.set_offsets(path[:i, :]) ax.set_title(str(i)) ms_per_frame = 1000 * n_seconds / path_length anim = FuncAnimation(fig, animate, frames=path_length, interval=ms_per_frame) return animif name == "main": xy_init = (.3, .8) n_iter = 3000
# path_adam_rosenbrock = run_optimization(xy_init, Adam, n_iter, rosenbrock) # path_sgd_rosenbrock = run_optimization(xy_init, SGD, n_iter, rosenbrock, lr=1e-3) freq = 10 optimizers = [Adam, SM3,]#Adafactor,CAME,SM3]# Adagrad, RMSprop, paths_rosenbrock = [run_optimization(xy_init, optimizer, n_iter, rosenbrock,lr=3e-3)[::freq] for optimizer in optimizers] colors = ["green", "brown", ]#"purple", "brown", "magenta"]# "pink", "brown", names = [optimizer.__name__ for optimizer in optimizers] anim_rosenbrock = create_animation(paths_rosenbrock, colors, names, rosenbrock, "Rosenbrock", figsize=(15, 8), x_lim=(-2.1, 2.1), y_lim=(-2.1, 2.1), n_seconds=15) anim_rosenbrock.save("SM3_rosenbrock.gif") - Assistant
To adapt the provided code to create an animation, we'll go through a series of modifications starting from the original code base towards the target functionality of animating the optimization paths. Here's an organized step-by-step guide reflecting the necessary adjustments for animation:
-
Import Required Libraries: Ensure to import
FuncAnimationfrommatplotlib.animationfor the animation capability as well as the required optimizer classes fromtorch.optim. Some optimizers, likeSM3, might not be directly available in PyTorch's standard library and might either need to be implemented manually or omitted unless you have a custom implementation available. -
Define the Optimization Function: The
run_optimizationfunction is essentially similar across both contexts. It takes an initial state, optimizer class, number of iterations, and additional arguments for the optimizer, executes the optimization on the Rosenbrock function, and tracks the path taken by the optimizer. -
Implement the Animation Creation Function: This function (
create_animation) prepares the animation by plotting the function landscape and the paths taken by different optimizers. It usesFuncAnimationto create an animation where each frame updates the positions of the optimizers on the function's landscape. -
Preparing for the Animation:
- Initialize Parameters and Optimizers: Before calling
create_animation, define the initial point, the number of iterations, and the list of optimizers to use (e.g.,Adam, other optimizers as per your modifications or available implementations). - Generate Optimization Paths: Use
run_optimizationwith each optimizer to generate their paths over the specified iterations. These paths will be used to visualize the optimization process. - Set Animation Properties: Define properties such as colors and labels for each optimizer path. These properties help differentiate between the paths of different optimizers in the animation.
- Initialize Parameters and Optimizers: Before calling
-
Execution and Saving the Animation:
- Use the
create_animationfunction to create theFuncAnimationobject by passing the relevant paths, colors, labels, and additional configuration like figure size, limits of the plot axes, and animation duration. - Save the animation using the
savemethod on theFuncAnimationobject. The format of the saved file (e.g.,"SM3_rosenbrock.gif") is determined by the file extension provided.
- Use the
Note: Ensure that all dependencies are correctly installed. Specifically,
matplotlibandtorchneed to be installed for animation and optimization functionalities, respectively. Also, keep in mind that the code snippet provided at the end has placeholders (likeSM3) that need actual implementation or replacement with available optimizers fromtorch.optim. IfSM3or other mentioned optimizers are not standard in your version of PyTorch, you will need to either implement them or substitute them with available optimizers (Adam,SGD,Adagrad,Adadelta,AdamW,RMSprop, etc.). -
- User
Dont care about SM3, write rest of the code without errors
- Assistant
Given that we will omit the
SM3optimizer due to its unavailability in the standard PyTorch library, let's focus on the remaining parts of the code to ensure smooth functionality without errors. We'll adapt the code to use readily available optimizers in PyTorch and further refine it to generate and save an animation of the optimization paths on the Rosenbrock function.Step 1: Import Necessary Libraries
import numpy as np import torch from torch.optim import Adam, SGD, RMSprop # More optimizers can be added as needed from matplotlib.animation import FuncAnimation import matplotlib.pyplot as plt from tqdm import tqdmStep 2: Define the Rosenbrock Function
def rosenbrock(xy): x, y = xy return (1 - x) ** 2 + 100 * (y - x ** 2) ** 2Step 3: Optimization Runner Function
def run_optimization(xy_init, optimizer_class, n_iter, function, **optimizer_kwargs): xy_t = torch.tensor(xy_init, dtype=torch.float32, requires_grad=True) optimizer = optimizer_class([xy_t], **optimizer_kwargs) path = np.empty((n_iter + 1, 2)) path[0, :] = xy_init for i in range(1, n_iter + 1): optimizer.zero_grad() loss = function(xy_t) loss.backward() torch.nn.utils.clip_grad_norm_(xy_t, 1.0) optimizer.step() path[i, :] = xy_t.detach().numpy() return pathStep 4: Create Animation Function
def create_animation(paths, colors, names, function, function_name, figsize=(12, 12), x_lim=(-2, 2), y_lim=(-2, 2), n_seconds=15): path_length = max(len(path) for path in paths) n_points = 1000 x = np.linspace(*x_lim, n_points) y = np.linspace(*y_lim, n_points) X, Y = np.meshgrid(x, y) Z = rosenbrock([X, Y]) minimum = (1.0, 1.0) fig, ax = plt.subplots(figsize=figsize) ax.contour(X, Y, Z, 90, cmap="jet") scatters = [ax.scatter(None, None, label=label, c=color) for color, label in zip(colors, names)] ax.legend() ax.plot(*minimum, "rD") def animate(i): for path, scatter in zip(paths, scatters): scatter.set_offsets(path[:i, :]) ax.set_title(f"Iteration: {i}") anim = FuncAnimation(fig, animate, frames=path_length, interval=(1000 * n_seconds / path_length)) return animStep 5: Script Execution Part to Generate Animation
if __name__ == "__main__": xy_init = (0.3, 0.8) n_iter = 200 # Reduce n_iter if the computation takes too long optimizers = [Adam, SGD, RMSprop] optimizer_labels = [opt.__name__ for opt in optimizers] colors = ["green", "blue", "red"] paths = [run_optimization(xy_init, opt, n_iter, rosenbrock, lr=0.001) for opt in optimizers] anim = create_animation(paths, colors, optimizer_labels, rosenbrock, "Rosenbrock", figsize=(8, 8), n_seconds=10) anim.save("rosenbrock_animation.gif", writer='imagemagick') # Ensure 'imagemagick' is installedKey Notes:
- Ensure
matplotlib,torch, andtqdmare installed in your environment. - The saved animation format depends on the availability of the
imagemagickwriter. If you encounter any issues saving the GIF, you may need to check your Matplotlib'sanimation.writerslist and install necessary dependencies. - The function signatures, variable names, and processing logic are aligned as per your request to exclude specific optimizers like
SM3while focusing on those available within PyTorch. - The
n_iterparameter controls the number of iterations for the optimization process. You might need to adjust it along with learning rates (lr) for better visualization results depending on the optimizer.
- Ensure
- User
why didnt you change my base code?
- Assistant
Regarding your initial request to adapt the existing base code to create animations without directly changing it, I misunderstood your requirements. Let's proceed by modifying the initial base code you provided to incorporate animation capabilities using
matplotlibfor visualizing the optimization path of different optimizers on the Rosenbrock function.This adjustment will directly modify the final part of your original script to include animation functionalities. We'll focus on integrating with the
FuncAnimationclass frommatplotlibto animate the optimization steps.Modifying Your Base Code for Animation
To adapt your base code for creating an animation, we'll add the animation functionality at the end of your script. This example will focus on the animation part while assuming the other functions and classes in your script remain unchanged.
# Additional imports needed for animation from matplotlib.animation import FuncAnimation # We'll modify the plot_rosenbrok function to create and return a FuncAnimation object for the animation def animated_rosenbrok(steps, optimizer_name, lr): n_iter = len(steps[0, :]) x = np.linspace(-2, 2, 250) y = np.linspace(-1, 3, 250) minimum = (1.0, 1.0) X, Y = np.meshgrid(x, y) Z = rosenbrock([X, Y]) fig, ax = plt.subplots(figsize=(8, 8)) ax.contour(X, Y, Z, 90, cmap="jet") scat = ax.scatter([], [], color="red", marker="x") # Required by FuncAnimation: initializer def init(): scat.set_offsets([]) return scat, # Required by FuncAnimation: step update def update(i): iter_x = steps[0, :i] iter_y = steps[1, :i] points = np.vstack((iter_x, iter_y)).T scat.set_offsets(points) return scat, anim = FuncAnimation(fig, update, frames=n_iter + 1, init_func=init, blit=True, interval=20) ax.set_title("Rosenbrock func: {} with lr={:.6}".format(optimizer_name, lr)) plt.plot(*minimum, "gD") # Save the animation anim_filename = "rosenbrock_animation_{}.gif".format(optimizer_name) anim.save(anim_filename, writer="imagemagick", fps=60) plt.close(fig) print("Animation saved as:", anim_filename) # Utilize the modified animation function in the execute_experiments function, replace the plot_func usage with animated_rosenbrok # This requires changing the call to animated_rosenbrok inside execute_experiments instead of plot_rosenbrok # Ensure when calling execute_experiments, the plot_rosenbrok parameter is replaced with animated_rosenbrok # For example, inside if __name__ == "__main__": block, when using execute_experimentsNotes
- This adaptation modifies
plot_rosenbroktoanimated_rosenbrok, saving the optimization path as an animated GIF rather than a static image. It leveragesFuncAnimationfor creating the animation. - The animation frames are generated based on optimizer steps; adjust the
intervalandfpsas needed to achieve the desired visualization speed. - Install
imagemagickif you haven't yet, as it's required for saving animations in GIF format frommatplotlib. - The given example assumes the rest of your code, including optimizer execution and the
execute_experimentsfunction, remains largely unchanged. Ensure to passanimated_rosenbrokin place of your plotting function when callingexecute_experimentswithin theif __name__ == "__main__":block. - The animation uses
blit=Truefor efficiency; this may not work correctly in all environments (especially non-IPython environments). If you encounter issues, play around with removingblitor adjusting thematplotlibbackend.
- This adaptation modifies