Some changes

app.py

@@ -38,29 +38,33 @@ def complex_heat_eq_solution(x, t, k, a, b, c):
     )
 
 
-def plot_heat_equation(m, approx_type):
+def plot_heat_equation(m, approx_type, quality, rand_or_det):
     global glob_k, glob_a, glob_b, glob_c, n_x, n_t
 
+    # Plot with more points than it was calculated
+    new_nx = 1 * n_x
+    new_nt = 1 * n_t
+
     try:
-        loaded_values = np.load(f"{approx_type}_m{m}.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"]
     Phi = loaded_values["Phi"]
 
     # Create grids for x and t
-    x = np.linspace(0, 1, n_x)  # Spatial grid
-    t = np.linspace(0, 5, n_t)  # Temporal grid
+    x = np.linspace(0, 1, new_nx)  # Spatial grid
+    t = np.linspace(0, 5, new_nt)  # Temporal grid
     X, T = np.meshgrid(x, t)
 
     # Compute the real solution over the grid
     U_real = complex_heat_eq_solution(X, T, glob_k, glob_a, glob_b, glob_c)
 
     # Compute the selected approximation
-    U_approx = np.zeros_like(U_real)
-    for i, t_val in enumerate(t):
-        Phi_gff_at_t = Phi[i * n_x : (i + 1) * n_x]
-        U_approx[i, :] = np.dot(Phi_gff_at_t, alpha)
+    # Compute the approximations as a single matrix multiplication
+    Phi_reshaped = Phi.reshape(n_t, n_x, -1)
+    # The result will be of shape (n_t, n_x), as U_approx should match U_real's shape
+    U_approx = np.einsum("ijk,k->ij", Phi_reshaped, alpha)
 
     # Create the 3D plot with Plotly
     traces = []
@@ -133,11 +137,11 @@ def plot_heat_equation(m, approx_type):
     return fig
 
 
-def plot_errors(m, approx_type):
+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}.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"]
@@ -154,8 +158,8 @@ def plot_errors(m, approx_type):
     # Compute the selected approximation
     U_approx = np.zeros_like(U_real)
     for i, t_val in enumerate(t):
-        Phi_gff_at_t = Phi[i * n_x : (i + 1) * n_x]
-        U_approx[i, :] = np.dot(Phi_gff_at_t, alpha)
+        Phi_at_t = Phi[i * n_x : (i + 1) * n_x]
+        U_approx[i, :] = np.dot(Phi_at_t, alpha)
 
     U_err = abs(U_approx - U_real)
 
@@ -229,19 +233,19 @@ def generate_data():
     return a_train, u_train, x, t
 
 
-def random_features(a, theta_j, kernel="SINE", k=0.5, t=1.0):
+def features(a, theta_j, kernel="SINE", k=1, eps=1e-8):
     """Compute random features with adjustable kernel width."""
     if kernel == "SINE":
-        return np.sin(t * np.linalg.norm(a - theta_j, axis=-1))
+        return np.sin(k * np.linalg.norm(a - theta_j, axis=-1) + eps)
     elif kernel == "GFF":
-        return np.log(np.linalg.norm(a - theta_j, axis=-1)) / (2 * np.pi)
+        return np.log(np.linalg.norm(a - theta_j, axis=-1) + eps) / (2 * np.pi)
     else:
         raise ValueError("Unsupported kernel type!")
 
 
 def design_matrix(a, theta, kernel):
     """Construct design matrix."""
-    return np.array([random_features(a, theta_j, kernel=kernel) for theta_j in theta]).T
+    return np.array([features(a, theta_j, kernel=kernel) for theta_j in theta]).T
 
 
 def learn_coefficients(Phi, u):
@@ -255,29 +259,7 @@ def approximate_solution(a, alpha, theta, kernel):
     return Phi @ alpha
 
 
