Merge pull request #491 from komaksym/add_new_problem_stepLR

Add new problem: stepLR learning rate scheduler

Author: moe18

questions/153_stepLR/description.md

@@ -0,0 +1,3 @@
+## Problem
+
+Write a Python class StepLRScheduler to implement a learning rate scheduler based on the StepLR strategy. Your class should have an __init__ method implemented to initialize with an initial_lr (float), step_size (int), and gamma (float) parameter. It should also have a **get_lr(self, epoch)** method implemented that returns the current learning rate for a given epoch (int). The learning rate should be decreased by gamma every step_size epochs. The answer should be rounded to 4 decimal places. Only use standard Python. 

questions/153_stepLR/example.json

@@ -0,0 +1,5 @@
+{
+  "input": "scheduler = StepLRScheduler(initial_lr=0.1, step_size=5, gamma=0.5)\nprint(scheduler.get_lr(epoch=0))\nprint(scheduler.get_lr(epoch=4))\nprint(scheduler.get_lr(epoch=5))\nprint(scheduler.get_lr(epoch=9))\nprint(scheduler.get_lr(epoch=10))",
+  "output": "0.1\n0.1\n0.05\n0.05\n0.025",
+  "reasoning": "The initial learning rate is 0.1. It stays 0.1 for epochs 0-4. At epoch 5, it decays by 0.5 to 0.05. It stays 0.05 for epochs 5-9. At epoch 10, it decays again to 0.025."
+}

questions/153_stepLR/learn.md

@@ -0,0 +1,39 @@
+# **Learning Rate Schedulers: StepLR**
+
+## **1. Definition**
+A **learning rate scheduler** is a component used in machine learning, especially in neural network training, to adjust the learning rate during the training process. The **learning rate** is a hyperparameter that determines the step size at each iteration while moving towards a minimum of a loss function.
+
+**StepLR (Step Learning Rate)** is a common type of learning rate scheduler that multiplicatively decays the learning rate by a fixed factor at predefined intervals (epochs). It is simple yet effective in stabilizing training and improving model performance.
+
+## **2. Why Use Learning Rate Schedulers?**
+* **Faster Convergence:** A higher initial learning rate can help quickly move through the loss landscape.
+* **Improved Performance:** A smaller learning rate towards the end of training allows for finer adjustments and helps in converging to a better local minimum, avoiding oscillations around the minimum.
+* **Stability:** Reducing the learning rate prevents large updates that could lead to divergence or instability.
+
+## **3. StepLR Mechanism**
+The learning rate is reduced by a factor γ (gamma) every step size epochs.
+
+The formula for the learning rate at a given epoch is:
+
+$$LR_e = LR_{\text{initial}} \times \gamma^{\lfloor e / \text{step size} \rfloor}$$
+
+Where:
+* $LR_e$: The learning rate at epoch e.
+* $LR_{\text{initial}}$: The initial learning rate.
+* γ (gamma): The multiplicative factor by which the learning rate is reduced (usually between 0 and 1, e.g., 0.1, 0.5).
+* step size: The interval (in epochs) after which the learning rate is decayed.
+* ⌊ · ⌋: The floor function, which rounds down to the nearest integer. This determines how many times the learning rate has been decayed.
+
+**Example:**
+If initial learning rate = 0.1, step size = 5, and γ = 0.5:
+* Epoch 0-4: $LR_e = 0.1 \times 0.5^{\lfloor 0/5 \rfloor} = 0.1 \times 0.5^0 = 0.1$
+* Epoch 5-9: $LR_e = 0.1 \times 0.5^{\lfloor 5/5 \rfloor} = 0.1 \times 0.5^1 = 0.05$
+* Epoch 10-14: $LR_e = 0.1 \times 0.5^{\lfloor 10/5 \rfloor} = 0.1 \times 0.5^2 = 0.025$
+
+## **4. Applications of Learning Rate Schedulers**
+Learning rate schedulers, including StepLR, are widely used in training various machine learning models, especially deep neural networks, across diverse applications such as:
+* **Image Classification:** Training Convolutional Neural Networks (CNNs) for tasks like object recognition.
+* **Natural Language Processing (NLP):** Training Recurrent Neural Networks (RNNs) and Transformers for tasks like machine translation, text generation, and sentiment analysis.
+* **Speech Recognition:** Training models for converting spoken language to text.
+* **Reinforcement Learning:** Optimizing policies in reinforcement learning agents.
+* **Any optimization problem:** where gradient descent or its variants are used.

questions/153_stepLR/meta.json

