Web ui with streamlit. requirements.txt added. Some minor updates.

.gitignore

@@ -1,4 +1,5 @@
 src/__pycache__/
+__pycache__
 deneme.py
 results/*.png
 results/*.txt

README.md

@@ -64,6 +64,19 @@ An example script (Runs adaptive hdmr): `python src/main.py --numSamples 1000 --
 
 If adaptive parameter is set, the output file will be additional parameters and will be starting with 'adaptive' key.
 
+# Web UI Update
+After you install all dependencies inside of the `requirements.txt` you can run the following code to run web ui on your browser.
+
+You should be inside of the main folder. (Should be seeing results, src folder etc.)
+1. Open the terminal in this folder.
+2. Run `streamlit run app`
+
+This basically runs the `app.py` which is the streamlit app folder. You can find the ui elements inside of this file.
+
+As default it runs the app on the `http://localhost:8501/`
+
+**NOTE:** 10d functions are currently disabled due to some errors on the presentation. They will be enabled with the next update.
+
 
 
 

app.py

@@ -0,0 +1,105 @@
+import streamlit as st
+import matplotlib.pyplot as plt
+import src.main as main
+import app_utils as utils
+
+st.set_page_config(
+    page_title="HDMR-Opt",
+    page_icon=":tada:",
+    layout="wide"
+)
+
+st.markdown(
+        """
+       <style>
+       [data-testid="stSidebar"][aria-expanded="true"]{
+           min-width: 300px;
+           max-width: 400px;
+       }
+       """,
+        unsafe_allow_html=True,
+    )  
+
+# Header
+page_text = """
+    This repository contains the codes to calculate global minimum points of the given functions.
+    In this code, we use two method to optimize and compare. In hdmr-opt method,
+    We get the one dimensional form of the given functions using HDMR. In other method,
+    we directly apply BFGS method to the function.
+"""
+with st.container():
+    # st.subheader("HDMR Optimization")
+    st.title("HDMR Optimization")
+    st.write(page_text)
+
+available_functions = ["testfunc_2d", "camel3_2d", "camel16_2d", "treccani_2d", "goldstein_2d", "branin_2d", 
+                       "rosenbrock_2d", "ackley_2d"]
+
+# available_functions = ["testfunc_2d", "camel3_2d", "camel16_2d", "treccani_2d", "goldstein_2d", "branin_2d", 
+#                        "rosenbrock_2d", "ackley_2d", "rosenbrock_10d", "griewank_10d", "rastrigin_10d"]
+
+st.sidebar.header('User Inputs')
+
+interactive_plot = st.sidebar.checkbox("Interactive Plot")
+
+N = st.sidebar.slider("Number of samples:", 100, 10000, 1000, 100)
+
+# n = st.sidebar.slider("Number of variables: ", 1, 10, 2, 1)
+function_name = st.sidebar.selectbox("Test function:", available_functions)
+legendreDegree = st.sidebar.slider("Legendre Degree:", 1, 20, 7, 1)
+
+st.sidebar.write("Function interval: ")
+col1, col2 = st.sidebar.columns(2)
+interval = utils.get_function_interval(function_name=function_name.split('_')[0])
+with col1:
+    st.number_input("Min: ", value=interval[0], format="%.3f", step=1.0)
+with col2:
+    st.number_input("Max: ", value=interval[1], format="%.3f", step=1.0)
+
+
+random_init = st.sidebar.checkbox("Random Initialization")
+st.sidebar.caption("Default is 0 initialization")
+
+is_adaptive = st.sidebar.checkbox("Adaptive HDMR")
+
+if is_adaptive:
+    num_closest_points = st.sidebar.number_input("Number of closest points:", 1, N, 100)
+    epsilon = st.sidebar.number_input("Epsilon:", value=0.1, min_value=0.0, step=0.1)
+    clip = st.sidebar.number_input("Clip:", 0.05, 1.0, 0.9, 0.05)
+
+if st.sidebar.button("Calculate HDMR"):
+
+    n = utils.get_dims(function_name)
+    print("n is: ", n)
+
+    main.is_streamlit = interactive_plot
+    if is_adaptive:
+        status_hdmr, plt1, plt2, file_name = main.main_function(N, n, function_name, legendreDegree, interval[0], interval[1], 
+                                        random_init, is_adaptive, num_closest_points, epsilon, clip)
+    else:
+        status_hdmr, plt1, plt2, file_name = main.main_function(N, n, function_name, legendreDegree, interval[0], interval[1], 
+                                        random_init, is_adaptive)
+    st.subheader("Results")
+    st.write(f"hdmr_opt status Success: {status_hdmr.success} - X: {status_hdmr.x}")
+
+    with st.expander("Click to see the full result", expanded=False):
+        st.write(status_hdmr)
+
+    st.subheader("Plots")
+    
+    if interactive_plot:
+        col3, col4 = st.columns(spec=[0.4, 0.6], gap='small')
+    else:
+        col3, col4 = st.columns(spec=2, gap='small')
+
+    with col3:
+        st.pyplot(plt1)
+    with col4:
+        if interactive_plot:
+            st.plotly_chart(plt2)
+        else:
+            st.pyplot(plt2) 
+        
+    
+
+

app_utils.py

@@ -0,0 +1,23 @@
+default_function_intervals = {
+    "testfunc": (-5.0, 5.0),
+    "camel3": (-5.0, 5.0),
+    "camel16": (-5.0, 5.0),
+    "treccani": (-5.0, 5.0),
+    "goldstein": (-2.0, 2.0),
+    "branin": (-5.0, 15.0),
+    "rosenbrock": (-2.048, 2.048),
+    "ackley": (-30.0, 30.0),
+    "griewank": (-600.0, 600.0),
+    "rastrigin": (-5.12, 5.12)
+}
+
+def get_function_interval(function_name):
+    try:
+        interval = default_function_intervals[function_name]    
+    except:
+        raise KeyError("You have entered non existing funtion name.")
+    
+    return interval
+
+def get_dims(function_name):
+    return int(function_name.split('_')[1][:-1])

requirements.txt

@@ -0,0 +1,6 @@
+matplotlib==3.5.2
+numpy==1.21.5
+pandas==1.4.4
+plotly==5.9.0
+scipy==1.9.1
+streamlit==1.24.1

src/functions.py

@@ -28,8 +28,8 @@ def camel16_2d(X):
         X = np.array([X])
     return (4*X[:, 0]**2 - 2.1*X[:, 0]**4 + (X[:, 0]**6)/3 + X[:, 0]*X[:, 1] - 4*X[:, 1]**2 + 4*X[:, 1]**4).reshape(-1, 1)
 
-# 2d Trecanni
-def trecanni_2d(X):
+# 2d Treccani
+def treccani_2d(X):
     try:
         X.shape[1]
     except:
@@ -119,9 +119,9 @@ if __name__ == "__main__":
     # Evaluate the function based on the provided name
     f = globals().get(function_name)
 
-    if f == camel3_2d or f == camel16_2d or f == trecanni_2d:
-        x1_min = x2_min = -3
-        x1_max = x2_max = 3
+    if f == camel3_2d or f == camel16_2d or f == treccani_2d:
+        x1_min = x2_min = -5
+        x1_max = x2_max = 5
     elif f == goldstein_2d:
         x1_min = x2_min = -2
         x1_max = x2_max = 2

src/main.py

@@ -3,7 +3,10 @@ import numpy as np
 import math
 import matplotlib.pyplot as plt
 import pandas as pd
-import functions as f
+try:
+    import src.functions as functions
+except:
+    import functions    
 import argparse
 
 """
@@ -11,6 +14,8 @@ Test functions are available in https://www.sfu.ca/~ssurjano/optimization.html
 
 """
 
+is_streamlit = False
+
 
 def rastrigin(x):
     if len(x.shape) == 2:
@@ -58,6 +63,7 @@ def hdmr_opt(fun, x0, args=(), jac=None, callback=None,
                  gtol=1e-5, maxiter=None,
                  disp=False, return_all=False, finite_diff_rel_step=None,
                  **unknown_options):
+    global plt1, plt2
 
     def Pn(m, x):
         if m == 0:
@@ -104,8 +110,6 @@ def hdmr_opt(fun, x0, args=(), jac=None, callback=None,
         return f
 
     def plot_results():
-        a = a_
-        b = b_
         f = np.zeros((N,n))
         y = fun(xs)
         for idx in range(n):
@@ -139,22 +143,56 @@ def hdmr_opt(fun, x0, args=(), jac=None, callback=None,
             axs[jj-1, 0].legend()
             axs[jj-1, 1].legend()
         plt.subplots_adjust(hspace=0.6, wspace=0.3)
-        plt.savefig(file_name + '.png')
+        return fig
     
     def plot_with_function():
-        a = a_
-        b = b_
+        global is_streamlit
+        if is_streamlit == True:
+            import plotly.graph_objects as go
+            Y = fun(xs)
+            yhat = evalute_hdmr(xs, np.mean(Y, axis=0), alpha)
+
+            X1, X2 = zip(*xs)
+            X1 = np.array(X1).flatten()
+            X2 = np.array(X2).flatten()
+            yhat = np.array(yhat).flatten()
+
+            # Scatter plot
+            scatter_trace = go.Scatter3d(x=X1, y=X2, z=yhat, mode='markers', marker=dict(color='blue', size=2), name='Data Points')
+
+            x1_min, x1_max = np.array((np.min(X1), np.max(X1)))
+            x2_min, x2_max = np.array((np.min(X2), np.max(X2)))
+
+            X1 = np.linspace(x1_min, x1_max, int(N/10))
+            X2 = np.linspace(x2_min, x2_max, int(N/10))
+
+            X1, X2 = np.meshgrid(X1, X2)
+            Y = fun(np.column_stack((X1.ravel(), X2.ravel()))).reshape(X1.shape)
+
+            # Surface plot
+            surface_trace = go.Surface(x=X1, y=X2, z=Y, colorscale='jet', opacity=0.6, name='Function Surface')
+
+            # Create the figure and add the traces
+            fig = go.Figure(data=[scatter_trace, surface_trace])
+
+            # Set labels for each axis
+            fig.update_layout(scene=dict(xaxis_title='X1', yaxis_title='X2', zaxis_title='y'), height=650, width=800, 
+                              title='HDMR Scatter & Original Function Surface Plot')
+
+            return fig
+        
+        
         Y = fun(xs)
         yhat = evalute_hdmr(xs, np.mean(Y, axis=0), alpha)
 
         X1, X2 = zip(*xs)
         fig = plt.figure(figsize=(8, n*4))
         ax = fig.add_subplot(111, projection='3d')
-
+        ax.set_title("HDMR Scatter & Original Function Surface Plot")
         # Scatter plot
         
         # ax.scatter(X1, X2, Y, c='r', marker='o', alpha=0.6)
-        ax.scatter(X1, X2, yhat, c='b', marker='o', alpha=0.6)
+        ax.scatter(X1, X2, yhat, c='b', marker='o', alpha=0.6, s=2)
         x1_min, x1_max = np.array((np.min(X1), np.max(X1)))
         x2_min, x2_max = np.array((np.min(X2), np.max(X2)))
 
@@ -166,7 +204,7 @@ def hdmr_opt(fun, x0, args=(), jac=None, callback=None,
         x1, x2 = np.meshgrid(x1, x2)
         y = fun(np.column_stack((x1.ravel(), x2.ravel()))).reshape(x1.shape)
 
-        ax.plot_surface(x1, x2, y, cmap='jet', alpha=0.5)
+        ax.plot_surface(x1, x2, y, cmap='jet', alpha=0.6)
 
         # Limit the Y axis so scatter is easier to see.
         # ax.set_zlim(np.min(yhat), np.max(yhat))
@@ -175,7 +213,7 @@ def hdmr_opt(fun, x0, args=(), jac=None, callback=None,
         ax.set_xlabel('X1')
         ax.set_ylabel('X2')
         ax.set_zlabel('y')
-        plt.show()
+        return fig
 
 
     def calculate_distances(x0, arr):
@@ -260,8 +298,8 @@ def hdmr_opt(fun, x0, args=(), jac=None, callback=None,
             old_b = new_b
         a_ = new_a
         b_ = new_b
-        plot_results()
-        plot_with_function()
+        plt1 = plot_results()
+        plt2 = plot_with_function()
     else:
         a_ = a
         b_ = b
@@ -269,79 +307,99 @@ def hdmr_opt(fun, x0, args=(), jac=None, callback=None,
         print('XS: ', xs.shape)
         alpha = calculate_alpha_coeff(xs)
         print("Alpha: ", alpha)
-        plot_results()
         temp_status = []
         for i in range(n):
             status = minimize(one_dim_evaluate_hdmr, np.array(x0[i]), method='BFGS') 
             temp_status.append(status.x[0])
         result = OptimizeResult(x=temp_status, fun=fun(x0, *args), success=True, message=" ", nfev=1, njev=0, nhev=0)
         result.nfev = N
-        plot_with_function()
+        plt1 = plot_results()
+        plt2 = plot_with_function()
 
     return result
 
+def main_function(N_, n_, function_name_, m_, a_, b_, random_init_, is_adaptive_, k_=None, epsilon_=None, clip_=None):
+    global N, n, function_name, m, a, b, random_init, is_adaptive, k, epsilon, clip
+    
+    N = N_
+    n = n_
+    function_name = function_name_
+    m = m_
+    a = a_
+    b = b_
+    random_init = random_init_
+    is_adaptive = is_adaptive_
 
-parser = argparse.ArgumentParser(
-                    prog='HDMR',
-                    description='Program applies the hdmr-opt method and plots the results.')
-parser.add_argument('--numSamples', type=int, help='Number of samples to calculate alpha coefficients.', required=True)
-parser.add_argument('--numVariables', type=int, help='Number of variable of the test function.', required=True)
-parser.add_argument('--function', help='Test function name.', required=True)
-parser.add_argument('--min', type=float, help='Lower range of the test function.', required=True)
-parser.add_argument('--max', type=float, help='Upper range of the test function.', required=True)
-parser.add_argument('--randomInit', action='store_true', help='Initializes x0 as random numbers in the range of xs. Default is initializing as 0.')
-parser.add_argument('--legendreDegree', type=int, default=7, help='Number of legendre polynomial. Default is 7.')
-parser.add_argument('--adaptive', action='store_true', help='Uses iterative method when set.')
-parser.add_argument('--numClosestPoints', type=int, help='Number of closest points to x0. Default is 1000.', default=100)
-parser.add_argument('--epsilon', type=float, help='Epsilon value for convergence. Default is 0.1.', default=0.1)
-parser.add_argument('--clip', type=float, help='Clipping value for updating interval (a, b). Default is 0.9.', default=0.9)
-
-global_args = parser.parse_args()
-
-if __name__ == "__main__":
-
-    # N = 100 # Number of samples to calculate alpha coefficients
-    # n = 2 # Number of variable
-    # m = 7 # Degree of the Legendre polynomial
-    # a = -5 # Range of the function
-    # b = 5 # Range of the function
-    print('Args: ', global_args)
-
-    N = global_args.numSamples # Number of samples to calculate alpha coefficients
-    n = global_args.numVariables # Number of variable
-    test_function = getattr(f, global_args.function)
-    m = global_args.legendreDegree # Degree of the Legendre polynomial
-    a = global_args.min # Range of the function
-    b = global_args.max # Range of the function
-    is_adaptive = global_args.adaptive
     if is_adaptive:
-        k = global_args.numClosestPoints # Number of resampled points
-        clip = global_args.clip
-        epsilon = global_args.epsilon # Epsilon value for convergence
+        k = k_
+        epsilon = epsilon_
+        clip = clip_
         if not (0 < clip <= 1):
             raise ValueError("Clipping value should be in the interval of (0, 1]")
-        file_name = f"results/adaptive_{global_args.function}_a{a}_b{b}_N{N}_m{m}_k{k}_c{clip:.2f}" 
+        file_name = f"results/adaptive_{function_name}_a{a}_b{b}_N{N}_m{m}_k{k}_c{clip:.2f}" 
     else:
-        file_name = f"results/{global_args.function}_a{a}_b{b}_N{N}_m{m}" 
+        file_name = f"results/{function_name}_a{a}_b{b}_N{N}_m{m}" 
     
-    if not global_args.randomInit:
-        if global_args.function.split('_')[1] == '2d':
+    if not random_init:
+        if function_name.split('_')[1] == '2d':
             x0 = np.array([0.0, 0.0]) # Initial value of function for optimizing process
-        elif global_args.function.split('_')[1] == '10d':
+        elif function_name.split('_')[1] == '10d':
             x0 = np.zeros((10,))
     else:
         file_name += '_randomInit'
-        if global_args.function.split('_')[1] == '2d':
+        if function_name.split('_')[1] == '2d':
             x0 = np.random.rand(2) * (b - a) + a # Initial value of function for optimizing process
-        elif global_args.function.split('_')[1] == '10d':
+        elif function_name.split('_')[1] == '10d':
             x0 = np.random.rand(10) * (b - a) + a
 
+    
     # status_bfgs = minimize(test_function, x0, method="BFGS") # Applying direct optimization method to the function
     # print(f"BFGS status: {status_bfgs}")
-    status_hdmr = minimize(test_function, x0, args=(), method=hdmr_opt) # Applying hdmr-opt method to the function
+    status_hdmr = minimize(getattr(functions, function_name), x0, args=(), method=hdmr_opt) # Applying hdmr-opt method to the function
+
+    return status_hdmr, plt1, plt2, file_name
+
+plt1 = plt2 = None
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser(
+                    prog='HDMR',
+                    description='Program applies the hdmr-opt method and plots the results.')
+    parser.add_argument('--numSamples', type=int, help='Number of samples to calculate alpha coefficients.', required=True)
+    parser.add_argument('--numVariables', type=int, help='Number of variable of the test function.', required=True)
+    parser.add_argument('--function', help='Test function name.', required=True)
+    parser.add_argument('--min', type=float, help='Lower range of the test function.', required=True)
+    parser.add_argument('--max', type=float, help='Upper range of the test function.', required=True)
+    parser.add_argument('--randomInit', action='store_true', help='Initializes x0 as random numbers in the range of xs. Default is initializing as 0.')
+    parser.add_argument('--legendreDegree', type=int, default=7, help='Number of legendre polynomial. Default is 7.')
+    parser.add_argument('--adaptive', action='store_true', help='Uses iterative method when set.')
+    parser.add_argument('--numClosestPoints', type=int, help='Number of closest points to x0. Default is 1000.', default=100)
+    parser.add_argument('--epsilon', type=float, help='Epsilon value for convergence. Default is 0.1.', default=0.1)
+    parser.add_argument('--clip', type=float, help='Clipping value for updating interval (a, b). Default is 0.9.', default=0.9)
+
+    global_args = parser.parse_args()
+
+    print('Args: ', global_args)
+    N_ = global_args.numSamples # Number of samples to calculate alpha coefficients
+    n_ = global_args.numVariables # Number of variable
+    function_name_ = global_args.function
+    m_ = global_args.legendreDegree # Degree of the Legendre polynomial
+    a_ = global_args.min # Range of the function
+    b_ = global_args.max # Range of the function
+    is_adaptive_ = global_args.adaptive
+    random_init_ = global_args.randomInit
+    k_ = global_args.numClosestPoints
+    epsilon_ = global_args.epsilon
+    clip_ = global_args.clip
+
+    status_hdmr, _, _, file_name = main_function(N_, n_, function_name_, m_, a_, b_, random_init_, 
+                                                is_adaptive_, k_, epsilon_, clip_)
     print(f"hdmr_opt status: {status_hdmr}")
 
     with open(file_name + '.txt', 'w') as f:
         # f.write("BFGS Status\n" + str(status_bfgs) + "\n\n")
         f.write("HDMR Status\n" + str(status_hdmr))
-    f.close()
+    f.close()
+            
+    plt.show()