Change wording

app.py

@@ -46,7 +46,9 @@ def plot_heat_equation(m, approx_type, quality, rand_or_det):
     new_nt = 1 * n_t
 
     try:
-        loaded_values = np.load(f"{approx_type}_m{m}_{str.lower(quality)}_{str.lower(rand_or_det)}.npz")
+        loaded_values = np.load(
+            f"{approx_type}_m{m}_{str.lower(quality)}_{str.lower(rand_or_det)}.npz"
+        )
     except:
         raise gr.Error(f"First train the coefficients for {approx_type} and m = {m}")
     alpha = loaded_values["alpha"]
@@ -141,7 +143,9 @@ def plot_errors(m, approx_type, quality, rand_or_det):
     global n_x, n_t
 
     try:
-        loaded_values = np.load(f"{approx_type}_m{m}_{str.lower(quality)}_{str.lower(rand_or_det)}.npz")
+        loaded_values = np.load(
+            f"{approx_type}_m{m}_{str.lower(quality)}_{str.lower(rand_or_det)}.npz"
+        )
     except:
         raise gr.Error(f"First train the coefficients for {approx_type} and m = {m}")
     alpha = loaded_values["alpha"]
@@ -233,19 +237,21 @@ def generate_data():
     return a_train, u_train, x, t
 
 
-def features(a, theta_j, kernel="SINE", k=1, eps=1e-8):
-    """Compute random features with adjustable kernel width."""
-    if kernel == "SINE":
+def features(a, theta_j, m, method="SINE", k=1, eps=1e-8):
+    """Compute random features with adjustable method width."""
+    if method == "SINE":
         return np.sin(k * np.linalg.norm(a - theta_j, axis=-1) + eps)
-    elif kernel == "GFF":
+    elif method == "GFF":
         return np.log(np.linalg.norm(a - theta_j, axis=-1) + eps) / (2 * np.pi)
     else:
-        raise ValueError("Unsupported kernel type!")
+        raise ValueError("Unsupported method type!")
 
 
-def design_matrix(a, theta, kernel):
+def design_matrix(a, theta, method):
     """Construct design matrix."""
-    return np.array([features(a, theta_j, kernel=kernel) for theta_j in theta]).T
+    return np.array(
+        [features(a, theta_j, theta.shape[0], method) for theta_j in theta]
+    ).T
 
 
 def learn_coefficients(Phi, u):
@@ -253,13 +259,13 @@ def learn_coefficients(Phi, u):
     return np.linalg.lstsq(Phi, u, rcond=None)[0]
 
 
-def approximate_solution(a, alpha, theta, kernel):
+def approximate_solution(a, alpha, theta, method):
     """Compute the approximation."""
-    Phi = design_matrix(a, theta, kernel)
+    Phi = design_matrix(a, theta, method)
     return Phi @ alpha
 
 
-def train_coefficients(m, kernel, quality, rand_or_det):
+def train_coefficients(m, method, quality, rand_or_det):
     global glob_k, glob_a, glob_b, glob_c, n_x, n_t
     # Start time for training
     start_time = time.time()
@@ -278,22 +284,22 @@ def train_coefficients(m, kernel, quality, rand_or_det):
     else:
         theta = np.column_stack(
             (
-                np.linspace(-1, 1, m),  # First dimension: [-1, 1]
-                np.linspace(-5, 5, m),  # Second dimension: [-5, 5]
+                np.linspace(-0.5, 0.5, m),  # Nonlinear spacing for x
+                np.linspace(-2.5, 2.5, m),  # Nonlinear spacing for y
             )
         )
 
     # Construct design matrix and learn coefficients
-    Phi = design_matrix(a_train, theta, kernel)
+    Phi = design_matrix(a_train, theta, method)
     alpha = learn_coefficients(Phi, u_train)
 
     end_time = f"{time.time() - start_time:.2f}"
 
     # Save values to the npz folder
     np.savez(
-        f"{kernel}_m{m}_{str.lower(quality)}_{str.lower(rand_or_det)}.npz",
+        f"{method}_m{m}_{str.lower(quality)}_{str.lower(rand_or_det)}.npz",
         alpha=alpha,
-        kernel=kernel,
+        method=method,
         Phi=Phi,
         theta=theta,
     )
