enhancement #13508

athikha · athikha · commit 2da7ea8aa5e3 · 2025-10-15T16:12:52.000+05:30
diff --git a/simulated_annealing/README.md b/simulated_annealing/README.md
@@ -0,0 +1,24 @@
+Simulated Annealing
+===================
+
+This package provides a simple Simulated Annealing optimizer and a Tkinter GUI to explore parameters and visualize optimization progress.
+
+Files
+- `simulated_annealing.py` - core optimizer (class `SimulatedAnnealing`)
+- `example.py` - example functions and CLI demo
+- `gui.py` - Tkinter GUI with embedded matplotlib plot
+
+Quick start
+-----------
+
+Run the GUI:
+
+```bash
+python -m simulated_annealing.gui
+```
+
+Run the CLI example:
+
+```bash
+python -m simulated_annealing.example
+```
diff --git a/simulated_annealing/__init__.py b/simulated_annealing/__init__.py
@@ -0,0 +1,10 @@
+"""Simulated Annealing package
+
+Exports:
+- SimulatedAnnealing: core optimizer class
+- example_functions: a small collection of test functions
+"""
+from .simulated_annealing import SimulatedAnnealing
+from .example import example_functions
+
+__all__ = ["SimulatedAnnealing", "example_functions"]
diff --git a/simulated_annealing/example.py b/simulated_annealing/example.py
@@ -0,0 +1,33 @@
+from typing import Callable, Dict, Sequence
+
+
+def sphere(x: Sequence[float]) -> float:
+    return sum(v * v for v in x)
+
+
+def rastrigin(x: Sequence[float]) -> float:
+    # Rastrigin function (common test function)
+    A = 10
+    return A * len(x) + sum((v * v - A * __import__("math").cos(2 * __import__("math").pi * v)) for v in x)
+
+
+example_functions: Dict[str, Callable[[Sequence[float]], float]] = {
+    "sphere": sphere,
+    "rastrigin": rastrigin,
+}
+
+
+def cli_example():
+    # CLI demo minimizing 2D sphere
+    from .simulated_annealing import SimulatedAnnealing
+    func = sphere
+    initial = [5.0, -3.0]
+    bounds = [(-10, 10), (-10, 10)]
+    sa = SimulatedAnnealing(func, initial, bounds=bounds, temperature=50, cooling_rate=0.95, iterations_per_temp=200)
+    best, cost, history = sa.optimize()
+    print("Best:", best)
+    print("Cost:", cost)
+
+
+if __name__ == "__main__":
+    cli_example()
diff --git a/simulated_annealing/gui.py b/simulated_annealing/gui.py
@@ -0,0 +1,157 @@
+import threading
+import tkinter as tk
+from tkinter import ttk, messagebox
+from typing import Optional
+
+import matplotlib
+matplotlib.use("TkAgg")
+from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
+import matplotlib.pyplot as plt
+
+from .simulated_annealing import SimulatedAnnealing
+from .example import example_functions
+
+
+class SA_GUI(tk.Tk):
+    def __init__(self):
+        super().__init__()
+        self.title("Simulated Annealing Explorer")
+        self.geometry("800x600")
+
+        # Left: controls
+        ctrl = ttk.Frame(self)
+        ctrl.pack(side=tk.LEFT, fill=tk.Y, padx=8, pady=8)
+
+        ttk.Label(ctrl, text="Function:").pack(anchor=tk.W)
+        self.func_var = tk.StringVar(value="sphere")
+        func_menu = ttk.Combobox(ctrl, textvariable=self.func_var, values=list(example_functions.keys()), state="readonly")
+        func_menu.pack(fill=tk.X)
+
+        ttk.Label(ctrl, text="Initial (comma-separated)").pack(anchor=tk.W, pady=(8, 0))
+        self.init_entry = ttk.Entry(ctrl)
+        self.init_entry.insert(0, "5, -3")
+        self.init_entry.pack(fill=tk.X)
+
+        ttk.Label(ctrl, text="Bounds (lo:hi comma-separated for each)").pack(anchor=tk.W, pady=(8, 0))
+        self.bounds_entry = ttk.Entry(ctrl)
+        self.bounds_entry.insert(0, "-10:10, -10:10")
+        self.bounds_entry.pack(fill=tk.X)
+
+        ttk.Label(ctrl, text="Temperature").pack(anchor=tk.W, pady=(8, 0))
+        self.temp_entry = ttk.Entry(ctrl)
+        self.temp_entry.insert(0, "50")
+        self.temp_entry.pack(fill=tk.X)
+
+        ttk.Label(ctrl, text="Cooling rate").pack(anchor=tk.W, pady=(8, 0))
+        self.cool_entry = ttk.Entry(ctrl)
+        self.cool_entry.insert(0, "0.95")
+        self.cool_entry.pack(fill=tk.X)
+
+        ttk.Label(ctrl, text="Iterations per temp").pack(anchor=tk.W, pady=(8, 0))
+        self.iter_entry = ttk.Entry(ctrl)
+        self.iter_entry.insert(0, "200")
+        self.iter_entry.pack(fill=tk.X)
+
+        self.run_btn = ttk.Button(ctrl, text="Run", command=self._on_run)
+        self.run_btn.pack(fill=tk.X, pady=(12, 0))
+
+        self.stop_flag = threading.Event()
+        self.stop_btn = ttk.Button(ctrl, text="Stop", command=self._on_stop, state=tk.DISABLED)
+        self.stop_btn.pack(fill=tk.X, pady=(6, 0))
+
+        # Right: plot
+        fig, self.ax = plt.subplots(figsize=(5, 4))
+        self.fig = fig
+        self.canvas = FigureCanvasTkAgg(fig, master=self)
+        self.canvas.get_tk_widget().pack(side=tk.RIGHT, fill=tk.BOTH, expand=1)
+
+        self._plot_line, = self.ax.plot([], [], label="best_cost")
+        self.ax.set_xlabel("Iterations")
+        self.ax.set_ylabel("Best cost")
+        self.ax.grid(True)
+
+    def _parse_initial(self) -> list:
+        raw = self.init_entry.get().strip()
+        parts = [p.strip() for p in raw.split(",") if p.strip()]
+        return [float(p) for p in parts]
+
+    def _parse_bounds(self, dim: int):
+        raw = self.bounds_entry.get().strip()
+        parts = [p.strip() for p in raw.split(",") if p.strip()]
+        bounds = []
+        for p in parts:
+            if ":" in p:
+                lo, hi = p.split(":", 1)
+                bounds.append((float(lo), float(hi)))
+            else:
+                # single number -> symmetric
+                val = float(p)
+                bounds.append((-abs(val), abs(val)))
+        # if fewer provided, extend with wide bounds
+        while len(bounds) < dim:
+            bounds.append((-1e6, 1e6))
+        return bounds[:dim]
+
+    def _on_run(self):
+        try:
+            initial = self._parse_initial()
+        except Exception as e:
+            messagebox.showerror("Input error", f"Invalid initial: {e}")
+            return
+
+        func_name = self.func_var.get()
+        func = example_functions.get(func_name)
+        if func is None:
+            messagebox.showerror("Input error", "Unknown function")
+            return
+
+        try:
+            temp = float(self.temp_entry.get())
+            cooling = float(self.cool_entry.get())
+            iterations = int(self.iter_entry.get())
+        except Exception as e:
+            messagebox.showerror("Input error", f"Invalid numeric param: {e}")
+            return
+
+        bounds = self._parse_bounds(len(initial))
+
+        self.run_btn.config(state=tk.DISABLED)
+        self.stop_btn.config(state=tk.NORMAL)
+        self.stop_flag.clear()
+
+        def worker():
+            sa = SimulatedAnnealing(func, initial, bounds=bounds, temperature=temp, cooling_rate=cooling, iterations_per_temp=iterations)
+            best, cost, history = sa.optimize()
+            # update plot on main thread
+            self.after(0, lambda: self._on_complete(best, cost, history))
+
+        t = threading.Thread(target=worker, daemon=True)
+        t.start()
+
+    def _on_stop(self):
+        # currently we don't have a cooperative stop in the algorithm; inform user
+        messagebox.showinfo("Stop", "Stop requested, but immediate stop is not implemented. The run will finish current loop.")
+
+    def _on_complete(self, best, cost, history):
+        x = list(range(len(history.get("best_costs", []))))
+        y = history.get("best_costs", [])
+        self.ax.clear()
+        self.ax.plot(x, y, label="best_cost")
+        self.ax.set_xlabel("Iterations")
+        self.ax.set_ylabel("Best cost")
+        self.ax.grid(True)
+        self.ax.legend()
+        self.canvas.draw()
+
+        messagebox.showinfo("Done", f"Best cost: {cost:.6g}\nBest solution: {best}")
+        self.run_btn.config(state=tk.NORMAL)
+        self.stop_btn.config(state=tk.DISABLED)
+
+
+def main():
+    app = SA_GUI()
+    app.mainloop()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/simulated_annealing/simulated_annealing.py b/simulated_annealing/simulated_annealing.py
@@ -0,0 +1,119 @@
+import math
+import random
+from typing import Callable, Sequence, Tuple, List, Optional
+
+
+class SimulatedAnnealing:
+    """Generic Simulated Annealing optimizer for continuous domains.
+
+    Usage:
+        sa = SimulatedAnnealing(func, initial_solution, bounds=..., **params)
+        best, best_cost, history = sa.optimize()
+    """
+
+    def __init__(
+        self,
+        func: Callable[[Sequence[float]], float],
+        initial_solution: Sequence[float],
+        bounds: Optional[Sequence[Tuple[float, float]]] = None,
+        temperature: float = 100.0,
+        cooling_rate: float = 0.99,
+        min_temperature: float = 1e-3,
+        iterations_per_temp: int = 100,
+        neighbor_scale: float = 0.1,
+        seed: Optional[int] = None,
+    ):
+        self.func = func
+        self.current = list(initial_solution)
+        self.dim = len(initial_solution)
+        self.bounds = bounds
+        self.temperature = float(temperature)
+        self.initial_temperature = float(temperature)
+        self.cooling_rate = float(cooling_rate)
+        self.min_temperature = float(min_temperature)
+        self.iterations_per_temp = int(iterations_per_temp)
+        self.neighbor_scale = float(neighbor_scale)
+        if seed is not None:
+            random.seed(seed)
+
+    def _clip(self, x: float, i: int) -> float:
+        if not self.bounds:
+            return x
+        lo, hi = self.bounds[i]
+        return max(lo, min(hi, x))
+
+    def _neighbor(self, solution: Sequence[float]) -> List[float]:
+        # Gaussian perturbation scaled by neighbor_scale and variable range
+        new = []
+        for i, v in enumerate(solution):
+            scale = self.neighbor_scale
+            if self.bounds:
+                lo, hi = self.bounds[i]
+                rng = (hi - lo) if hi > lo else 1.0
+                scale = self.neighbor_scale * rng
+            candidate = v + random.gauss(0, scale)
+            candidate = self._clip(candidate, i)
+            new.append(candidate)
+        return new
+
+    def _accept(self, delta: float, temp: float) -> bool:
+        if delta < 0:
+            return True
+        try:
+            prob = math.exp(-delta / temp)
+        except OverflowError:
+            prob = 0.0
+        return random.random() < prob
+
+    def optimize(self, max_steps: Optional[int] = None) -> Tuple[List[float], float, dict]:
+        """Run optimization and return best solution, cost, and history.
+
+        history dict contains: temps, best_costs, current_costs
+        """
+        temp = self.temperature
+        current = list(self.current)
+        current_cost = float(self.func(current))
+        best = list(current)
+        best_cost = current_cost
+
+        history = {"temps": [], "best_costs": [], "current_costs": []}
+
+        steps = 0
+        while temp > self.min_temperature:
+            for _ in range(self.iterations_per_temp):
+                candidate = self._neighbor(current)
+                candidate_cost = float(self.func(candidate))
+                delta = candidate_cost - current_cost
+                if self._accept(delta, temp):
+                    current = candidate
+                    current_cost = candidate_cost
+                    if current_cost < best_cost:
+                        best = list(current)
+                        best_cost = current_cost
+
+                history["temps"].append(temp)
+                history["best_costs"].append(best_cost)
+                history["current_costs"].append(current_cost)
+
+                steps += 1
+                if max_steps is not None and steps >= max_steps:
+                    self.current = current
+                    return best, best_cost, history
+
+            # Cool down
+            temp *= self.cooling_rate
+
+        self.current = current
+        return best, best_cost, history
+
+
+def _test_quadratic():
+    # Simple test: minimize f(x) = (x-3)^2
+    func = lambda x: (x[0] - 3) ** 2
+    sa = SimulatedAnnealing(func, [0.0], bounds=[(-10, 10)], temperature=10, iterations_per_temp=50)
+    best, cost, hist = sa.optimize()
+    print("best:", best, "cost:", cost)
+
+
+if __name__ == "__main__":
+    _test_quadratic()
