Added flexible range.

app.py

@@ -17,7 +17,7 @@ def Pn(m, x):
 def L(a,b,m,x):
     return np.sqrt((2*m+1)/(b-a))*Pn(m, 2*(x-b)/(b-a)+1)
 
-def sobol(x, y, m):
+def sobol(x, y, m, range_min, range_max):
     print(x.shape, y.shape)
     N, n = x.shape 
     f0 = np.mean(y)
@@ -26,9 +26,9 @@ def sobol(x, y, m):
 
     for r in range(m):  
         for i in range(n):  
-            alpha[r, i] = np.mean((y-f0) * L(0, 1, r+1, np.array(x[:, [i]])))
+            alpha[r, i] = (range_max-range_min) * np.mean((y-f0) * L(range_min, range_max, r+1, np.array(x[:, [i]])))
     
-    global_D = np.mean(y ** 2) - np.mean(y) ** 2
+    global_D = (range_max-range_min)*np.mean(y ** 2) - ((range_max-range_min)*np.mean(y)) ** 2
     D_first_order = np.zeros((n))
     S_first_order = np.zeros((n))
     for k in range(n):
@@ -37,33 +37,33 @@ def sobol(x, y, m):
 
     return S_first_order, f0, alpha
 
-def evalute_hdmr(x, f0, alpha):
+def evalute_hdmr(x, f0, alpha, range_min, range_max):
     N, n = x.shape  
     m, _ = alpha.shape
     y = f0 * np.ones((N,1))
     for r in range(m):  
         for i in range(n):  
-            y = y + alpha[r, i] * L(0, 1, r+1, np.array(x[:, [i]]))
+            y = y + alpha[r, i] * L(range_min, range_max, r+1, np.array(x[:, [i]]))
     return y
 
 def f(x):
     return np.sum((x-0.5)**2,axis=1,keepdims=True)
 
-def optimize(N,n,m,func_code,trn_ratio):
+def optimize(N,n,m,func_code,trn_ratio,range_min,range_max):
     global df_trn, df_hat_trn, df_tst, df_hat_tst
     print(func_code)
     print(N)
     N_trn = round(N*trn_ratio)
     N_tst = N - N_trn
     print(f'N:{N} N_trn:{N_trn} N_tst:{N_tst}')
-    x_trn = np.random.uniform(0,1,size=(N_trn,n))
+    x_trn = np.random.uniform(range_min,range_max,size=(N_trn,n))
     y_trn = eval(func_code, {'x': x_trn,'np':np})
-    x_tst = np.random.uniform(0,1,size=(N_tst,n))
+    x_tst = np.random.uniform(range_min,range_max,size=(N_tst,n))
     y_tst = eval(func_code, {'x': x_tst,'np':np})
 
-    si, f0, alpha = sobol(x_trn, y_trn, m)
-    yhat_trn = evalute_hdmr(x_trn, f0, alpha)
-    yhat_tst = evalute_hdmr(x_tst, f0, alpha)
+    si, f0, alpha = sobol(x_trn, y_trn, m, range_min, range_max)
+    yhat_trn = evalute_hdmr(x_trn, f0, alpha, range_min, range_max)
+    yhat_tst = evalute_hdmr(x_tst, f0, alpha, range_min, range_max)
     out = ''
     out += f'trn x:{x_trn.shape} y:{y_trn.shape}'
     out += f'tst x:{x_tst.shape} y:{y_tst.shape}'
