Create app.py

app.py

@@ -0,0 +1,500 @@
+import numpy as np
+import math
+import matplotlib.pyplot as plt
+from io import BytesIO
+from PIL import Image
+import gradio as gr
+from mpl_toolkits.mplot3d import Axes3D
+
+class Objective:
+    def Evaluate(self, p):
+        return -5.0*np.exp(-0.5*((p[0]+2.2)**2/0.4+(p[1]-4.3)**2/0.4)) + -2.0*np.exp(-0.5*((p[0]-2.2)**2/0.4+(p[1]+4.3)**2/0.4))
+
+# Create an instance of the Objective class
+obj = Objective()
+
+# Evaluate the fitness of a position
+position = np.array([-2.2, 4.3])
+fitness = obj.Evaluate(position)
+
+print(f"The fitness of the position {position} is {fitness}")
+
+class Bounds:
+    def __init__(self, lower, upper, enforce="clip"):
+        self.lower = np.array(lower)
+        self.upper = np.array(upper)
+        self.enforce = enforce.lower()
+    
+    def Upper(self): 
+        return self.upper
+    
+    def Lower(self): 
+        return self.lower
+    
+    def Limits(self, pos): 
+        npart, ndim = pos.shape 
+        for i in range(npart):
+            for j in range(ndim):
+                if pos[i, j] < self.lower[j]:
+                    if self.enforce == "clip":
+                        pos[i, j] = self.lower[j]
+                    elif self.enforce == "resample":
+                        pos[i, j] = self.lower[j] + np.random.random() * (self.upper[j] - self.lower[j])
+                elif pos[i, j] > self.upper[j]:
+                    if self.enforce == "clip":
+                        pos[i, j] = self.upper[j]
+                    elif self.enforce == "resample":
+                        pos[i, j] = self.lower[j] + np.random.random() * (self.upper[j] - self.lower[j])
+            pos[i] = self.Validate(pos[i]) 
+        return pos
+    
+    def Validate(self, pos):
+        return pos
+
+# Define the bounds
+lower_bounds = [-6, -6]
+upper_bounds = [6, 6]
+
+# Create an instance of the Bounds class
+bounds = Bounds(lower_bounds, upper_bounds, enforce="clip")
+
+# Define a set of positions
+positions = np.array([[15, 15], [-15, -15], [5, 15], [15, 5]])
+
+# Enforce the bounds on the positions
+valid_positions = bounds.Limits(positions)
+
+print(f"Valid positions: {valid_positions}")
+
+# Define the bounds
+lower_bounds = [-6, -6]
+upper_bounds = [6, 6]
+
+# Create an instance of the Bounds class
+bounds = Bounds(lower_bounds, upper_bounds, enforce="resample")
+
+# Define a set of positions
+positions = np.array([[15, 15], [-15, -15], [5, 15], [15, 5]])
+
+# Enforce the bounds on the positions
+valid_positions = bounds.Limits(positions)
+
+print(f"Valid positions: {valid_positions}")
+
+class QuasiRandomInitializer:
+    def __init__(self, npart=10, ndim=2, bounds=None, k=1, jitter=0.0):
+        self.npart = npart
+        self.ndim = ndim
+        self.bounds = bounds
+        self.k = k
+        self.jitter = jitter
+        self.primes = [
+            2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,
+            101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197,
+            199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313,
+            317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439,
+            443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571,
+            577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659
+        ]
+
+    def Halton(self, i, b):
+        f = 1.0
+        r = 0
+        while i > 0:
+            f = f / b
+            r = r + f * (i % b)
+            i = math.floor(i / b)
+        return r
+
+    def InitializeSwarm(self):
+        self.swarm = np.zeros((self.npart, self.ndim))
+        lo = np.zeros(self.ndim)
+        hi = np.ones(self.ndim)
+        if self.bounds is not None:
+            lo = self.bounds.Lower()
+            hi = self.bounds.Upper()
+
+        for i in range(self.npart):
+            for j in range(self.ndim):
+                h = self.Halton(i + self.k, self.primes[j % len(self.primes)])
+                q = self.jitter * (np.random.random() - 0.5)
+                self.swarm[i, j] = lo[j] + (hi[j] - lo[j]) * h + q
+
+        if self.bounds is not None:
+            self.swarm = self.bounds.Limits(self.swarm)
+
+        return self.swarm
+
+# Define the bounds
+lower_bounds = [-6, -6]
+upper_bounds = [6, 6]
+bounds = Bounds(lower_bounds, upper_bounds, enforce="clip")
+
+# Create an instance of the QuasiRandomInitializer class
+init = QuasiRandomInitializer(npart=50, ndim=2, bounds=bounds)
+
+# Initialize the swarm
+swarm_positions = init.InitializeSwarm()
+
+print(f"Initial swarm positions: {swarm_positions}")
+
+# Define the bounds
+lower_bounds = [-6, -6]
+upper_bounds = [6, 6]
+bounds = Bounds(lower_bounds, upper_bounds, enforce="resample")
+
+# Create an instance of the QuasiRandomInitializer class
+init = QuasiRandomInitializer(npart=50, ndim=2, bounds=bounds)
+
+# Initialize the swarm
+swarm_positions = init.InitializeSwarm()
+
+print(f"Initial swarm positions: {swarm_positions}")
+
+class GWO:
+    def __init__(self, obj, eta=2.0, npart=10, ndim=2, max_iter=200,tol=None,init=None,done=None,bounds=None):   
+            self.obj = obj
+            self.npart = npart
+            self.ndim = ndim
+            self.max_iter = max_iter
+            self.init = init
+            self.done = done
+            self.bounds = bounds
+            self.tol = tol
+            self.eta = eta
+            self.initialized = False
+        
+    def Initialize(self):
+        """Set up the swarm"""
+
+        self.initialized = True
+        self.iterations = 0
+       
+        self.pos = self.init.InitializeSwarm()  # initial swarm positions
+        self.vpos= np.zeros(self.npart)
+        for i in range(self.npart):
+            self.vpos[i] = self.obj.Evaluate(self.pos[i])
+            
+        # Initialize the list to store positions at each iteration
+        self.all_positions = []
+        self.all_positions.append(self.pos.copy())  # Store the initial positions
+
+        #  Swarm bests
+        self.gidx = []
+        self.gbest = []
+        self.gpos = []
+        self.giter = []
+        idx = np.argmin(self.vpos)
+        self.gidx.append(idx)
+        self.gbest.append(self.vpos[idx])
+        self.gpos.append(self.pos[idx].copy())
+        self.giter.append(0)
+
+        #  1st, 2nd, and 3rd best positions
+        idx = np.argsort(self.vpos)
+        self.alpha = self.pos[idx[0]].copy()
+        self.valpha= self.vpos[idx[0]]
+        self.beta  = self.pos[idx[1]].copy()
+        self.vbeta = self.vpos[idx[1]]
+        self.delta = self.pos[idx[2]].copy()
+        self.vdelta= self.vpos[idx[2]]
+
+    # *** Gradio app method optimize created [leveraged vis-a-vis optimize function on the outside of the underlying anatomy of GWO class] ***
+    def optimize(self):
+        """
+        Run a full optimization and return the best positions and fitness values.
+        This method is designed to be used with Gradio.
+        """
+        # Initialize the swarm
+        self.Initialize()
+
+        # Lists to store the best positions and fitness values at each step
+        best_positions = []
+        best_fitness = []
+
+        # Main loop
+        while not self.Done():
+            self.Step()  # Perform an optimization step
+            # Update best_positions and best_fitness with the current best values
+            best_positions.append(self.gbest[-1])
+            best_fitness.append(self.gpos[-1])
+
+        # Print the best positions and fitness found
+        print("Best Positions:", best_positions)
+        print("Best Fitness:", best_fitness)
+
+        # Return the best positions and fitness after the optimization
+        return best_positions, best_fitness
+
+    def Step(self):
+        """Do one swarm step"""
+
+        #  a from eta ... zero (default eta is 2)
+        a = self.eta - self.eta*(self.iterations/self.max_iter)
+
+        #  Update everyone
+        for i in range(self.npart):
+            A = 2*a*np.random.random(self.ndim) - a
+            C = 2*np.random.random(self.ndim)
+            Dalpha = np.abs(C*self.alpha - self.pos[i]) 
+            X1 = self.alpha - A*Dalpha
+
+            A = 2*a*np.random.random(self.ndim) - a
+            C = 2*np.random.random(self.ndim)
+            Dbeta = np.abs(C*self.beta - self.pos[i]) 
+            X2 = self.beta - A*Dbeta
+
+            A = 2*a*np.random.random(self.ndim) - a
+            C = 2*np.random.random(self.ndim)
+            Ddelta = np.abs(C*self.delta - self.pos[i]) 
+            X3 = self.delta - A*Ddelta 
+            
+            self.pos[i,:] = (X1+X2+X3) / 3.0
+
+        #  Keep in bounds
+        if (self.bounds != None):
+            self.pos = self.bounds.Limits(self.pos)
+
+        #  Get objective function values and check for new leaders
+        for i in range(self.npart):
+            self.vpos[i] = self.obj.Evaluate(self.pos[i])
+
+            #  new alpha?
+            if (self.vpos[i] < self.valpha):
+                self.vdelta = self.vbeta
+                self.delta = self.beta.copy()
+                self.vbeta = self.valpha
+                self.beta = self.alpha.copy()
+                self.valpha = self.vpos[i]
+                self.alpha = self.pos[i].copy()
+
+            #  new beta?
+            if (self.vpos[i] > self.valpha) and (self.vpos[i] < self.vbeta):
+                self.vdelta = self.vbeta
+                self.delta = self.beta.copy()
+                self.vbeta = self.vpos[i]
+                self.beta = self.pos[i].copy()
+            
+            #  new delta?
+            if (self.vpos[i] > self.valpha) and (self.vpos[i] < self.vbeta) and (self.vpos[i] < self.vdelta):
+                self.vdelta = self.vpos[i]
+                self.delta = self.pos[i].copy()
+
+            #  is alpha new swarm best?
+            if (self.valpha < self.gbest[-1]):
+                self.gidx.append(i)
+                self.gbest.append(self.valpha)
+                np.save('best_fitness.npy', np.array(self.gbest))
+                self.gpos.append(self.alpha.copy())
+                np.save('best_positions.npy', np.array(self.gpos))
+                # Save the positions at the current iteration
+                self.all_positions.append(self.pos.copy())
+                np.save('all_positions.npy', np.array(self.all_positions), allow_pickle=True)
+                self.giter.append(self.iterations)
+
+        self.iterations += 1
+    
+    def Done(self):
+        """Check if we are done"""
+
+        if (self.done == None):
+            if (self.tol == None):
+                return (self.iterations == self.max_iter)
+            else:
+                return (self.gbest[-1] < self.tol) or (self.iterations == self.max_iter)
+        else:
+            return self.done.Done(self.gbest,
+                        gpos=self.gpos,
+                        pos=self.pos,
+                        max_iter=self.max_iter,
+                        iteration=self.iterations)
+    
+    def Evaluate(self, pos):
+        p = np.zeros(self.npart) 
+        for i in range(self.npart):
+            p[i] = self.obj.Evaluate(pos[i]) 
+        return p
+    
+    def Results(self):
+        if (not self.initialized):
+            return None 
+        return {
+            "npart": self.npart,
+            "ndim": self.ndim,
+            "max_iter": self.max_iter,
+            "iterations": self.iterations,
+            "tol": self.tol,
+            "eta": self.eta,
+            "gbest": self.gbest,
+            "giter": self.giter,
+            "gpos": self.gpos,
+            "gidx": self.gidx,
+            "pos": self.pos,
+            "vpos": self.vpos
+            }
+    def plot_contour_and_wolves(self, wolf_positions):
+        # Define the objective function
+        def objective_function(x, y):
+            return -5.0*np.exp(-0.5*((x+2.2)**2/0.4+(y-4.3)**2/0.4)) + -2.0*np.exp(-0.5*((x-2.2)**2/0.4+(y+4.3)**2/0.4))
+
+        best_postions_npy = np.load('best_positions.npy')
+
+        wolf_positions = best_positions_npy
+
+        # Determine the search space boundaries based on the wolf positions
+        x_min, x_max = wolf_positions[:, 0].min() - 1, wolf_positions[:, 0].max() + 1
+        y_min, y_max = wolf_positions[:, 1].min() - 1, wolf_positions[:, 1].max() + 1
+
+        # Generate a grid of points within the determined search space
+        x = np.linspace(x_min, x_max, 100)
+        y = np.linspace(y_min, y_max, 100)
+        X, Y = np.meshgrid(x, y)
+
+        # Evaluate the objective function on the grid
+        Z = objective_function(X, Y)
+
+        # Plot the contour map
+        plt.figure(figsize=(10, 8))
+        contour = plt.contour(X, Y, Z, levels=20, cmap='viridis')
+        plt.colorbar(contour)
+
+        # Plot the wolf positions
+        plt.plot(wolf_positions[:, 0], wolf_positions[:, 1], 'ro', markersize=5, label='Wolves')
+
+        # Set plot title and labels
+        plt.title('Contour Map of Wolves Oscillating Over Search Space')
+        plt.xlabel('x')
+        plt.ylabel('y')
+        plt.legend()
+
+        # Set the x and y limits of the plot based on the determined search space
+        plt.xlim(x_min, x_max)
+        plt.ylim(y_min, y_max)
+
+        # Convert the plot to a PIL Image and return it
+        buf = BytesIO()
+        plt.savefig(buf, format='png')
+        buf.seek(0)
+        plt.close()  # Close the figure to free up memory
+        return Image.open(buf)
+    
+    def Dispersion(self):
+        """Calculate the dispersion of the swarm"""
+        x, y = self.gpos[:, 0], self.gpos[:, 1]
+        dx = x.max() - x.min()
+        dy = y.max() - y.min()
+        return (dx + dy) / 2.0
+
+    def plot_dispersion(self):
+        """Plot the dispersion over time"""
+        # Assuming self.giter stores the iteration number at which each best position was found
+        # and self.gbest stores the corresponding best fitness values
+        dispersion_values = [self.Dispersion() for _ in range(self.max_iter)]
+
+        plt.figure(figsize=(10, 6))
+        plt.plot(range(self.max_iter), dispersion_values, label='Dispersion')
+        plt.xlabel('Iteration')
+        plt.ylabel('Dispersion')
+        plt.title('Evolution of Dispersion')
+        plt.legend()
+        plt.show()
+
+        # Convert the plot to a PIL Image and return it
+        buf = BytesIO()
+        plt.savefig(buf, format='png')
+        buf.seek(0)
+        plt.close()  # Close the figure to free up memory
+        return Image.open(buf)
+
+    def plot_dispersion_heatmap(self, x_range, y_range, grid_size=100):
+        """Plot a heatmap of dispersion over a grid of positions"""
+        x_values = np.linspace(x_range[0], x_range[1], grid_size)
+        y_values = np.linspace(y_range[0], y_range[1], grid_size)
+        X, Y = np.meshgrid(x_values, y_values)
+        positions = np.vstack([X.ravel(), Y.ravel()]).T
+
+        # Calculate dispersion for each position in the grid
+        dispersion_values = np.array([self.Dispersion(pos) for pos in positions])
+        Z = dispersion_values.reshape(X.shape)
+
+        plt.figure(figsize=(10, 8))
+        plt.imshow(Z, extent=(x_range[0], x_range[1], y_range[0], y_range[1]), origin='lower', cmap='viridis')
+        plt.colorbar(label='Dispersion')
+        plt.title('Heatmap of Dispersion')
+        plt.xlabel('X')
+        plt.ylabel('Y')
+        plt.show()
+
+        # Convert the plot to a PIL Image and return it
+        buf = BytesIO()
+        plt.savefig(buf, format='png')
+        buf.seek(0)
+        plt.close()  # Close the figure to free up memory
+        return Image.open(buf)
+
+        
+
+    
+
+def optimize(npart, ndim, max_iter):
+    # Initialize the GWO algorithm with the provided parameters
+    gwo = GWO(obj=obj, npart=npart, ndim=ndim, max_iter=max_iter, init=init, bounds=bounds)
+    
+    # Run the optimization
+    best_positions, best_fitness = gwo.optimize()
+
+    # Get the best fitness and positions at the last iteration
+    last_best_fitness = best_fitness[-1]
+    last_best_positions = best_positions[-1]
+
+    # Format the output strings
+    best_fitness_text = f"Best Positions: {last_best_fitness}"
+    best_positions_text = f"Best Fitness: {last_best_positions}"
+
+    # Get the contour plot as a PIL Image
+    contour_plot = gwo.plot_contour_and_wolves(wolf_positions)
+
+    # Calculate the dispersion
+    dispersion = gwo.Dispersion()
+
+    # Format the output strings
+    best_fitness_text = f"Best Positions: {last_best_fitness}"
+    best_positions_text = f"Best Fitness: {last_best_positions}"
+    dispersion_text = f"Dispersion: {dispersion}"
+
+    # Plot the dispersion over time
+    dispersion_plot = gwo.plot_dispersion()
+
+    # Plot the dispersion heatmap
+    dispersion_heatmap_plot = gwo.plot_dispersion_heatmap(x_range=(-6,6), y_range=(-6,6))
+
+
+    # Return the positions plot, the text for the best fitness and positions, and the loaded data
+    return [contour_plot, dispersion_plot, dispersion_heatmap_plot], best_fitness_text, best_positions_text, best_fitness_npy, best_positions_npy, dispersion_text
+
+
+
+# Define the Gradio interface
+iface = gr.Interface(
+    fn=optimize,  # Pass the optimize function object
+    inputs=[
+        gr.components.Slider(10, 50, 50, step=1, label="Number of Wolves [Default = 50 Wolves]"),
+        gr.components.Slider(2, 2, 2, step=1, label="Two-Dimensional Search Space"),
+        gr.components.Slider(100, 200, 200, step=1, label="Maximum Iterations [Default = 200 Epochs]"),
+    ],
+    outputs=[
+        gr.components.Image(type="pil", label="Contour Map of Wolves Oscillating Over Search Space"),
+        gr.components.Image(type="pil", label="Dispersion Plot"),
+        gr.components.Image(type="pil", label="Dispersion Heatmap Plot"),
+        gr.components.Textbox(label="Dispersion Values"),
+        gr.components.Textbox(label="Best Positions"),
+        gr.components.Textbox(label="Best Fitness")
+        
+    ],
+    title="Grey Wolf Optimizer",
+    description="Optimize the objective function using the Grey Wolf Optimizer.",
+    article="## Grey Wolf Optimizer\nThe Grey Wolf Optimizer (GWO) is a population-based metaheuristic optimization algorithm inspired by the social behavior of grey wolves in nature."
+)
+
+# Launch the Gradio interface
+iface.launch()