@@ -310,7 +316,7 @@ def train_coefficients(m, kernel, quality, rand_or_det):
     # U_approx = np.zeros_like(U_real)
     # for i, xpos in enumerate(x_random):
     #    for j, tpos in enumerate(t_random):
-    #        Phi_at_x_t = test_approx([xpos, tpos], theta, kernel)
+    #        Phi_at_x_t = test_approx([xpos, tpos], theta, method)
     #        U_approx[j, i] = np.dot(Phi_at_x_t, alpha)
 
     # Compute average error
@@ -384,13 +390,13 @@ def plot_function(k, a, b, c):
     return fig
 
 
-def plot_all(m, kernel, quality, rand_or_det):
+def plot_all(m, method, quality, rand_or_det):
     # Generate the plot content (replace this with your actual plot logic)
     approx_fig = plot_heat_equation(
-        m, kernel, quality, rand_or_det
+        m, method, quality, rand_or_det
     )  # Replace with your function for approx_plot
     error_fig = plot_errors(
-        m, kernel, quality, rand_or_det
+        m, method, quality, rand_or_det
     )  # Replace with your function for error_plot
 
     # Return the figures and make the plots visible
@@ -432,7 +438,7 @@ def create_gradio_ui():
     $$
     \argmin_{\alpha\in\mathbb{R}^m}\|{\alpha\Phi-u}\|_2^2,
     $$
-    where $\Phi$ contains the features depending on the kernel.
+    where $\Phi$ contains the features depending on the method.
     """
 
     # Get the initial available files
@@ -440,7 +446,13 @@ def create_gradio_ui():
         gr.Markdown("# Approximating a solution to the heat equation using RFM")
 
         # Function parameter inputs
-        gr.Markdown(markdown_content, latex_delimiters=[ {"left": "$$", "right": "$$", "display": True }, {"left": "$", "right": "$", "display": False }])
+        gr.Markdown(
+            markdown_content,
+            latex_delimiters=[
+                {"left": "$$", "right": "$$", "display": True},
+                {"left": "$", "right": "$", "display": False},
+            ],
+        )
 
         with gr.Row():
             with gr.Column(min_width=500):
@@ -482,15 +494,15 @@ def create_gradio_ui():
 
         with gr.Column():
             with gr.Row():
-                # Kernel selection and slider for m
+                # method selection and slider for m
                 quality_dropdown = gr.Dropdown(
                     label="Choose Quality", choices=["Low", "Mid", "High"], value="Low"
                 )
                 quality_dropdown.change(
                     fn=change_quality, inputs=quality_dropdown, outputs=None
                 )
-                kernel_dropdown = gr.Dropdown(
-                    label="Choose Kernel", choices=["SINE", "GFF"], value="SINE"
+                method_dropdown = gr.Dropdown(
+                    label="Choose Method", choices=["SINE", "GFF"], value="SINE"
                 )
                 m_slider = gr.Dropdown(
                     label="Number of Random Features (m)",
@@ -511,7 +523,12 @@ def create_gradio_ui():
                 # Function to trigger training and update dropdown
                 train_button.click(
                     fn=train_coefficients,
-                    inputs=[m_slider, kernel_dropdown, quality_dropdown, rand_det_dropdown],
+                    inputs=[
+                        m_slider,
+                        method_dropdown,
+                        quality_dropdown,
+                        rand_det_dropdown,
+                    ],
                     outputs=output,
                 )
                 approx_button = gr.Button("Plot Approximation")
@@ -524,7 +541,7 @@ def create_gradio_ui():
 
         approx_button.click(
             fn=plot_all,
-            inputs=[m_slider, kernel_dropdown, quality_dropdown, rand_det_dropdown],
+            inputs=[m_slider, method_dropdown, quality_dropdown, rand_det_dropdown],
             outputs=[approx_plot, error_plot],
         )