@@ -132,6 +132,16 @@ with gd.Blocks() as demo:
                         to construct the meta-model.
                         """)
             trn_ratio = gd.Slider(0.1, 0.9, value=0.2, step=0.1, label="Training ratio")
+            range_min = gd.Slider(-10.0, 10.0, step=0.01, value=-5, label="Minimum value of the range",
+                        info="""
+                        Please choose the lowest value of the range. Make sure the range_min is less than
+                        range_max.
+                        """)
+            range_max = gd.Slider(-10.0, 10.0, step=0.01, value=5, label="Maximum value of the range",
+                        info="""
+                        Please choose the highest value of the range. Make sure the range_max is greate than
+                        range_min.
+                        """)
 
         with gd.Column():
             func_disp = gd.Markdown()
@@ -144,22 +154,23 @@ with gd.Blocks() as demo:
             )
             btn = gd.Button('Create FEOM')
     gd.Examples([["np.sum((10*x-5)**2 - 10*np.cos(2*3.14*(10*x-5)),axis=1,keepdims=True) +10*x.shape[1]", 
-                 "$$\mathbf{y} = 10n+\sum_{i=1}^n[\mathbf{x}_i^2-10 \cos(2 \pi x_i)] \;\; \mathbf{x}_i \in R^{N}$$"],
-        ["np.sum((x-0.5)**2,axis=1,keepdims=True)","$$\mathbf{y} = \sum_i^n(\mathbf{x}_i-0.5)^2,\;\; \mathbf{x}_i \in R^{N}$$"],
-        ["np.sum(x,axis=1,keepdims=True)","$$\mathbf{y} = \sum_i^n \mathbf{x}_i \;\; \mathbf{x}_i \in R^{N}$$"],
-        ["np.sum((x-0.5)**3,axis=1,keepdims=True)","$$\mathbf{y} = \sum_i^n (\mathbf{x}_i-0.5)^3 \;\; \mathbf{x}_i \in R^{N}$$"]],
-        inputs=[func_code,func_disp])
+                 "$$\mathbf{y} = 10n+\sum_{i=1}^n[\mathbf{x}_i^2-10 \cos(2 \pi x_i)] \;\; \mathbf{x}_i \in R^{N}$$",
+                 0,1],
+        ["np.sum((x-0.5)**2,axis=1,keepdims=True)","$$\mathbf{y} = \sum_i^n(\mathbf{x}_i-0.5)^2,\;\; \mathbf{x}_i \in R^{N}$$",0,1],
+        ["np.sum(x,axis=1,keepdims=True)","$$\mathbf{y} = \sum_i^n \mathbf{x}_i \;\; \mathbf{x}_i \in R^{N}$$",0,1],
+        ["np.sum((x-0.5)**3,axis=1,keepdims=True)","$$\mathbf{y} = \sum_i^n (\mathbf{x}_i-0.5)^3 \;\; \mathbf{x}_i \in R^{N}$$",0,1]],
+        inputs=[func_code,func_disp,range_min,range_max])
     with gd.Row():
-        gd.Markdown('Training Data')
-        gd.Markdown('FEOM applied to Training')
+        gd.Markdown('Original Training Data')
+        gd.Markdown('HDMR Approximation applied to Training Data')
         r2_out_trn = gd.Markdown('R2 Score on Training')
     with gd.Row():
         pdp_trn = gd.ScatterPlot(label='Scatter plot of input data').style(container=True)
         feom_trn = gd.ScatterPlot(label='Scatter plot of FEOM').style(container=True)
         corr_trn = gd.ScatterPlot(label='y versus feom')
     with gd.Row():
-        gd.Markdown('Testing')
-        gd.Markdown('FEOM applied to Testing')
+        gd.Markdown('Original Testing Data')
+        gd.Markdown('HDMR Approximation applied to Testing Data')
         r2_out_tst = gd.Markdown('R2 Score on Testing')
     with gd.Row():
         pdp_tst = gd.ScatterPlot(label='Scatter plot of input data').style(container=True)
@@ -168,19 +179,19 @@ with gd.Blocks() as demo:
                
     pdp_x = gd.Dropdown(['x1','x2'], label="Choose input variable to show in scatter plots")
     out = gd.TextArea()
-    btn.click(optimize, inputs=[N,n,m,func_code, trn_ratio], 
+    btn.click(optimize, inputs=[N,n,m,func_code, trn_ratio,range_min,range_max], 
               outputs=[out, pdp_x, pdp_trn, feom_trn,corr_trn,r2_out_trn,
                        pdp_tst, feom_tst,corr_tst,r2_out_tst])
-    n.change(optimize, inputs=[N,n,m,func_code,trn_ratio],
+    n.change(optimize, inputs=[N,n,m,func_code,trn_ratio,range_min,range_max],
               outputs=[out, pdp_x, pdp_trn, feom_trn,corr_trn,r2_out_trn,
                        pdp_tst, feom_tst,corr_tst,r2_out_tst])
-    N.change(optimize, inputs=[N,n,m,func_code,trn_ratio], 
+    N.change(optimize, inputs=[N,n,m,func_code,trn_ratio,range_min,range_max], 
               outputs=[out, pdp_x, pdp_trn, feom_trn,corr_trn,r2_out_trn,
                        pdp_tst, feom_tst,corr_tst,r2_out_tst])
-    m.change(optimize, inputs=[N,n,m,func_code,trn_ratio], 
+    m.change(optimize, inputs=[N,n,m,func_code,trn_ratio,range_min, range_max], 
               outputs=[out, pdp_x, pdp_trn, feom_trn,corr_trn,r2_out_trn,
                        pdp_tst, feom_tst,corr_tst,r2_out_tst])
-    trn_ratio.change(optimize, inputs=[N,n,m,func_code,trn_ratio], 
+    trn_ratio.change(optimize, inputs=[N,n,m,func_code,trn_ratio,range_min, range_max], 
               outputs=[out, pdp_x, pdp_trn, feom_trn,corr_trn,r2_out_trn,
                        pdp_tst, feom_tst,corr_tst,r2_out_tst])
     pdp_x.change(change_pdp, inputs=pdp_x, outputs=[pdp_trn, feom_trn, pdp_tst, feom_tst])