optimization python project

Comment

0

# Import required libraries
import numpy as np
import sympy as sym
from scipy.optimize import minimize, shgo, differential_evolution
import plotly.graph_objects as go
import pandas as pd

# Definition of the function to be researched
x = sym.Symbol('x')
y = sym.Symbol('y')
f = (x**2 + y - 11)**2 + (x + y**2 - 7)**2
f2 = sym.lambdify((x, y), f)

# Generate the domain
def generateDomain():
    X_cord_val = np.linspace(-5, 5, 100)
    Y_cord_val = np.linspace(-5, 5, 100)
    return X_cord_val, Y_cord_val

# Function to calculate the function value at a point
def Function2Calc(point2Calc):
    x, y = point2Calc
    return f2(x, y)

# Function to calculate the derivatives of the function for Jacobian and Hessian matrices
dFdX = sym.lambdify((x, y), f.diff(x))
dFdY = sym.lambdify((x, y), f.diff(y))
d2FdX2 = sym.lambdify((x, y), f.diff(x, 2))
d2FdY2 = sym.lambdify((x, y), f.diff(y, 2))
d2FdXdY = sym.lambdify((x, y), f.diff(x).diff(y))

# Function to calculate the Jacobian matrix of f
def JacobianCalc(point2Calc):
    x, y = point2Calc
    return np.array((dFdX(x, y), dFdY(x, y)))

# Function to calculate the Hessian matrix of f
def HesCalc(point2Calc):
    x, y = point2Calc
    return np.array(((d2FdX2(x, y), d2FdXdY(x, y)), (d2FdXdY(x, y), d2FdY2(x, y))))

# Function to find local minimization of f using different optimization algorithms
def findLocalMinimizationOfF():
    X_cord_val, Y_cord_val = generateDomain()
    np.random.seed(1000)
    random_x = np.random.uniform(X_cord_val[0], X_cord_val[-1], size=100)
    random_y = np.random.uniform(Y_cord_val[0], Y_cord_val[-1], size=100)
    pointsArray = np.array([random_x, random_y]).transpose()
    methods = ["CG", "BFGS", "Newton-CG", "L-BFGS-B"]
    PointsArrayAnswers = np.zeros((100 * 4, 6))
    for i, point2Calc in zip(range(0, 400, len(methods)), pointsArray):
        for AlgIdx, method in zip(range(1, 5), methods):
            result = minimize(Function2Calc, point2Calc, method=method, jac=JacobianCalc, hess=HesCalc)
            PointsArrayAnswers[i + AlgIdx - 1, 0:2] = point2Calc
            PointsArrayAnswers[i + AlgIdx - 1, 2:4] = result.x
            PointsArrayAnswers[i + AlgIdx - 1, 4] = result.fun
            PointsArrayAnswers[i + AlgIdx - 1, 5] = AlgIdx

    return PointsArrayAnswers

# Function to perform global optimization of f over D using differential_evolution
def globalOptimizationOfFOverDUsingDifferentialEvolution():
    X_cord_val, Y_cord_val = generateDomain()
    result = differential_evolution(Function2Calc, bounds=[(-5, 5), (-5, 5)])
    xBar, yBar = result.x
    fBar = result.fun
    print(f"f({xBar}; {yBar}) = {fBar}")
    return xBar, yBar

# Function to calculate the matrix inverse
def calculateMatrixInverse():
    A = np.array([[3, 1], [1, 2]])
    A_inv = np.linalg.inv(A)
    print("Matrix A:")
    print(A)
    print("Inverse of Matrix A:")
    print(A_inv)
    return A, A_inv

# Visualization of the function in 3D using Plotly
def Draw3dVersionFunction():
    X_cord_val, Y_cord_val = generateDomain()
    X_grid, Y_grid = np.meshgrid(X_cord_val, Y_cord_val)
    Z_grid = Function2Calc([X_grid, Y_grid])

    fig = go.Figure(data=[go.Surface(x=X_cord_val, y=Y_cord_val, z=Z_grid)])
    fig.update_layout(title="3D Visualization of the Function", scene=dict(xaxis_title="X", yaxis_title="Y", zaxis_title="Z"))
    fig.show()

# Draw the function as a 2D matrix using Plotly
def Draw2dMatrixVersionFunction():
    X_cord_val, Y_cord_val = generateDomain()
    Z_grid = Function2Calc([X_cord_val, Y_cord_val])

    fig = go.Figure(data=[go.Heatmap(x=X_cord_val, y=Y_cord_val, z=Z_grid)])
    fig.update_layout(title="2D Matrix Visualization of the Function", xaxis_title="X", yaxis_title="Y")
    fig.show()

# Main function to run all the tasks
def main():
    # Task 1: Visualization of the function in 3D using Plotly
    Draw3dVersionFunction()

    # Task 2: Draw the function as a 2D matrix using Plotly
    Draw2dMatrixVersionFunction()

    # Task 3: Local Minimization of the function
    PointsArrayAnswers = findLocalMinimizationOfF()
    df = pd.DataFrame(PointsArrayAnswers, columns=["Initial X", "Initial Y", "Minimized X", "Minimized Y", "Minimized Value", "Algorithm"])
    print("Local Minimization of the Function:")
    print(df)

    # Task 4: Global Optimization of the function using differential_evolution
    globalOptimizationOfFOverDUsingDifferentialEvolution()

    # Task 5: Comparison of Matrix Inverse
    A, A_inv = calculateMatrixInverse()

if __name__ == "__main__":
    main()

Popularity 6/10 Helpfulness 1/10 Language python

Source: chat.openai.com

Tags: optimization project python

Share

Link to this answer
Share Copy Link

Contributed on Jul 30 2023

Green Team

0 Answers Avg Quality 2/10

optimization python

Comment

5

import numpy as np
from scipy.optimize import minimize

# Define a cubic function to minimize: z = Ax^3 + By + C
def cubic_function(x, A, B, C):
    return A * x[0]**3 + B * x[1] + C

# Coefficients for the cubic function
A_coefficient = 2.0
B_coefficient = -3.0
C_constant = 5.0

# Initial guess
initial_guess = [1, 1]

# Minimize the cubic function
result = minimize(cubic_function, initial_guess, args=(A_coefficient, B_coefficient, C_constant), method='Nelder-Mead')

# Print the result
print("Minimum found at x:", result.x)
print("Minimum function value (z):", result.fun)

Popularity 9/10 Helpfulness 4/10 Language python

Source: Grepper

Tags: optimization optimizati

Share

Link to this answer
Share Copy Link

Contributed on Jan 07 2024

Innocent Iguana

0 Answers Avg Quality 2/10

optimization in python

Comment

-2

OPTIMIZATION FOR PYTHON: TIP 2 - 4

2 - When importing modules you can import them all in a single line:

import module_1, module_2, module_3, etc...


3 - When importing everything from a module use *:

from random import *

We imported everything from the 'random' module using *, now we dont need to use 'random.'
FUN FACT: Not using module. increases performance since module. uses the get_attr function which
decreases performance


4 - When importing only a few things from a module combine the two tips above:

from random import randint, choice

#Now we only import the things we want while also iincreasing performance and start-up time

Popularity 9/10 Helpfulness 1/10 Language python

Source: Grepper

Tags: optimization optimizati

Share

Link to this answer
Share Copy Link

Contributed on Mar 19 2022

Victorious Vulture

0 Answers Avg Quality 2/10

optimization python project

Contents

More Related Answers

optimization python project

Closely Related Answers

optimization python

optimization in python

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.