-def polyfit2d(x, y, z, kx=3, ky=3, order=None):
-    # grid coords
-    x, y = np.meshgrid(x, y)
-    # coefficient array, up to x^kx, y^ky
-    coeffs = np.ones((kx + 1, ky + 1))
-
-    # solve array
-    a = np.zeros((coeffs.size, x.size))
-
-    # for each coefficient produce array x^i, y^j
-    for index, (j, i) in enumerate(np.ndindex(coeffs.shape)):
-        # do not include powers greater than order
-        if order is not None and i + j > order:
-            arr = np.zeros_like(x)
-        else:
-            arr = coeffs[i, j] * x**i * y**j
-        a[index] = arr.ravel()
-
-    # do leastsq fitting and return leastsq result
-    return np.linalg.lstsq(a.T, np.ravel(z), rcond=None)
-
-
-def train_coefficients(m, kernel):
+def train_coefficients(m, kernel, 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()
@@ -286,36 +268,57 @@ def train_coefficients(m, kernel):
     a_train, u_train, x, t = generate_data()
 
     # Define random features
-    theta = np.column_stack(
-        (
-            np.random.uniform(-1, 1, size=m),  # First dimension: [-1, 1]
-            np.random.uniform(-5, 5, size=m),  # Second dimension: [-5, 5]
+    if rand_or_det == "Random":
+        theta = np.column_stack(
+            (
+                np.random.uniform(-1, 1, size=m),  # First dimension: [-1, 1]
+                np.random.uniform(-5, 5, size=m),  # Second dimension: [-5, 5]
+            )
+        )
+    else:
+        theta = np.column_stack(
+            (
+                np.linspace(-1, 1, m),  # First dimension: [-1, 1]
+                np.linspace(-5, 5, m),  # Second dimension: [-5, 5]
+            )
         )
-    )
 
     # Construct design matrix and learn coefficients
     Phi = design_matrix(a_train, theta, kernel)
     alpha = learn_coefficients(Phi, u_train)
-    # Validate and animate results
-    u_real = np.array(
-        [complex_heat_eq_solution(x, t_i, glob_k, glob_a, glob_b, glob_c) for t_i in t]
-    )
-    a_test = np.c_[np.meshgrid(x, t)[0].ravel(), np.meshgrid(x, t)[1].ravel()]
-    u_approx = approximate_solution(a_test, alpha, theta, kernel).reshape(n_t, n_x)
+
+    end_time = f"{time.time() - start_time:.2f}"
 
     # Save values to the npz folder
     np.savez(
-        f"{kernel}_m{m}.npz",
+        f"{kernel}_m{m}_{str.lower(quality)}_{str.lower(rand_or_det)}.npz",
         alpha=alpha,
         kernel=kernel,
         Phi=Phi,
         theta=theta,
     )
 
+    # Create grids for x and t
+    # x_random = np.random.uniform(0, 1, 10 * n_x)  # Spatial grid
+    # t_random = np.random.uniform(0, 5, 10 * n_t)  # Temporal grid
+    # X, T = np.meshgrid(x_random, t_random)  # Create the mesh grid
+    # Compute the real solution over the grid
+    # U_real = complex_heat_eq_solution(X, T, glob_k, glob_a, glob_b, glob_c)
+    # print(U_real.shape)
+    # print(U_real)
+    # Compute the selected approximation
+    # 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)
+    #        U_approx[j, i] = np.dot(Phi_at_x_t, alpha)
+
     # Compute average error
-    avg_err = np.mean(np.abs(u_real - u_approx))
+    # avg_err = np.mean(np.abs(U_real - U_approx))
 
-    return f"Training completed in {time.time() - start_time:.2f} seconds. The average error is {avg_err}."
+    return (
+        f"Training completed in {end_time} seconds."  # The average error is {avg_err}."
+    )
 
 
 def plot_function(k, a, b, c):
@@ -381,12 +384,14 @@ def plot_function(k, a, b, c):
     return fig
 
 
-def plot_all(m, kernel):
+def plot_all(m, kernel, quality, rand_or_det):
     # Generate the plot content (replace this with your actual plot logic)
     approx_fig = plot_heat_equation(
-        m, kernel
+        m, kernel, quality, rand_or_det
     )  # Replace with your function for approx_plot
-    error_fig = plot_errors(m, kernel)  # Replace with your function for error_plot
+    error_fig = plot_errors(
+        m, kernel, quality, rand_or_det
+    )  # Replace with your function for error_plot
 
     # Return the figures and make the plots visible
     return (
@@ -431,7 +436,6 @@ def create_gradio_ui():
         # Function parameter inputs
         gr.Markdown(markdown_content)
 
-
         with gr.Row():
             with gr.Column(min_width=500):
                 k_slider = gr.Slider(
@@ -487,8 +491,13 @@ def create_gradio_ui():
                     choices=[50, 250, 1000, 5000, 10000, 25000],
                     value=1000,
                 )
-                # Output to show status
-                output = gr.Textbox(label="Status", interactive=False)
+                rand_det_dropdown = gr.Dropdown(
+                    label="Choose Random / Deterministic",
+                    choices=["Deterministic", "Random"],
+                    value="Deterministic",
+                )
+            # Output to show status
+            output = gr.Textbox(label="Status", interactive=False)
 
             with gr.Column():
                 # Button to train coefficients
@@ -496,7 +505,7 @@ def create_gradio_ui():
                 # Function to trigger training and update dropdown
                 train_button.click(
                     fn=train_coefficients,
-                    inputs=[m_slider, kernel_dropdown],
+                    inputs=[m_slider, kernel_dropdown, quality_dropdown, rand_det_dropdown],
                     outputs=output,
                 )
                 approx_button = gr.Button("Plot Approximation")
@@ -509,7 +518,7 @@ def create_gradio_ui():
 
         approx_button.click(
             fn=plot_all,
-            inputs=[m_slider, kernel_dropdown],
+            inputs=[m_slider, kernel_dropdown, quality_dropdown, rand_det_dropdown],
             outputs=[approx_plot, error_plot],
         )