Optimizer_Experimentation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **📈ADAM OPTIMIZATION FROM SCRATCH.**\n",
    "\n",
    "*Purpose: Implementing the ADAM optimizer from the ground up with PyTorch and comparing its performance on 6 3-D objective functions (each progressively more difficult to optimize) against SGD, AdaGrad, and RMSProp.*\n",
    "\n",
    "In recent years, the Adam optimizer has become famous for achieving fast and accurate results when it comes to optimizing complex stochastic loss functions - thanks to its moment estimates (as I'll explain further) and update rule, it is able to more efficiently converge to reliable local (and sometimes global) minima, and has been shown to perform remarkably well on high-dimensional objective functions due to **a very small memory requirement - the optimization method is invariant to gradient scaling and does NOT need to compute higher order derivatives, thus making it more computationally efficient.**\n",
    "\n",
    "The goal of this project is to 1️⃣ learn how optimization methods work mathematically and their theoretical behaviour (reading and taking notes on the paper + building a strong foundation of statistics), 2️⃣ apply this theoretical knowledge by constructing said optimizer from scratch in PyTorch (found in `CustomAdam.py`), and 3️⃣ test this custom implementation on six 3D functions against optimizers to determine performance. The objective of this last step was to see if I could **leverage the mathematical knowledge gained in a) to improve the optimizer** (found in `Optimizer_Experimentation.ipynb`).\n",
    "\n",
    "This project was started in an effort to replicate the original 2017 paper! Check it out for more information and a more detailed explanation of how everything works under the hood - https://arxiv.org/pdf/1412.6980.pdf."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **➗ How Adam Actually Works - The Math.**\n",
    "\n",
    "**Fundamentally, the core aspect of ML that allows machine to \"learn\" is optimization** - taking a differentiable objective (loss) function and attempting to intelligently modify the model's parameters in such a way that it results in a lower (or higher) value of this function. This is done iteratively - the optimization algorithm uses something known as the **gradient** (simply the derivative of the loss function at that point) to determine how best to update all the parameters. Each one of these updates/iterations is known as a **\"step\"**, and over a large number of steps, the model should ideally **converge to a local minima that offers arbitrarily good parameters** for convex problems. The *size* of these steps is known as the *stepsize or learning rate*, as we'll go over next.\n",
    "\n",
    "Here's a quick GIF using the standard SGD (Stochastic Gradient Descent) Optimization Algorithm (source: https://mlfromscratch.com/optimizers-explained/):\n",
    "\n",
    "<p align = \"center\"><img src = \"./images/GRADIENT-DESCENT-GIF.gif\"></img></p>\n",
    "\n",
    "**The key disadvantage of this method is that it becomes computationally expensive extremely fast.** The image above showed a model with one parameter being optimized - but, practically, most models have **dozens if not hundreds of thousands of parameters** that must be optimized. In such cases, we have to compute the **nth order derivative of some cost function $Z(θ)$** where $θ$ is a vector of all of these parameters - a task that must be repeated **for each step we take.** This quite evidently slows down the optimization process and drastically increases the compute needed as well. Furthermore, SGD without further parameters such as momentum is known to become trapped in local minima quite easily.\n",
    "\n",
    "How does Adam fix this? *By using first and second moment ESTIMATES to update parameters rather than the gradient themselves.* \n",
    "\n",
    "(**Quickly, here are some terms worth noting:**\n",
    "\n",
    "- **Expected Value:** this is given by $E[X]=∫^∞_{-∞}x*p(x)dx$, and its fundamental goal is to represent **the return you can obtain for performing some action.** In this case, $p(x)$ is the probability distribution of some random variable, and *x* is the variable itself. All in all, this gives the probability that some random event will occur.\n",
    "\n",
    "- **First Moment:** this is given by $E[X]$, and simply yields the mean value of the given data.\n",
    "\n",
    "- **Centered and Uncentered Moments:** the formula given for the expected value involves an integral; but, we can **APPROXIMATE THIS MOMENT WITH A SUM**, much like any integral can be approximated via a left or right Riemann sum. In that case, we simply do $prob * var + prob * var...$ for all the different probabilities and variables. This is known as the **uncentered** or raw moment. If we subtract the *mean from each and every variable value then we get the CENTERED moment.* Mathematically, it a centered moment would be yielded by $prob * (var - mean) + prob * (var - mean)...$ for all $n$ variables.\n",
    "\n",
    "- **Second Moment (UNCENTERED AND CENTERED):** The second moment is the same as the first moment, except for the fact that **every $x$ term is SQUARED.** So, the actual formula for a moment is $m_n=E[X^n]$, where $n$ refers to the given moment (first, second, etc.). The **second CENTERED MOMENT is the variance, whereas the second UNCENTERED moment is the uncentered variance or SQUARED DISTANCE FROM THE ORIGIN.** \n",
    "\n",
    "*P.S. - while there isn't enough room here to give full proofs of all these equations. I've broken down the math for myself as I was learning it all in one spot https://crysta.notion.site/ADAM-A-METHOD-FOR-STOCHASTIC-OPTIMIZATION-758a789b929842d4ac01281e4366f9f5; check it out and scroll to the \"Key Terms\" section for a more detailed set of definitions*.)\n",
    "\n",
    "By using these moment estimates, Adam is able to circumvent the high compute and training time for traditional optimization methods on high dimension problems. \n",
    "\n",
    "**Here's an exact breakdown of the algorithm:**\n",
    "\n",
    "1. **Initialize zero-filled tensors** for the first moment estimate $m_0$ and the second uncentered moment estimate $v_0$, and set timestep $t$ (which keeps track of what iteration we are on) to zero.\n",
    "\n",
    "(Repeat the following steps until converged)\n",
    "\n",
    "2. **Increment timestep** ($t = t+1$).\n",
    "\n",
    "3. **Obtain the gradients:** $g_t = ∇f_t(θ_{t-1})$ where f_t is the loss function, θ is the parameter vector and ∇ represents the act of taking the gradients (partial derivatives as we have more than one parameter; the derivative of a vector is known as a partial derivative) of the specified cost function. \n",
    "\n",
    "4. **Use a bias to estimate the first moment across all the gradients:** $m_t = B_1 * m_{t-1} + (1 - B_1) * g_t$. When optimizing, we want to limit the influence of outliers and one-off exploding gradients as much as possible - if the new gradient vector is substantially different than the existing ones, then we want to take the past vectors into consideration so as not to make disastrous, radically different updates. So, we add a **bias term to circumvent this - this bias decays exponentially as we progress**, thanks to the next couple of steps.\n",
    "\n",
    "5. **Estimate the second uncentered moment.** Same philosophy as the above step, but this time $v_t$ is being updated and we are taking the **SQUARE OF THE GRADIENT** since we're computing the estimate of the second raw moment: $v_t = B_2 * (v_{t-1}) + (1 - B_2) * g_t^2$.\n",
    "\n",
    "    - Note that this equation is a moment estimate - $B_2$ acts as a probability, and $v_{t-1}$ and $g_t^2$ act as the \"random\" variables ($P(x)$ and $x$ in the expected value equation). The second uncentered moment requires that we *square each X*, which is thus why $g_t$ is squared.\n",
    "\n",
    "\n",
    "6. **Correct the bias introduced in the first moment estimate:** $m^{Δ}_t=m_t/(1-B_1^t)$. I won't go into too much detail into why exactly we need to do this here, but it's relatively simple - as mentioned earlier, our \"sum\" method is an approximation of the moments instead of the true moment (which would be found by taking the integral in the expected formula). If we take the integral of the above formula to find $E[v]$, we are left with $E[g] * (1 - B_2) + C$, meaning that we are a factor of $1 - B_2$ off from the true second raw moment $E[g]$. **So, simply divide the moment estimate** $m_t$ by $1 - B_2$ **to correct for the added bias - yielding** $m^Δ$. Furthermore, note that we are dividing by 1 minus the *bias raised to the power 2.* This is, in essence, decaying the bias and **shrinking** $m^Δ$ **as** $t$ **(our current step) grows larger and larger.**\n",
    "\n",
    "7. **Correct the bias introduced in the *second* uncentered moment estimate:** $v_t^{Δ}=v_t/(1-B_2^t)$. Exact same principle as step #6, but applied to $v_t$.\n",
    "\n",
    "8. **Update the parameters:** $θ_t=θ_{t-1} - \\frac{α}{√(v^Δ_t)+ε} * m^Δ_t$. Let's break this down:\n",
    "    - $α$ represents the stepsize. This, along with $\\frac{a(1-B_1)}{√(1-B_2)}$, serve as the upper bound for the effective step that the optimizer can take. For more depth on this, checkout the \"Information about the algorithm\" section in my Notion link above, or the original paper.\n",
    "\n",
    "    - $m_t^Δ$ represents the first moment bias-corrected moment estimate computed in step 6.\n",
    "\n",
    "    - $v_t^Δ$ represents the second uncentered bias-corrected moment estimate computed in step 7.\n",
    "\n",
    "    - $ε$ is an arbitrary constant (usually 10e-8) added in the denominator to avoid division by zero. We'll be ignoring this in the next analyses, as its extremely small size makes it effectively irrelevant when taking a step.\n",
    "\n",
    "    Why are we multiplying the stepsize with $\\frac{m^Δ_t}{√(v^Δ_t)}$ ? Note that the latter is, roughly speaking, the first moment divided by the second moment - the mean divided by the mean distance from the origin. Furthermore, $v^Δ_t$ yields the AVERAGE SQUARED DISTANCE from the origin (it would yield avg. sq. distance from the mean if the moment was centered), and thus the square root is needed to yield the raw avg. sq. distance from the origin.\n",
    "\n",
    "    **In the paper, this expression** ($\\frac{m^Δ_t}{√(v^Δ_t)}$) **is known as the *signal to noise ratio*.** The idea is that we want to REDUCE the stepsize if we are more unsure of what the ideal step would be - meaning that that the value of the factor that we multiply the stepsize with should be *closer to zero/have a larger denominator* if there is more *variability* across the gradient estimates. More specifically, **if the gradients have more spread w.r.t the origin despite the mean being SMALL (0), then this indicates that there is high degree of uncertainty** - and, as the mean and the spread w.r.t the origin are both the first moment and the second uncentered moment respectively, the SNR will be a much smaller value as the denominator grows larger than the numerator. If both are high, then this means there is a strong signal for an update in a certain direction (**meaning that the SNR should be closer to one and thus allow for a step of the full stepsize**). \n",
    "\n",
    "    Fundamentally, this is a form of **stepsize annealing** - the step size is adjusted **dynamically and grows smaller and smaller as we begin approaching a minima and the gradients begin to shrink.**\n",
    "\n",
    "Here's a full picture of all of these steps summarized (as presented in the paper):\n",
    "\n",
    "<p align = \"center\"><img src = \"./images/ADAM_ALGORITHM.jpg\"></img></p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **🧪 Method and About This Experiment.**\n",
    "\n",
    "There are two key components to this repository - the custom implementation of the Adam Optimizer can be found in `CustomAdam.py`, whereas the experimentation process with all other optimizers occurs under `Optimizer_Experimentation.ipynb`. **Each optimizer is ran for 60k steps for each function (replicating one full pass through of the MNIST-dataset, one of thousands performed in the Adam paper).**\n",
    "\n",
    "The experiment setup was made in an effort to determine the performance of the custom Adam implementation against other commonly used methods. Specifically, the experiment runs CustomAdam, SGD, RMSProp, and AdaGrad on six 3-Dimensional functions (with each using the same weight initializations between ±1), each of which pose unique challenges and test different aspects of optimization (highlighting different strengths and weaknesses of each approach).\n",
    "\n",
    "Here are the six functions used in this experiment, along with a diagram and key challenges (diagram made in PowerPoint, function diagrams and equations can be found at https://www.sfu.ca/~ssurjano/optimization.html):\n",
    "\n",
    "<p align = \"center\"><img src = \"./images/LOSS_FUNCTIONS_DIAGRAM.jpg\"></img></p>\n",
    "\n",
    "There are **two key classes that make this experiment possible** - `LossFunctions`, which consists of one method for each of the above functions (each of these methods computes the listed equation with `torch` operations), and `OptimizerTest`, which tests the given optimizer against the functions specified in `Lossfunctions` and instantiates a separate instance of each optimizer for each experiment to reset the input parameters (each instance of an optimizer should be used to optimize just one function as a best practice to avoid different parameters being used for each test).\n",
    "\n",
    "**All optimizer points and results are stored inside dictionaries for plotting the end results, as seen in `Optimizer_Experimentation.py`*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **🎯 The Results.**\n",
    "\n",
    "Interestingly, the performance of all optimization functions varied wildly across all trials (test was repeated 5+ times to ensure that similar trends were taking place).\n",
    "\n",
    "Here are the results. Note that **all results are shown in symmetrical logarithmic scale.**\n",
    "\n",
    "<p align = \"center\"><img src = \".\\images\\OPTIMIZER_COMPARISON_GRAPH.png\"></img></p>\n",
    "\n",
    "Interestingly, the CustomAdam implementation is largely successful in solving virtually all the posed optimization problems. While its speed of optimization tends to be around 100-500 steps later than RMSProp (which seems to have the best performance overall when considering performance across all functions), it appears to be marginally better at avoiding local minima (as given by its non-oscillation and rapid convergence with regards to the Bukin test).\n",
    "\n",
    "Of particular interest are the Bukin and Easom function tests. As visible in the function diagrams of the previous section, the Bukin function consists of hundreds and hundreds of local minima arranged in a kind of \"ridge\" shape - meaning that if an optimizer were to get stuck in one of these local minima, it would (depending on the learning rate) begin rebounding along the edges and generate a rapidly oscillating function. That certainly is one explanation for why both RMSProp and SGD appear to form discrete \"chunks\" caused by rapid oscillation over 60k steps.\n",
    "\n",
    "However, that is not the full story - as the scale is logarithmic, it means that the difference between the peak and trough of the RMSProp oscillation is an order of magnitude smaller than the same difference of the SGD oscillation. In other words, **SGD fluctuates between 1 and 100, whereas RMSProp fluctuates between near-zero and 1.** This indicates that **despite having the same general pattern of repeated oscillation, RMSProp was able to find a local minima, whereas SGD was simply unable to converge.** A potential reason for this may be the tendency of SGD to get \"trapped\" inside local minima - RMSProp introduces exponential decay rates which prevents steps from becoming inconsequential too quickly, a problem that often plagues optimizers by the likes of AdaGrad due to excessive learning rate decay (see the original papers for said optimizers for more information on why exactly this is). Both CustomAdam and AdaGrad were able to converge without any (visible) oscillation. \n",
    "\n",
    "Regarding the Easom function, **no optimizer except AdaGrad** was able to converge here - given that the Easom function is effectively uniform with the exception of one gargantuan trough, this was to be expected. AdaGrad in particular aims to update sparse features more often than already updated ones; helping to strengthen the probability that the step taken was the most optimal not just regarding the immediate surroundings, but in the context of a certain range. Ultimately, this aids AdaGrad in making better and more \"informed\" steps towards minima.\n",
    "\n",
    "While the CustomAdam implementation converged faster in the more complex Bukin function, it speed of convergence lagged behind those of RMSProp and AdaGrad. Empirical evidence suggests some reasons for this - whereas the exponential moving averages (moment estimates) used in Adam prevent against excessive stepsize decay by weighting new gradients higher than previous one, it is often **rare in practice that these new gradients are large enough to provide meaningful signals - and in cases that they do, exponential decay makes it so that they become nearly irrelevant after just a certain number of steps (thus hindering convergence).** This is particularly the case with **nonconvex optimization problems**, such as the aforementioned Easom function - and explains how **AdaGrad (which has no decay) was able to converge, whereas decay-based optimization methods such as the CustomAdam implementation and RMSProp both failed to converge.** Further empirical evidence has also shown that **Adam and adaptive gradient descent techniques can, in high-parameter models, generalize *worse on average than simply using SGD!***\n",
    "\n",
    "(Here are the papers describing these effects: https://openreview.net/forum?id=ryQu7f-RZ, http://www.cs.toronto.edu/~sajadn/sajad_norouzi/ECE1505.pdf)\n",
    "\n",
    "All in all, there is certainly tremendous room for further growth and exploration in the performance of these optimizers - in fact, several new optimizers have arisen in recent years to address the aforementioned problems. \n",
    "\n",
    "🪜**Next steps involve:**\n",
    " - Testing on higher dimensional functions to determine if the theoretical memory benefits of Adam hold true, \n",
    " - Attempting to solve the above problems by creating a new optimizer from scratch,\n",
    " - Testing said functions on more non-convex functions, and\n",
    " - Using the points dictionary to generate real-time animations of the optimizers as they take steps!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **🔑 Key Learnings.**\n",
    "\n",
    "1. 🏛️**The inner workings of optimizers and statistics fundamentals, from both a theoretical and practical perspective.** Reading through the original Adam paper, taking notes, and re-implementing the optimizer combined gave me a stronger intuition about the nature of optimization functions and the mathematics behind parameter tuning than any one of those things could have taught me individually. The theoretical aspect aided in solidifying why it was that Adam actually worked (key proofs and formulas that explained common real-world occurrences), whereas the practical aspect better acquainted me with how libraries such as PyTorch work in the backend (leaf tensors and views) and **important practical considerations when converting a theoretical optimizer into raw flesh and blood.**\n",
    "\n",
    "2. 📊**Why certain optimizers converge better than others.** As mentioned in the results section, simple things such as exponential decay can drastically influence the ability of optimization methods to converge; and allow more simple optimizers to sometimes perform better than adaptive methods. On the other hand, these same simple optimizers (SGD without momentum in particular) have a greater tendency to get stuck in local minima. As usual, it appears that **the best solution may lie in ensembles of optimizers as opposed to relying on just one method - combining the pros of each to obtain the best of each world.**\n",
    "   \n",
    "3. 🧪 **Best practices in terms of validating optimization methods** - or, the importance of using non-convex and local-minima-riddled functions to test optimizers. These types of functions often highlight discrepancies and major faults/weaknesses between various methods and can help open the floor for further analysis (as was the case under the results section).\n",
    "\n",
    "All things considered, this project 10x-ed my understanding of the mathematics behind machine learning and revealed interesting problems in terms of both tuning hyperparameters and optimizing parameters on high-dimensional functions. Excited to see what comes next!\n",
    "\n",
    "*Special thanks to Diederik P. Kingma and Jimmy Lei Ba for writing the original paper! Very fascinating read and was a blast to replicate.* 😄"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Import libraries\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#We want to test different optimizers using different optimizer evaluation functions\n",
    "#Run each optimizer across a) the Rosenbrock function, b) Local Minima filled functions, c) Bowl-Shaped functions, d) Plate-Shaped functions\n",
    "# and e) Functions with Steep drops\n",
    "\n",
    "#After running each optimizer across these functions, take the average across all functions and plot to determine average performance\n",
    "#Generate x data for each test - use same initialization distribution to ensure reproducibility and fairness while testing\n",
    "import math\n",
    "\n",
    "#Class to test optimizer\n",
    "class OptimizerTest():\n",
    "    #Initialize optimizer testing object\n",
    "    def __init__(self, Optimizer, epochs, params, **opt_args):\n",
    "        #Set the parameters to an initial x and y value, optimize_(var) variables will be modiifed in the optimization process via the optimizeParams() method\n",
    "        self.params = params\n",
    "        #Set both the initial and optimized versions of x and y to COPIES of the original parameter such as to not modify the input tensor\n",
    "        self.initial_x, self.initial_y = torch.clone(self.params)\n",
    "        #Save optional arguments for future object creation\n",
    "        self.opt_args = opt_args\n",
    "        #Save optimizer type for same purpose\n",
    "        self.optimizer_type = Optimizer\n",
    "        #Instantiate new Optimizer object - check if optional keyword arguments (specific arguments for the optimizer) have been provided\n",
    "        if self.opt_args != {}:\n",
    "            self.vals = [args for args in self.opt_args.values()]\n",
    "            self.optimizer = Optimizer([self.params], *self.vals)\n",
    "        else: self.optimizer = Optimizer([self.params])\n",
    "        #Set both the initial and optimized versions of x and y to COPIES of the original parameter such as to not modify the input tensor\n",
    "        self.initial_x, self.initial_y = torch.clone(self.params)\n",
    "        #Set epochs\n",
    "        self.epochs = epochs\n",
    "\n",
    "    #Optimize the loss function on a given loss function\n",
    "    def optimizeParams(self, loss_function):\n",
    "        #Fit the given 3D function\n",
    "        #Store losses (z values) obtained via optimizing this function\n",
    "        losses = []\n",
    "        points = []\n",
    "        #Iterate over number of epochs\n",
    "        for epoch in range(self.epochs):\n",
    "            #Set all gradients to zero - this is to prevent gradient accumulation as they do not reset per epoch\n",
    "            self.optimizer.zero_grad()\n",
    "            #Compute the loss\n",
    "            x, y = self.params\n",
    "            loss = loss_function(x, y)\n",
    "            #Compute the gradients\n",
    "            loss.backward()\n",
    "            #Run the optimizer\n",
    "            self.optimizer.step()\n",
    "            #Add loss to loss array - use item() for both this append and the next one to extract the raw scalar as opposed to adding the tensor\n",
    "            #Adding the tensor directly causes unexpected behaviour as the optimizer directly modifies the base; thereby changing all views and raising exceptions\n",
    "            losses.append(loss.item())\n",
    "            #Append points to point array for visualization and evaluation\n",
    "            points.append([x.item(), y.item(), loss.item()])\n",
    "        #Add losses array to dictionary of all optimization functions\n",
    "        #To find the name of the function given, use the .__name__ method\n",
    "        self.all_losses[\"{}\".format(loss_function.__name__)] = losses\n",
    "        self.all_points[\"{}\".format(loss_function.__name__)] = points\n",
    "        \n",
    "    #Method to run tests - create a new LossFunctions object, and run the optimization method on all of those functions\n",
    "    def runTests(self):\n",
    "        #Create dictionary of all losses\n",
    "        self.all_losses = {}\n",
    "        #Create dictionary of all points\n",
    "        self.all_points = {}\n",
    "        #Create new LossFunctions object to obtain various testing functions\n",
    "        TestFunctions = LossFunctions(self.params)\n",
    "        #Define list of loss functions we would like to optimize from Lossfunctions\n",
    "        self.loss_opt_funcs = [\"RosenbrockLoss\", \"BukinLoss\", \"BohachevskyLoss\", \"BoothLoss\", \"CamelLoss\", \"EasomLoss\"]\n",
    "        #Optimize each given loss function (call optimizeParams for each function in the list)\n",
    "        for loss_func in self.loss_opt_funcs:\n",
    "            func = eval('TestFunctions.{}'.format(loss_func))\n",
    "            self.optimizeParams(func)\n",
    "            #Reset the optimized parameters back to the initial values - this ensures that each test starts off with the same values\n",
    "            self.params = torch.tensor((self.initial_x, self.initial_y), requires_grad = True, dtype = torch.float64)\n",
    "            #Create a new optimizer object - each instance of the optimizer is meant to optimize one loss function\n",
    "            #As the optimization task is done, create a new instance of the optimizer\n",
    "            if self.opt_args != {}:\n",
    "                self.vals = [args for args in self.opt_args.values()]\n",
    "                self.optimizer = self.optimizer_type([self.params], *self.vals)\n",
    "            else: self.optimizer = self.optimizer_type([self.params]) \n",
    "        return self.all_losses, self.all_points\n",
    "    \n",
    "#Define class of all loss functions being used\n",
    "#Methods to calculate the losses dependent on the function - given a set of x and y points, these functions will determine the respective z coordinate (which is our loss)\n",
    "#The optimizers chosen will need to optimize this function and arive at its local minima; as all have two input parameters, they form a three dimensional graph\n",
    "class LossFunctions():\n",
    "    #Initialize x and y values from params upon initialization - these are the x and y values that each test will start with (before they are updated)\n",
    "    def __init__(self, params): self.initial_x, self.initial_y = params\n",
    "\n",
    "    #Rosenbrock function - one of the most famous functions for evaluating optimization methods\n",
    "    def RosenbrockLoss(self, x, y):\n",
    "        term_1 = torch.pow(1.0 - x, 2)\n",
    "        term_2 = 100 * torch.pow(torch.subtract(y, torch.pow(x, 2)), 2)\n",
    "        return torch.add(term_1, term_2)\n",
    "\n",
    "    #Bukin Function (testing for many local minima)\n",
    "    def BukinLoss(self, x, y):\n",
    "        #Equation - z = 100sqr(|y-0.01x^2|)+0.01(x+10)\n",
    "        term_1 = 100 * torch.abs(y - (0.01 * torch.pow(x, 2)))\n",
    "        return term_1 + (0.01 * torch.abs(x + 10))\n",
    "\n",
    "    #Bohachevsky Functions (testing to see if optimizer works on bowl-shaped functions)\n",
    "    def BohachevskyLoss(self, x, y):\n",
    "        #Equation - z = x^2 + 2y^2 - 0.3cos(3pix) - 0.4cos(4piy) + 0.7\n",
    "        cosine_term_1 = 0.3 * torch.cos(3 * math.pi * x)\n",
    "        cosine_term_2 = 0.4 * torch.cos(4 * math.pi * x)\n",
    "        return torch.pow(x, 2) + (2 * torch.pow(y, 2)) - cosine_term_1 - cosine_term_2 + 0.7\n",
    "    \n",
    "    #Booth Function (Plate shaped function)\n",
    "    def BoothLoss(self, x, y):\n",
    "        #Equation - z = (x + 2y - 7)^2 + (2x + y -5)^2\n",
    "        term_1 = torch.pow(x + (2 * y) - 7, 2)\n",
    "        term_2 = torch.pow(2 * x - 5, 2)\n",
    "        return term_1 + term_2\n",
    "    \n",
    "    #\"Six-Hump\" Camel function (function with six local minima)\n",
    "    def CamelLoss(self, x, y):\n",
    "        #Equation - z = (4 - 2.1x^2 + x^4/3)x^2 + xy + (-4 + 4y^2)y^2\n",
    "        term_1 = torch.mul(4 - 2.1 * torch.pow(x, 2) + (torch.pow(x, 4)/3), torch.pow(x, 2))\n",
    "        term_3 = torch.mul((-4 + 4*torch.pow(y, 2)), torch.pow(y, 2))\n",
    "        return term_1 + torch.mul(x, y) + term_3\n",
    "    \n",
    "    #Easom Function (has very steep drops but is otherwise unimodal - the minimum takes a small space relative to the search space of the function)\n",
    "    def EasomLoss(self, x, y):\n",
    "        #Equation - z = -cos(x)cos(y)exp(-(x-pi)^2-(y-pi)^2)\n",
    "        cosine_term = - torch.mul(torch.cos(x), torch.cos(y))\n",
    "        exponential_term = torch.subtract(-torch.pow(x - math.pi, 2), torch.pow(y - math.pi, 2))\n",
    "        return torch.mul(cosine_term, torch.exp(exponential_term))\n",
    "\n",
    "#Function to calculate the loss (Euclidean distance between current point and global minima)\n",
    "#The loss will be the DISTANCE from the local minima to the gradient - we're measuring how fast the optimizer can reach this minima\n",
    "def computeEuclideanLoss(current_point, global_minima):\n",
    "    #Compute the squared difference between the two vectors\n",
    "    squared_difference = torch.float_power(torch.subtract(current_point, global_minima), 2.0)\n",
    "    #Add all squared differences, convert the resulting scalar to a float, and then take the square root\n",
    "    return torch.sqrt(torch.sum(squared_difference))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Initialize x and y vectors - 3D functions will be written in the form z(x, y)\n",
    "#Both x and y will be initialized with normal distributions from ranges -5 to 5\n",
    "from random import uniform\n",
    "x = uniform(-1, 1)\n",
    "y = uniform(-1, 1)\n",
    "#Create tuple and convert to tensor\n",
    "XY = (x, y)\n",
    "\n",
    "#Import Custom Adam Optimizer Implementation and all other optimizers\n",
    "from CustomAdam import CustomAdam\n",
    "from torch.optim import SGD, Adagrad, RMSprop\n",
    "#List of all optimizers\n",
    "optimizers = [\"CustomAdam\", \"SGD\", \"Adagrad\", \"RMSprop\"]\n",
    "#Dictionary of all losses\n",
    "optimizer_losses = {}\n",
    "#Dictionary of all points traversed during the optimization process\n",
    "optimizer_points = {}\n",
    "#List of all objective functions\n",
    "loss_funcs = [\"Rosenbrock\", \"Bukin\", \"Bohachevsky\", \"Booth\", \"Camel\", \"Easom\"]\n",
    "\n",
    "#Number of steps to run optimizers - the Adam paper iterated 200 times over the entire MNIST dataset (roughly 60k * 200 steps)\n",
    "#Taking compute into account, the optimizer will run for 60k steps (once over the dataset)\n",
    "steps = 60000\n",
    "#Iterate over all optimizers\n",
    "for opt in optimizers:\n",
    "    #Redefine every iteration as these parameters are optimzied and therefore modified - we want the same set of parameters to be passed into all optimizer tests\n",
    "    #Redefining the tensor also cuts off all existing gradients\n",
    "    XY_TENSOR = torch.tensor(XY, requires_grad = True, dtype = torch.float64)\n",
    "    #Run optimizer tests on given tensor - create a new Optimizer test object and call runTests()\n",
    "    #If the optimizer is SGD, add the required learning rate parameter (same as the Adam stepsize)\n",
    "    if opt == \"SGD\":\n",
    "        TestInstance = OptimizerTest(Optimizer = eval(opt), epochs = steps, params = XY_TENSOR, lr = 0.001)\n",
    "    else: TestInstance = OptimizerTest(Optimizer = eval(opt), epochs = steps, params = XY_TENSOR)\n",
    "    optimizer_losses[opt], optimizer_points[opt] = TestInstance.runTests()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1728x1296 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot losses for each test function and compare to determine optimizer convergence speed and duration\n",
    "#Import libraries\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "#Create subplot\n",
    "loss_plot, [[Rosenbrock_ax, Bukin_ax], [Bohachevsky_ax, Booth_ax], [Camel_ax, Easom_ax]] = plt.subplots(3, 2, figsize = (24, 18))\n",
    "#Function to plot losses for a particular objective function w.r.t all optimizers\n",
    "def plotLosses(loss_func):\n",
    "    #Iterate over each optimizer\n",
    "    for optimizer in optimizers:\n",
    "        #Plot optimizer's losses over the # of epochs\n",
    "        globals()[loss_func + \"_ax\"].plot(optimizer_losses[optimizer][loss_func + \"Loss\"], label = optimizer)\n",
    "    #Set title and x and y labels\n",
    "    globals()[loss_func + \"_ax\"].set_title(loss_func.upper() + \" FUNCTION OPTIMIZATION.\")\n",
    "    globals()[loss_func + \"_ax\"].set_xlabel(\"# OF STEPS\")\n",
    "    globals()[loss_func + \"_ax\"].set_ylabel(\"Z VALUE (LOSS)\")\n",
    "    #Display legend\n",
    "    globals()[loss_func + \"_ax\"].legend(loc = \"upper right\")\n",
    "    #Set to logarithmic scale to better see differences in updates as loss values become increasingly small\n",
    "    globals()[loss_func + \"_ax\"].set_yscale(\"symlog\")\n",
    "\n",
    "#Plot losses for each loss function\n",
    "for loss_func in loss_funcs:\n",
    "    plotLosses(loss_func)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "dddb19642e9b394136ddc94a498b5755938c06ddbfeeb7fe6324263f04d0baab"
  },
  "kernelspec": {
   "display_name": "Python 3.10.4 ('ml_mastery_replicates')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}