@@ -0,0 +1,15 @@
+{
+  "id": "153",
+  "title": "StepLR Learning Rate Scheduler",
+  "difficulty": "easy",
+  "category": "Machine Learning",
+  "video": "",
+  "likes": "0",
+  "dislikes": "0",
+  "contributor": [
+    {
+      "profile_link": "https://github.com/komaksym",
+      "name": "komaksym"
+    }
+  ]
+}

questions/153_stepLR/solution.py

@@ -0,0 +1,35 @@
+class StepLRScheduler:
+    def __init__(self, initial_lr, step_size, gamma):
+        """
+        Initializes the StepLR scheduler.
+
+        Args:
+            initial_lr (float): The initial learning rate.
+            step_size (int): The period of learning rate decay.
+                             Learning rate is decayed every `step_size` epochs.
+            gamma (float): The multiplicative factor of learning rate decay.
+                           (e.g., 0.1 for reducing LR by 10x).
+        """
+        self.initial_lr = initial_lr
+        self.step_size = step_size
+        self.gamma = gamma
+
+    def get_lr(self, epoch):
+        """
+        Calculates and returns the current learning rate for a given epoch.
+
+        Args:
+            epoch (int): The current epoch number (0-indexed).
+
+        Returns:
+            float: The calculated learning rate for the current epoch.
+        """
+        # Calculate the number of decays that have occurred.
+        # Integer division (//) in Python automatically performs the floor operation.
+        num_decays = epoch // self.step_size
+        
+        # Apply the decay factor 'gamma' raised to the power of 'num_decays'
+        # to the initial learning rate.
+        current_lr = self.initial_lr * (self.gamma ** num_decays)
+        
+        return round(current_lr, 4)

questions/153_stepLR/starter_code.py

@@ -0,0 +1,9 @@
+class StepLRScheduler:
+    def __init__(self, initial_lr, step_size, gamma):
+        # Initialize initial_lr, step_size, and gamma
+        pass
+
+    def get_lr(self, epoch):
+        # Calculate and return the learning rate for the given epoch
+        pass
+

questions/153_stepLR/tests.json

@@ -0,0 +1,34 @@
+[
+    {
+        "test": "scheduler = StepLRScheduler(initial_lr=0.1, step_size=5, gamma=0.5)\nprint(scheduler.get_lr(epoch=0))",
+        "expected_output": "0.1"
+    },
+    {
+        "test": "scheduler = StepLRScheduler(initial_lr=0.1, step_size=5, gamma=0.5)\nprint(scheduler.get_lr(epoch=4))",
+        "expected_output": "0.1"
+    },
+    {
+        "test": "scheduler = StepLRScheduler(initial_lr=0.1, step_size=5, gamma=0.5)\nprint(scheduler.get_lr(epoch=5))",
+        "expected_output": "0.05"
+    },
+    {
+        "test": "scheduler = StepLRScheduler(initial_lr=0.1, step_size=5, gamma=0.5)\nprint(scheduler.get_lr(epoch=9))",
+        "expected_output": "0.05"
+    },
+    {
+        "test": "scheduler = StepLRScheduler(initial_lr=0.1, step_size=5, gamma=0.5)\nprint(scheduler.get_lr(epoch=10))",
+        "expected_output": "0.025"
+    },
+    {
+        "test": "scheduler = StepLRScheduler(initial_lr=0.01, step_size=10, gamma=0.1)\nprint(scheduler.get_lr(epoch=0))\nprint(scheduler.get_lr(epoch=9))\nprint(scheduler.get_lr(epoch=10))\nprint(scheduler.get_lr(epoch=19))\nprint(scheduler.get_lr(epoch=20))",
+        "expected_output": "0.01\n0.01\n0.001\n0.001\n0.0001"
+    },
+    {
+        "test": "scheduler = StepLRScheduler(initial_lr=1.0, step_size=1, gamma=0.9)\nprint(round(scheduler.get_lr(epoch=0), 6))\nprint(round(scheduler.get_lr(epoch=1), 6))\nprint(round(scheduler.get_lr(epoch=2), 6))\nprint(round(scheduler.get_lr(epoch=3), 6))",
+        "expected_output": "1.0\n0.9\n0.81\n0.729"
+    },
+    {
+        "test": "scheduler = StepLRScheduler(initial_lr=0.001, step_size=50, gamma=0.5)\nprint(scheduler.get_lr(epoch=49))\nprint(scheduler.get_lr(epoch=50))\nprint(scheduler.get_lr(epoch=100))",
+        "expected_output": "0.001\n0.0005\n0.0003"
+    }
+]