Scribd Logo
Upload

Welcome to Scribd!

  • 56 views

    Experiment 7: Hybridization of Genetic Algorithm With PSO

    Uploaded by

    Mahima Hans
    The document describes experimenting with hybridizing genetic algorithms and particle swarm optimization. It discusses how PSO is prone to premature convergence and that hybridization with GAs is one way to address this. The experiment applies adaptive mutation and crossover operators from GAs to PSO individually and combined. The results found that an adaptive approach with position factor was most effective for the proposed PSO hybrids and improved performance over single PSO. The code implements a class for a grid of cells that can be filled and saved to a file.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd

    Experiment 7: Hybridization of Genetic Algorithm With PSO

    Uploaded by

    Mahima Hans
    56 views6 pages
    The document describes experimenting with hybridizing genetic algorithms and particle swarm optimization. It discusses how PSO is prone to premature convergence and that hybridization with GAs is one way to address this. The experiment applies adaptive mutation and crossover operators from GAs to PSO individually and combined. The results found that an adaptive approach with position factor was most effective for the proposed PSO hybrids and improved performance over single PSO. The code implements a class for a grid of cells that can be filled and saved to a file.

    Original Title

    co_172_EXP_07

    Copyright

    © © All Rights Reserved

    Available Formats

    PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The document describes experimenting with hybridizing genetic algorithms and particle swarm optimization. It discusses how PSO is prone to premature convergence and that hybridization with GAs is one way to address this. The experiment applies adaptive mutation and crossover operators from GAs to PSO individually and combined. The results found that an adaptive approach with position factor was most effective for the proposed PSO hybrids and improved performance over single PSO. The code implements a class for a grid of cells that can be filled and saved to a file.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    56 views6 pages

    Experiment 7: Hybridization of Genetic Algorithm With PSO

    Uploaded by

    Mahima Hans
    The document describes experimenting with hybridizing genetic algorithms and particle swarm optimization. It discusses how PSO is prone to premature convergence and that hybridization with GAs is one way to address this. The experiment applies adaptive mutation and crossover operators from GAs to PSO individually and combined. The results found that an adaptive approach with position factor was most effective for the proposed PSO hybrids and improved performance over single PSO. The code implements a class for a grid of cells that can be filled and saved to a file.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    of 6

    Experiment 7

    Aim: - Hybridization of Genetic Algorithm with PSO.

    Theory:
    Particle Swarm Optimization (PSO) is a popular algorithm used extensively in continuous
    optimization. One of its well-known drawbacks is its propensity for premature convergence.
    Many techniques have been proposed for alleviating this problem. One of the alternative
    approaches is hybridization. Genetic Algorithms (GA) are one of the possible techniques used for
    hybridization

    Algorithm:

    Hybridization of Genetic Algorithm(GA) with Particle Swarm Optimization(PSO) algorithm


    Most often, a mutation scheme is added to the PSO, but some applications of crossover have
    been added more recently. Some of these schemes use adaptive parameterization when applying
    the GA operators. adaptively parameterized mutation and crossover operators are combined with
    a PSO implementation individually and in combination to test the effectiveness of these
    additions. The results indicate that an adaptive approach with position factor is more effective for
    the proposed PSO hybrids. Compared to single PSO with adaptive inertia weight, all the PSO
    hybrids with adaptive probability have shown satisfactory performance in generating near-
    optimal solutions for all tested functions.

    Code : -
    import numpy as np

    class Cell():
    FILLED_COLOR_BG = "green"
    EMPTY_COLOR_BG = "white"
    FILLED_COLOR_BORDER = "green"
    EMPTY_COLOR_BORDER = "black"

    def __init__(self, master, x, y, size):


    """ Constructor of the object called by Cell(...) """
    self.master = master
    self.abs = x
    self.ord = y
    self.size = size
    self.fill = False
    self.value = 0
    def _switch(self):
    """ Switch if the cell is filled or not. """
    self.fill = not self.fill

    def draw(self):
    """ order to the cell to draw its representation on the canvas
    """
    if self.master is not None :
    fill = Cell.FILLED_COLOR_BG
    outline = Cell.FILLED_COLOR_BORDER
    self.value = 1

    if not self.fill:
    fill = Cell.EMPTY_COLOR_BG
    outline = Cell.EMPTY_COLOR_BORDER
    self.value = 0

    xmin = self.abs * self.size


    xmax = xmin + self.size
    ymin = self.ord * self.size
    ymax = ymin + self.size

    self.master.create_rectangle(xmin, ymin, xmax, ymax, fill


    = fill, outline = outline)

    class CellGrid(Canvas):
    def __init__(self,master, rowNumber, columnNumber, cellSize,
    *args, **kwargs):
    Canvas.__init__(self, master, width = cellSize * columnNumber
    , height = cellSize * rowNumber, *args, **kwargs)

    self.cellSize = cellSize
    self.grid = []
    for row in range(rowNumber):
    line = []
    for column in range(columnNumber):
    line.append(Cell(self, column, row, cellSize))

    self.grid.append(line)

    #memorize the cells that have been modified to avoid many


    switching of state during mouse motion.
    self.switched = []

    self.matrix = np.matrix(np.zeros((rowNumber, columnNumber)))

    #bind click action


    self.bind("<Button-1>", self.handleMouseClick)
    #bind moving while clicking
    self.bind("<B1-Motion>", self.handleMouseMotion)
    #bind release button action - clear the memory of midified
    cells.
    self.bind("<ButtonRelease-1>", lambda event:
    self.switched.clear())
    self.bind("<Double-Button-1>", self.save)

    self.draw()

    def draw(self):
    for row in self.grid:
    for cell in row:
    cell.draw()
    self.matrix[cell.ord, cell.abs] = cell.value

    with open("map_small.txt", "w") as file:


    for line in self.matrix:
    np.savetxt(file, line, fmt='%.0f')
    file.write("\n")

    def _eventCoords(self, event):


    row = int(event.y / self.cellSize)
    column = int(event.x / self.cellSize)
    return row, column

    def handleMouseClick(self, event):


    row, column = self._eventCoords(event)
    cell = self.grid[row][column]
    cell._switch()
    cell.draw()
    #add the cell to the list of cell switched during the click
    self.switched.append(cell)
    #self.draw()

    def handleMouseMotion(self, event):


    row, column = self._eventCoords(event)
    cell = self.grid[row][column]

    if cell not in self.switched:


    cell._switch()
    cell.draw()
    self.switched.append(cell)
    #self.draw()

    def save(self, event):


    print(event)
    self.draw()

    if __name__ == "__main__" :
    app = Tk()

    grid = CellGrid(app, 10, 10, 40)


    grid.pack()

    app.mainloop()

    Output : -

    Initial epoch
    Final epoch

    Learning & Finding


    1. Successfully implemented Hybridization of Genetic Algorithm with PSO technique in python.

    You might also like