updating run.py

Author: lorenzotomada

scripts/profiling.py

@@ -10,14 +10,17 @@
     QR,
     QR_cp,
 )
-from pyclassify.utils import make_symmetric, read_config
+from pyclassify.utils import (
+    make_symmetric,
+    read_config,
+    profile_with_cprofile,
+    profile_with_cupy_profiler,
+)
 import numpy as np
 import scipy.sparse as sp
+import scipy
 import random
 import argparse
-import cProfile
-import os
-import csv
 
 
 seed = 8422
@@ -34,80 +37,50 @@
     args.config if args.config else "./experiments/config"
 )  # automatic choice if no argument is passed
 
+
 kwargs = read_config(filename)
 dim = kwargs["dim"]
 density = kwargs["density"]
 tol = kwargs["tol"]
 max_iter = kwargs["max_iter"]
 
 
-matrix = sp.random(dim, dim, density=density, format="coo")
-matrix = make_symmetric(matrix)
-cp_symm_matrix = cpsp.csr_matrix(matrix)
+eigenvals = np.arange(1, dim + 1)
+A = np.diag(eigenvals)
+U = scipy.stats.ortho_group.rvs(dim)
+A = U @ A @ U.T
+A = make_symmetric(A)
+A = sp.csr_matrix(A)
+A_cp = cpsp.csr_matrix(A)
 
 
-logs = "./logs"
+log_file = "./logs/timings.csv"
 iteration_factor = 300
 
 
-def profile_with_cprofile(func_name, func, *args, **kwargs):
-    log_file = "./logs/timings.csv"
-    with open(log_file, "a", newline="") as csvfile:
-        writer = csv.writer(csvfile)
-
-        profile_output = cProfile.Profile()
-        profile_output.enable()
-
-        result = func(*args, **kwargs)
-
-        profile_output.disable()
-
-        stats = profile_output.getstats()
-        total_time = sum(stat.totaltime for stat in stats)
-
-        print(f"{func_name}: {total_time:.6f} s")
-
-        writer.writerow([func_name, dim, total_time])
-
-    return result
-
-
 profile_with_cprofile(
-    "eigenvalues_np", eigenvalues_np, matrix.toarray(), symmetric=True
+    log_file, dim, "eigenvalues_np", eigenvalues_np, A.toarray(), symmetric=True
+)
+profile_with_cprofile(
+    log_file, dim, "eigenvalues_sp", eigenvalues_sp, A, symmetric=True
+)
+profile_with_cprofile(log_file, dim, "power_method", power_method, A)
+profile_with_cprofile(
+    log_file, dim, "power_method_numba", power_method_numba, A.toarray()
+)
+profile_with_cprofile(
+    log_file, dim, "QR", QR, A.toarray(), max_iter=iteration_factor * dim
 )
-profile_with_cprofile("eigenvalues_sp", eigenvalues_sp, matrix, symmetric=True)
-profile_with_cprofile("power_method", power_method, matrix)
-profile_with_cprofile("power_method_numba", power_method_numba, matrix.toarray())
-profile_with_cprofile("QR", QR, matrix.toarray(), max_iter=iteration_factor * dim)
-
-
-def profile_with_cupy_profiler(func_name, func, *args, **kwargs):
-    log_file = "./logs/timings.csv"
-    with open(log_file, "a", newline="") as csvfile:
-        writer = csv.writer(csvfile)
-        start = cp.cuda.Event()
-        end = cp.cuda.Event()
-
-        start.record()
-        result = func(*args, **kwargs)
-        end.record()
-        end.synchronize()
-
-        result = func(*args, **kwargs)
-        elapsed_time = cp.cuda.get_elapsed_time(start, end) / 1000
-        print(f"{func_name}: {elapsed_time:.6f} s")
-
-        writer.writerow([func_name, dim, elapsed_time])
-
-    return result
 
 
-profile_with_cupy_profiler("eigenvalues_cp", eigenvalues_cp, cp_symm_matrix)
-profile_with_cupy_profiler("power_method_cp", power_method_cp, cp_symm_matrix)
+profile_with_cupy_profiler(log_file, dim, "eigenvalues_cp", eigenvalues_cp, A_cp)
+profile_with_cupy_profiler(log_file, dim, "power_method_cp", power_method_cp, A_cp)
 profile_with_cupy_profiler(
+    log_file,
+    dim,
     "QR_cp",
     QR_cp,
-    cp_symm_matrix,
+    A_cp,
     q0=cp.random.rand(dim),
     tol=1e-3,
     max_iter=iteration_factor * dim,

scripts/run.py

@@ -1,92 +1,91 @@
-import cupyx.scipy.sparse as cpsp
-import cupy as cp
-from pyclassify import (
-    eigenvalues_np,
-    eigenvalues_sp,
-    eigenvalues_cp,
-    power_method,
-    power_method_numba,
-    power_method_cp,
-    QR,
-    QR_cp,
-)
-from pyclassify.utils import make_symmetric, read_config
-import numpy as np
-import scipy.sparse as sp
-import random
-import argparse
-import cProfile
-import cupyx.profiler as profiler
-import os
-import csv
-
-
-random.seed(226)
-cp.random.seed(226)
-np.random.seed(226)
-
-
-parser = argparse.ArgumentParser()
-parser.add_argument("--config", type=str, required=False, help="config file:")
-
-
-args = parser.parse_args()
-filename = (
-    args.config if args.config else "./experiments/config"
-)  # automatic choice if no argument is passed
-
-
-kwargs = read_config(filename)
-dim = kwargs["dim"]
-density = kwargs["density"]
-tol = kwargs["tol"]
-max_iter = kwargs["max_iter"]
-
-
-matrix = sp.random(dim, dim, density=density, format="csr")
-matrix = make_symmetric(matrix)
-cp_symm_matrix = cpsp.csr_matrix(matrix)
-
-
-logs = "./logs"
-iteration_factor = 300
-
-
-cProfile.run(
-    "eigenvalues_np(matrix.toarray(), symmetric=True)",
-    os.path.join(logs, f"eigenvalues_np_{dim}.prof"),
-)
-cProfile.run(
-    "eigenvalues_np(matrix, symmetric=True)",
-    os.path.join(logs, f"eigenvalues_sp_{dim}.prof"),
-)
-cProfile.run("power_method(matrix)", os.path.join(logs, f"power_method_{dim}.prof"))
-cProfile.run(
-    "power_method(matrix.toarray())",
-    os.path.join(logs, f"power_method_numba{dim}.prof"),
-)
-cProfile.run(
-    "QR(matrix.toarray(), max_iter=iteration_factor*d)",
-    os.path.join(logs, f"QR_{dim}.prof"),
-)
-
-
-def profile_function(func_name, func, *args, **kwargs):
-    cupyx.profiler.start()
-    result = func(*args, **kwargs)
-    cupyx.profiler.stop()
-
-    profiler_data = cupyx.profiler.get_profiler()
-
-    output_file = os.path.join(logs, f"{func_name}_{dim}.prof")
-    with open(output_file, "w") as f:
-        f.write(str(profiler_data))
-
-    elapsed_time = profiler_data[0]["time"]
-    print(f"{func_name}: {elapsed_time/1000} s")
-    return result
-
-
-profile_function("eigenvalues_cp", eigenvalues_cp, cp_symm_matrix)
-profile_function("power_method_cp", power_method_cp, cp_symm_matrix)
-profile_function("QR_cp", QR_cp, cp_symm_matrix, max_iter=iteration_factor * d)
+import cupyx.scipy.sparse as cpsp
+import cupy as cp
+from pyclassify import (
+    eigenvalues_np,
+    eigenvalues_sp,
+    eigenvalues_cp,
+    power_method,
+    power_method_numba,
+    power_method_cp,
+    QR,
+    QR_cp,
+)
+from pyclassify.utils import (
+    make_symmetric,
+    read_config,
+    profile_with_cprofile,
+    profile_with_cupy_profiler,
+)
+import numpy as np
+import scipy.sparse as sp
+import scipy
+import random
+import argparse
+
+
+cp.cuda.Device(0).use()
+cp.get_default_memory_pool().free_all_blocks()
+
+
+seed = 8422
+random.seed(seed)
+cp.random.seed(seed)
+np.random.seed(seed)
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--config", type=str, required=False, help="config file:")
+
+args = parser.parse_args()
+filename = (
+    args.config if args.config else "./experiments/config"
+)  # automatic choice if no argument is passed
+
+
+kwargs = read_config(filename)
+dim = kwargs["dim"]
+density = kwargs["density"]
+tol = kwargs["tol"]
+max_iter = kwargs["max_iter"]
+
+
+eigenvals = np.arange(1, dim + 1)
+A = np.diag(eigenvals)
+U = scipy.stats.ortho_group.rvs(dim)
+A = U @ A @ U.T
+A = make_symmetric(A)
+A = sp.csr_matrix(A)
+A_cp = cpsp.csr_matrix(A)
+
+
+log_file = "./logs/timings.csv"
+iteration_factor = 300
+
+
+profile_with_cprofile(
+    log_file, dim, "eigenvalues_np", eigenvalues_np, A.toarray(), symmetric=True
+)
+profile_with_cprofile(
+    log_file, dim, "eigenvalues_sp", eigenvalues_sp, A, symmetric=True
+)
+profile_with_cprofile(log_file, dim, "power_method", power_method, A)
+profile_with_cprofile(
+    log_file, dim, "power_method_numba", power_method_numba, A.toarray()
+)
+profile_with_cprofile(
+    log_file, dim, "QR", QR, A.toarray(), max_iter=iteration_factor * dim
+)
+
+
+profile_with_cupy_profiler(log_file, dim, "eigenvalues_cp", eigenvalues_cp, A_cp)
+profile_with_cupy_profiler(log_file, dim, "power_method_cp", power_method_cp, A_cp)
+profile_with_cupy_profiler(
+    log_file,
+    dim,
+    "QR_cp",
+    QR_cp,
+    A_cp,
+    q0=cp.random.rand(dim),
+    tol=1e-3,
+    max_iter=iteration_factor * dim,
+)

shell/submit.sbatch

@@ -46,7 +46,7 @@ for dim in 100 500 1000; do
     echo "tol: $tol" >> experiments/config.yaml
     echo "max_iter: $max_iter" >> experiments/config.yaml
 
-    python scripts/profiling.py
+    python scripts/run.py
 
     echo "dim: $dim - times saved in logs/timings.csv" 
     echo '--------------------------------------------------'

src/pyclassify/eigenvalues.py

@@ -391,7 +391,6 @@ def QR_method(diag, off_diag, tol=1e-8, max_iter=1000):
         iter += 1
         if abs(off_diag[m - 1]) < tol * (np.abs(diag[m]) + np.abs(diag[m - 1])):
             m -= 1
-
     return diag, Q
 
 

src/pyclassify/utils.py

@@ -5,10 +5,11 @@
 import numba
 import os
 import yaml
-from line_profiler import profile
 
-
-# from numba.pycc import CC
+# from line_profiler import profile
+import cProfile
+import cupyx.profiler as profiler
+import csv
 
 
 def check_square_matrix(A):
@@ -136,3 +137,50 @@ def read_config(file: str) -> dict:
     with open(filepath, "r") as stream:
         kwargs = yaml.safe_load(stream)
     return kwargs
+
+
+def profile_with_cprofile(log_file, dim, func_name, func, *args, **kwargs):
+    """
+    Function used to profile the code using cProfile.
+    """
+    with open(log_file, "a", newline="") as csvfile:
+        writer = csv.writer(csvfile)
+
+        profile_output = cProfile.Profile()
+        profile_output.enable()
+
+        result = func(*args, **kwargs)
+
+        profile_output.disable()
+
+        stats = profile_output.getstats()
+        total_time = sum(stat.totaltime for stat in stats)
+
+        print(f"{func_name}: {total_time:.6f} s")
+
+        writer.writerow([func_name, dim, total_time])
+
+    return result
+
+
+def profile_with_cupy_profiler(log_file, dim, func_name, func, *args, **kwargs):
+    """
+    Function used to profile the code using the CuPy profiler.
+    """
+    with open(log_file, "a", newline="") as csvfile:
+        writer = csv.writer(csvfile)
+        start = cp.cuda.Event()
+        end = cp.cuda.Event()
+
+        start.record()
+        result = func(*args, **kwargs)
+        end.record()
+        end.synchronize()
+
+        result = func(*args, **kwargs)
+        elapsed_time = cp.cuda.get_elapsed_time(start, end) / 1000
+        print(f"{func_name}: {elapsed_time:.6f} s")
+
+        writer.writerow([func_name, dim, elapsed_time])
+
+    return result