新增实验结果

src/lead.egg-info/SOURCES.txt

@@ -1,4 +1,5 @@
 MANIFEST.in
+README.md
 setup.py
 src/lead/__init__.py
 src/lead.egg-info/PKG-INFO
@@ -7,6 +8,9 @@ src/lead.egg-info/dependency_links.txt
 src/lead.egg-info/entry_points.txt
 src/lead.egg-info/requires.txt
 src/lead.egg-info/top_level.txt
+src/lead/problems/bp/problem_config.json
+src/lead/problems/mc/problem_config.json
+src/lead/problems/mc/dataset/__init__.py
 src/lead/problems/nd/problem_config.json
 src/lead/problems/nd/dataset/__init__.py
 src/lead/problems/sort/__init__.py

src/lead/problems/nd/evolution_history/20250408_110938/generation_0.json

@@ -0,0 +1,49 @@
+{
+  "generation": 0,
+  "population": [
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n    \n    U, s, VT = svd(denoised_matrix)\n    \n    alpha = np.mean(s)\n    s_thresholded = np.sign(s) * np.maximum(np.abs(s) - alpha, 0)\n    \n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n    \n    max_value = np.max(denoised_matrix)\n    mean_value = np.mean(denoised_matrix)\n    denoised_adj_binary = (denoised_matrix > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1704,
+      "generation": 1
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha=0.1, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    \n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized)\n    \n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 1
+    },
+    {
+      "code": "import numpy as np\n\ndef denoise_network(noisy_adj):\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj = np.where(denoised_adj > mean_value, 1, 0)\n    return denoised_adj",
+      "fitness": 0.5784,
+      "generation": 0
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\nfrom sklearn.preprocessing import MinMaxScaler\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def recover_network(noisy_matrix, iterations=100, initial_tau=0.1):\n        U, S, Vt = svd(noisy_matrix)\n        denoised_matrix = U @ np.diag(S) @ Vt\n        \n        tau = initial_tau\n        for i in range(iterations):\n            thresholded_singular_values = soft_thresholding(S, tau)\n            denoised_matrix = U @ np.diag(thresholded_singular_values) @ Vt\n            \n            S_diff = np.abs(S - thresholded_singular_values)\n            tau = np.median(S_diff[S_diff > 0]) if np.any(S_diff > 0) else tau\n            \n            U, S, Vt = svd(denoised_matrix)\n        \n        return denoised_matrix\n    \n    scaler = MinMaxScaler()\n    noisy_adj_scaled = scaler.fit_transform(noisy_adj)\n    clean_adj_scaled = recover_network(noisy_adj_scaled)\n    clean_adj = scaler.inverse_transform(clean_adj_scaled)\n    clean_adj_binarized = (clean_adj > 0.5).astype(float)\n\n    return clean_adj_binarized",
+      "fitness": Infinity,
+      "generation": 0
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha=0.1, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    noisy_adj_normalized = noisy_adj / np.max(np.abs(noisy_adj))\n    denoised_adj = learn_denoised_matrix(noisy_adj_normalized)\n    denoised_adj_binary = (denoised_adj > 0.5).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.3452,
+      "generation": 0
+    },
+    {
+      "code": "import numpy as np\n\ndef denoise_network(noisy_adj):\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj = np.where(denoised_adj > mean_value, 1, 0)\n    return denoised_adj",
+      "fitness": 0.5784,
+      "generation": 0
+    },
+    {
+      "code": "import numpy as np\n\ndef denoise_network(noisy_adj):\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj = np.where(denoised_adj > mean_value, 1, 0)\n    return denoised_adj",
+      "fitness": 0.5784,
+      "generation": 0
+    },
+    {
+      "code": "import numpy as np\n\ndef denoise_network(noisy_adj):\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    std_value = np.std(denoised_adj)\n    adaptive_threshold = mean_value + 0.5 * std_value\n    denoised_adj = np.where(denoised_adj > adaptive_threshold, 1, 0)\n    return denoised_adj",
+      "fitness": 0.38,
+      "generation": 0
+    }
+  ],
+  "best_fitness": 0.1576,
+  "best_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha=0.1, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    \n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized)\n    \n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+  "best_ever_fitness": 0.1576,
+  "best_ever_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha=0.1, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    \n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized)\n    \n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary"
+}

src/lead/problems/nd/evolution_history/20250408_110938/generation_1.json

@@ -0,0 +1,49 @@
+{
+  "generation": 1,
+  "population": [
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, iterations=100, tolerance=1e-5):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            tau = np.median(s)\n            s_thresholded = soft_thresholding(s, tau)\n            new_denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n            if np.linalg.norm(new_denoised_matrix - denoised_matrix) < tolerance:\n                break\n            denoised_matrix = new_denoised_matrix\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    \n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized)\n    \n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.3376,
+      "generation": 1
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_matrix = diag_matrix - filtered_laplacian\n    \n    U, s, VT = svd(denoised_matrix)\n\n    q1, q3 = np.percentile(s, [25, 75])\n    iqr = q3 - q1\n    adaptive_threshold = q3 + 1.5 * iqr\n    s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n    \n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 2
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\nfrom sklearn.preprocessing import StandardScaler\n\ndef denoise_network(noisy_adj):\n    scaler = StandardScaler()\n    noisy_adj_scaled = scaler.fit_transform(noisy_adj)\n\n    diag_matrix = np.diag(np.sum(noisy_adj_scaled, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj_scaled\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n    \n    U, s, VT = svd(denoised_matrix)\n    \n    alpha = np.mean(s)\n    s_thresholded = np.sign(s) * np.maximum(np.abs(s) - alpha, 0)\n    \n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    median_value = np.median(denoised_matrix)\n    std_dev = np.std(denoised_matrix)\n    adaptive_threshold = median_value + std_dev\n\n    denoised_adj_binary = (denoised_matrix > adaptive_threshold).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": Infinity,
+      "generation": 1
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n    \n    U, s, VT = svd(denoised_matrix)\n    \n    alpha = np.mean(s)\n    s_thresholded = np.sign(s) * np.maximum(np.abs(s) - alpha, 0)\n    \n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n    \n    max_value = np.max(denoised_matrix)\n    mean_value = np.mean(denoised_matrix)\n    denoised_adj_binary = (denoised_matrix > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1704,
+      "generation": 1
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n    \n    U, s, VT = svd(denoised_matrix)\n    \n    alpha = np.mean(s)\n    s_thresholded = np.sign(s) * np.maximum(np.abs(s) - alpha, 0)\n    \n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n    \n    max_value = np.max(denoised_matrix)\n    mean_value = np.mean(denoised_matrix)\n    denoised_adj_binary = (denoised_matrix > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1704,
+      "generation": 1
+    },
+    {
+      "code": "import numpy as np\n\ndef denoise_network(noisy_adj):\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    std_value = np.std(denoised_adj)\n    adaptive_threshold = mean_value + 0.5 * std_value\n    denoised_adj = np.where(denoised_adj > adaptive_threshold, 1, 0)\n    return denoised_adj",
+      "fitness": 0.38,
+      "generation": 0
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    \n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_alpha)\n    \n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 1
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n    \n    U, s, VT = svd(denoised_matrix)\n    \n    alpha = np.mean(s)\n    s_thresholded = np.sign(s) * np.maximum(np.abs(s) - alpha, 0)\n    \n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n    \n    max_value = np.max(denoised_matrix)\n    mean_value = np.mean(denoised_matrix)\n    denoised_adj_binary = (denoised_matrix > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1704,
+      "generation": 1
+    }
+  ],
+  "best_fitness": 0.1576,
+  "best_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_matrix = diag_matrix - filtered_laplacian\n    \n    U, s, VT = svd(denoised_matrix)\n\n    q1, q3 = np.percentile(s, [25, 75])\n    iqr = q3 - q1\n    adaptive_threshold = q3 + 1.5 * iqr\n    s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n    \n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+  "best_ever_fitness": 0.1576,
+  "best_ever_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha=0.1, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    \n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized)\n    \n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary"
+}

src/lead/problems/nd/evolution_history/20250408_110938/generation_2.json

@@ -0,0 +1,49 @@
+{
+  "generation": 2,
+  "population": [
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    \n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_matrix = diag_matrix - filtered_laplacian\n    \n    U, s, VT = svd(denoised_matrix)\n\n    q1, q3 = np.percentile(s, [25, 75])\n    iqr = q3 - q1\n    adaptive_threshold = q3 + threshold_factor * iqr\n    s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n    \n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 2
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix, full_matrices=False)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_alpha)\n\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 2
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    \n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_alpha)\n    \n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 1
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n    U, s, VT = svd(denoised_matrix)\n    alpha = np.mean(s)\n    s_thresholded = np.sign(s) * np.maximum(np.abs(s) - alpha, 0)\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n    mean_value = np.mean(denoised_matrix)\n    std_dev = np.std(denoised_matrix)\n    threshold = mean_value + 0.5 * std_dev\n    denoised_adj_binary = (denoised_matrix > threshold).astype(float)\n    denoised_adj_binary[denoised_adj_binary < 0.5] = 0\n    return denoised_adj_binary",
+      "fitness": 0.1784,
+      "generation": 1
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\nfrom scipy.stats import zscore\nfrom sklearn.neighbors import LocalOutlierFactor\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_matrix = diag_matrix - filtered_laplacian\n    \n    U, s, VT = svd(denoised_matrix)\n\n    z_scores = zscore(s)\n    adaptive_threshold = np.mean(z_scores) + 1.5 * np.std(z_scores)\n    s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n    \n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    model = LocalOutlierFactor(n_neighbors=5)\n    outlier_pred = model.fit_predict(denoised_adj_normalized)\n    \n    denoised_adj_binary = (outlier_pred == 1).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": Infinity,
+      "generation": 2
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n    \n    U, s, VT = svd(denoised_matrix)\n    \n    alpha = np.mean(s)\n    s_thresholded = np.sign(s) * np.maximum(np.abs(s) - alpha, 0)\n    \n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n    \n    max_value = np.max(denoised_matrix)\n    mean_value = np.mean(denoised_matrix)\n    denoised_adj_binary = (denoised_matrix > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1704,
+      "generation": 1
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n    \n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_matrix = diag_matrix - filtered_laplacian\n    \n    U, s, VT = svd(denoised_matrix)\n\n    energy = np.sum(s**2)\n    threshold_factor = 0.1\n    adaptive_threshold = threshold_factor * energy / len(s)\n    \n    s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n    \n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 2
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_matrix = diag_matrix - filtered_laplacian\n    \n    U, s, VT = svd(denoised_matrix)\n\n    q1, q3 = np.percentile(s, [25, 75])\n    iqr = q3 - q1\n    adaptive_threshold = q3 + 1.5 * iqr\n    s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n    \n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 2
+    }
+  ],
+  "best_fitness": 0.1576,
+  "best_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    \n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_matrix = diag_matrix - filtered_laplacian\n    \n    U, s, VT = svd(denoised_matrix)\n\n    q1, q3 = np.percentile(s, [25, 75])\n    iqr = q3 - q1\n    adaptive_threshold = q3 + threshold_factor * iqr\n    s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n    \n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+  "best_ever_fitness": 0.1576,
+  "best_ever_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha=0.1, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    \n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized)\n    \n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary"
+}

src/lead/problems/nd/evolution_history/20250408_110938/generation_3.json

@@ -0,0 +1,49 @@
+{
+  "generation": 3,
+  "population": [
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    \n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    explained_variance = eigvals / np.sum(eigvals)\n    cumulative_variance = np.cumsum(explained_variance)\n    \n    k = np.argmax(cumulative_variance >= 0.9) + 1\n    \n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_matrix = diag_matrix - filtered_laplacian\n    \n    U, s, VT = svd(denoised_matrix)\n\n    q1, q3 = np.percentile(s, [25, 75])\n    iqr = q3 - q1\n    adaptive_threshold = q3 + threshold_factor * iqr\n    s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n    \n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1592,
+      "generation": 2
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=0.1):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix)\n\n    q1, q3 = np.percentile(s, [25, 75])\n    iqr = q3 - q1\n    adaptive_threshold = q3 + threshold_factor * iqr\n    s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.16,
+      "generation": 3
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    \n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_alpha)\n    \n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 1
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(singular_values, alpha):\n        adaptive_threshold = alpha * np.mean(singular_values)\n        return np.sign(singular_values) * np.maximum(np.abs(singular_values) - adaptive_threshold, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        learning_rate = 0.1\n\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix, full_matrices=False)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n            \n            current_loss = np.linalg.norm(noisy_matrix - denoised_matrix)\n            if current_loss < 1e-5:\n                break\n            learning_rate *= 0.95\n            \n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_alpha)\n\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.248,
+      "generation": 2
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, base_alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for i in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            adaptive_alpha = base_alpha * np.mean(s) / (1 + i)\n            s_thresholded = soft_thresholding(s, adaptive_alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n\n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    \n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_alpha)\n\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.3576,
+      "generation": 1
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100, tolerance=1e-5):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix, full_matrices=False)\n            s_thresholded = soft_thresholding(s, alpha)\n            new_denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n            alpha = np.mean(np.abs(new_denoised_matrix)) * 0.1\n            if np.linalg.norm(new_denoised_matrix - denoised_matrix) < tolerance:\n                break\n            denoised_matrix = new_denoised_matrix\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_alpha)\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n    return denoised_adj_binary",
+      "fitness": 0.3576,
+      "generation": 3
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix, full_matrices=False)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n\n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_alpha)\n\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 3
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\nfrom sklearn.decomposition import NMF\n\ndef denoise_network(noisy_adj, threshold_factor=1.5):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    \n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_matrix = diag_matrix - filtered_laplacian\n    \n    model = NMF(n_components=k, init='random', random_state=0)\n    W = model.fit_transform(denoised_matrix)\n    H = model.components_\n    denoised_matrix = np.dot(W, H)\n    \n    U, s, VT = svd(denoised_matrix)\n\n    q1, q3 = np.percentile(s, [25, 75])\n    iqr = q3 - q1\n    adaptive_threshold = q3 + threshold_factor * iqr\n    s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n    \n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": Infinity,
+      "generation": 2
+    }
+  ],
+  "best_fitness": 0.1576,
+  "best_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    \n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_alpha)\n    \n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+  "best_ever_fitness": 0.1576,
+  "best_ever_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha=0.1, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    \n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized)\n    \n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary"
+}

src/lead/problems/nd/evolution_history/20250408_110938/generation_4.json

@@ -0,0 +1,49 @@
+{
+  "generation": 4,
+  "population": [
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\nfrom skimage.restoration import denoise_bilateral\n\ndef denoise_network(noisy_adj, threshold_factor=1.5):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    \n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    explained_variance = eigvals / np.sum(eigvals)\n    cumulative_variance = np.cumsum(explained_variance)\n    \n    k = np.argmax(cumulative_variance >= 0.9) + 1\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n    \n    U, s, VT = svd(denoised_matrix)\n\n    q1, q3 = np.percentile(s, [25, 75])\n    iqr = q3 - q1\n    adaptive_threshold = q3 + threshold_factor * iqr\n    s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n    \n    denoised_matrix_bilateral = denoise_bilateral(denoised_matrix, sigma_color=0.1, sigma_spatial=15, multichannel=False)\n\n    denoised_adj_normalized = denoised_matrix_bilateral / np.max(np.abs(denoised_matrix_bilateral))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": Infinity,
+      "generation": 2
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\nfrom sklearn.decomposition import NMF\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    \n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    \n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_alpha)\n    \n    model = NMF(n_components=5, init='random', random_state=42)\n    denoised_adj_nmf = model.fit_transform(denoised_adj)\n    denoised_adj = np.dot(denoised_adj_nmf, model.components_)\n    \n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": Infinity,
+      "generation": 1
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=0.1):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix)\n\n    q1, q3 = np.percentile(s, [25, 75])\n    iqr = q3 - q1\n    adaptive_threshold = q3 + threshold_factor * iqr\n    s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.16,
+      "generation": 2
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=0.1):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n\n    weights = eigvals[top_k_indices] / np.sum(eigvals[top_k_indices])\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(weights) @ eigvecs[:, top_k_indices].T\n\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix)\n\n    q1, q3 = np.percentile(s, [25, 75])\n    iqr = q3 - q1\n    adaptive_threshold = q3 + threshold_factor * iqr\n    s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.16,
+      "generation": 3
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=0.1):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix)\n\n    q1, q3 = np.percentile(s, [25, 75])\n    iqr = q3 - q1\n    adaptive_threshold = q3 + threshold_factor * iqr\n    s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.16,
+      "generation": 3
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    explained_variance = eigvals / np.sum(eigvals)\n    cumulative_variance = np.cumsum(explained_variance)\n    k = np.argmax(cumulative_variance >= 0.9) + 1\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    adaptive_threshold = adaptive_alpha * threshold_factor\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_threshold)\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 3
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=0.1):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix)\n\n    q1, q3 = np.percentile(s, [25, 75])\n    iqr = q3 - q1\n    adaptive_threshold = q3 + threshold_factor * iqr\n    s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.16,
+      "generation": 3
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=0.1):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n\n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * threshold_factor\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_alpha)\n\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    \n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 4
+    }
+  ],
+  "best_fitness": 0.1576,
+  "best_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    explained_variance = eigvals / np.sum(eigvals)\n    cumulative_variance = np.cumsum(explained_variance)\n    k = np.argmax(cumulative_variance >= 0.9) + 1\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    adaptive_threshold = adaptive_alpha * threshold_factor\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_threshold)\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+  "best_ever_fitness": 0.1576,
+  "best_ever_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha=0.1, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    k = min(5, len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    \n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    \n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized)\n    \n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary"
+}

src/lead/problems/nd/evolution_history/20250408_110938/generation_5.json

@@ -0,0 +1,49 @@
+{
+  "generation": 5,
+  "population": [
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=0.1):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix)\n\n    q1, q3 = np.percentile(s, [25, 75])\n    iqr = q3 - q1\n    adaptive_threshold = q3 + threshold_factor * iqr\n    s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.16,
+      "generation": 5
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix, full_matrices=False)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    explained_variance = eigvals / np.sum(eigvals)\n    cumulative_variance = np.cumsum(explained_variance)\n    k = np.argmax(cumulative_variance >= 0.9) + 1\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    adaptive_threshold = adaptive_alpha * threshold_factor\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_threshold)\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 4
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=0.1):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    explained_variance = eigvals / np.sum(eigvals)\n    cumulative_variance = np.cumsum(explained_variance)\n    k = np.argmax(cumulative_variance >= 0.9) + 1\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n\n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    adaptive_threshold = adaptive_alpha * threshold_factor\n    \n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_threshold)\n\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.5576,
+      "generation": 3
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    explained_variance = eigvals / np.sum(eigvals)\n    cumulative_variance = np.cumsum(explained_variance)\n    k = np.argmax(cumulative_variance >= 0.9) + 1\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    adaptive_threshold = adaptive_alpha * threshold_factor\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_threshold)\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 3
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=0.1, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.156,
+      "generation": 3
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n\n    mean_value = np.mean(denoised_adj)\n    std_value = np.std(denoised_adj)\n    adaptive_alpha = (mean_value + threshold_factor * std_value)\n\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_alpha)\n\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 4
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=0.1):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    \n    explained_variance = eigvals / np.sum(eigvals)\n    cumulative_variance = np.cumsum(explained_variance)\n    \n    k_candidates = np.arange(1, len(eigvals) + 1)\n    deltas = np.diff(cumulative_variance)\n    elbow_index = np.argmax(deltas < np.mean(deltas) * 0.5)  \n    k = elbow_index if elbow_index > 0 else len(eigvals)\n    \n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n\n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * threshold_factor\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_alpha)\n\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    \n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.4604,
+      "generation": 5
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=0.1):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix)\n\n    q1, q3 = np.percentile(s, [25, 75])\n    iqr = q3 - q1\n    adaptive_threshold = q3 + threshold_factor * iqr\n    s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.16,
+      "generation": 2
+    }
+  ],
+  "best_fitness": 0.156,
+  "best_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=0.1, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+  "best_ever_fitness": 0.156,
+  "best_ever_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=0.1, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary"
+}

src/lead/problems/nd/evolution_history/20250408_110938/generation_6.json

@@ -0,0 +1,49 @@
+{
+  "generation": 6,
+  "population": [
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau, momentum=0.9, previous=None):\n        if previous is None:\n            previous = np.zeros_like(matrix)\n        thresholded = np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n        return momentum * previous + (1 - momentum) * thresholded\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        previous_s = s.copy()\n        s_thresholded = soft_thresholding(s, adaptive_threshold, previous=previous_s) - lambda_reg * s\n    else:\n        previous_s = s.copy()\n        s_thresholded = soft_thresholding(s, adaptive_threshold, previous=previous_s)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1768,
+      "generation": 4
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    explained_variance = eigvals / np.sum(eigvals)\n    cumulative_variance = np.cumsum(explained_variance)\n    k = np.argmax(cumulative_variance >= 0.9) + 1\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    adaptive_threshold = adaptive_alpha * threshold_factor\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_threshold)\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 3
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1544,
+      "generation": 5
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    explained_variance = eigvals / np.sum(eigvals)\n    cumulative_variance = np.cumsum(explained_variance)\n    k = np.argmax(cumulative_variance >= 0.9) + 1\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    adaptive_threshold = adaptive_alpha * threshold_factor\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_threshold)\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 3
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=0.1, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.156,
+      "generation": 3
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, max_iterations=100, tol=1e-5):\n        denoised_matrix = noisy_matrix.copy()\n        prev_matrix = denoised_matrix\n        for _ in range(max_iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n            if np.linalg.norm(denoised_matrix - prev_matrix) < tol:\n                break\n            prev_matrix = denoised_matrix\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    explained_variance = eigvals / np.sum(eigvals)\n    cumulative_variance = np.cumsum(explained_variance)\n    k = np.argmax(cumulative_variance >= 0.9) + 1\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    adaptive_threshold = adaptive_alpha * threshold_factor\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_threshold)\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 3
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=0.1, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.156,
+      "generation": 3
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    explained_variance = eigvals / np.sum(eigvals)\n    cumulative_variance = np.cumsum(explained_variance)\n    k = np.argmax(cumulative_variance >= 0.9) + 1\n    top_k_indices = np.argsort(eigvals)[:k]\n\n    weights = np.sum(noisy_adj, axis=0) + 1e-10\n    weighted_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices] * weights[top_k_indices]) @ eigvecs[:, top_k_indices].T\n\n    filtered_laplacian = weighted_laplacian\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n\n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    adaptive_threshold = adaptive_alpha * threshold_factor\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_threshold)\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    \n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 3
+    }
+  ],
+  "best_fitness": 0.1544,
+  "best_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+  "best_ever_fitness": 0.1544,
+  "best_ever_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary"
+}

src/lead/problems/nd/evolution_history/20250408_110938/generation_7.json

@@ -0,0 +1,49 @@
+{
+  "generation": 7,
+  "population": [
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1544,
+      "generation": 6
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\nfrom skimage.filters import threshold_otsu\n\ndef denoise_network(noisy_adj, threshold_factor=0.1, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    otsu_threshold = threshold_otsu(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > otsu_threshold).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": Infinity,
+      "generation": 3
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1544,
+      "generation": 4
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\nfrom sklearn.decomposition import NMF\n\ndef denoise_network(noisy_adj, threshold_factor=1.5):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, iterations=100):\n        denoised_matrix = noisy_matrix.copy()\n        for _ in range(iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n        return denoised_matrix\n    \n    def adaptive_thresholding(singular_values):\n        mean_val = np.mean(singular_values)\n        std_dev = np.std(singular_values)\n        return mean_val + std_dev\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    explained_variance = eigvals / np.sum(eigvals)\n    cumulative_variance = np.cumsum(explained_variance)\n    k = np.argmax(cumulative_variance >= 0.9) + 1\n    top_k_indices = np.argsort(eigvals)[:k]\n\n    model = NMF(n_components=k, init='random', random_state=0)\n    W = model.fit_transform(noisy_adj)\n    H = model.components_\n    nmf_matrix = np.dot(W, H)\n\n    weights = np.sum(noisy_adj, axis=0) + 1e-10\n    weighted_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices] * weights[top_k_indices]) @ eigvecs[:, top_k_indices].T\n\n    filtered_laplacian = weighted_laplacian\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n\n    adaptive_alpha = adaptive_thresholding(np.abs(denoised_adj).flatten())\n    adaptive_threshold = adaptive_alpha * threshold_factor\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_threshold)\n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    \n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": Infinity,
+      "generation": 3
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1544,
+      "generation": 5
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    def learn_denoised_matrix(noisy_matrix, alpha, max_iterations=100, tol=1e-5):\n        denoised_matrix = noisy_matrix.copy()\n        prev_matrix = denoised_matrix\n        for _ in range(max_iterations):\n            U, s, VT = svd(denoised_matrix)\n            s_thresholded = soft_thresholding(s, alpha)\n            denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n            if np.linalg.norm(denoised_matrix - prev_matrix) < tol:\n                break\n            prev_matrix = denoised_matrix\n        return denoised_matrix\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n    explained_variance = eigvals / np.sum(eigvals)\n    cumulative_variance = np.cumsum(explained_variance)\n    k = np.argmax(cumulative_variance >= 0.9) + 1\n    top_k_indices = np.argsort(eigvals)[:k]\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_adj = diag_matrix - filtered_laplacian\n    denoised_adj = (denoised_adj + denoised_adj.T) / 2\n\n    noise_estimate = np.mean(np.abs(denoised_adj - noisy_adj))\n    adaptive_alpha = np.mean(np.abs(denoised_adj)) * 0.1\n    adaptive_threshold = adaptive_alpha * max(threshold_factor, noise_estimate)\n\n    denoised_adj_normalized = denoised_adj / np.max(np.abs(denoised_adj))\n    denoised_adj = learn_denoised_matrix(denoised_adj_normalized, adaptive_threshold)\n    \n    denoised_adj = 1 / (1 + np.exp(-denoised_adj))\n    mean_value = np.mean(denoised_adj)\n    denoised_adj_binary = np.where(denoised_adj > mean_value, 1, 0)\n\n    return denoised_adj_binary",
+      "fitness": 0.1576,
+      "generation": 4
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=0.1, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    \n    adaptive_threshold = mean_s + threshold_factor * (np.percentile(s, 75) - np.percentile(s, 25))\n\n    lambda_reg = 0.1 * (np.std(s) / (np.mean(s) + 1e-10))\n\n    if use_regularization:\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n    \n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1656,
+      "generation": 3
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1544,
+      "generation": 5
+    }
+  ],
+  "best_fitness": 0.1544,
+  "best_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+  "best_ever_fitness": 0.1544,
+  "best_ever_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary"
+}

src/lead/problems/nd/evolution_history/20250408_110938/generation_8.json

@@ -0,0 +1,49 @@
+{
+  "generation": 8,
+  "population": [
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1544,
+      "generation": 5
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True, return_stats=False):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    q1 = np.percentile(s, 25)\n    q3 = np.percentile(s, 75)\n    iqr = q3 - q1\n    adaptive_threshold = q3 + threshold_factor * iqr\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    min_val = np.min(denoised_matrix)\n    max_val = np.max(denoised_matrix)\n    denoised_adj_normalized = (denoised_matrix - min_val) / (max_val - min_val)\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    if return_stats:\n        return denoised_adj_binary, {'mean_s': np.mean(s), 'std_s': np.std(s), 'adaptive_threshold': adaptive_threshold}\n    \n    return denoised_adj_binary",
+      "fitness": 0.1544,
+      "generation": 5
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\nfrom sklearn.cluster import KMeans\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    kmeans = KMeans(n_clusters=2)\n    clustered_labels = kmeans.fit_predict(eigvals.reshape(-1, 1))\n\n    if np.sum(clustered_labels == 0) > 0:\n        top_k_indices = np.where(clustered_labels == 0)[0]\n    else:\n        top_k_indices = np.argsort(eigvals)[:min(len(eigvals) // 10, len(eigvals) - 1)]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / (np.linalg.norm(denoised_matrix, ord=1) + 1e-10)\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": Infinity,
+      "generation": 6
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1544,
+      "generation": 6
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = np.percentile(eigvals, 90)\n    top_k_indices = np.where(eigvals <= k)[0]\n\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    median_s = np.median(s)\n    percentile_threshold = np.percentile(s, 70)\n    adaptive_threshold = median_s + threshold_factor * (percentile_threshold - median_s)\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    small_value_threshold = 0.01\n    s_thresholded[s_thresholded < small_value_threshold] = 0\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1592,
+      "generation": 6
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1544,
+      "generation": 7
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1544,
+      "generation": 5
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1544,
+      "generation": 5
+    }
+  ],
+  "best_fitness": 0.1544,
+  "best_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+  "best_ever_fitness": 0.1544,
+  "best_ever_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary"
+}

src/lead/problems/nd/evolution_history/20250408_110938/generation_9.json

@@ -0,0 +1,49 @@
+{
+  "generation": 9,
+  "population": [
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    sparsity_factor = np.sum(s > adaptive_threshold) / len(s)\n    adaptive_threshold *= (1 + sparsity_factor)\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1544,
+      "generation": 7
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\nfrom sklearn.model_selection import train_test_split\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True, return_stats=False):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    q1 = np.percentile(s, 25)\n    q3 = np.percentile(s, 75)\n    iqr = q3 - q1\n    adaptive_threshold = q3 + threshold_factor * iqr\n\n    if use_regularization:\n        s_train, s_val = train_test_split(s, test_size=0.2, random_state=42)\n        lambda_values = np.logspace(-3, 1, 5)\n        best_lambda = lambda_values[0]\n        best_score = float('inf')\n\n        for lambda_reg in lambda_values:\n            s_thresholded = soft_thresholding(s_train, adaptive_threshold) - lambda_reg * s_train\n            reconstructed_val = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n            score = np.mean((reconstructed_val - noisy_adj) ** 2)\n            if score < best_score:\n                best_score = score\n                best_lambda = lambda_reg\n\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - best_lambda * s\n\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    min_val = np.min(denoised_matrix)\n    max_val = np.max(denoised_matrix)\n    denoised_adj_normalized = (denoised_matrix - min_val) / (max_val - min_val)\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    if return_stats:\n        return denoised_adj_binary, {'mean_s': np.mean(s), 'std_s': np.std(s), 'adaptive_threshold': adaptive_threshold, 'best_lambda': best_lambda}\n    \n    return denoised_adj_binary",
+      "fitness": Infinity,
+      "generation": 6
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1544,
+      "generation": 6
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1544,
+      "generation": 6
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1544,
+      "generation": 7
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True, custom_lambda=0.1):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    range_eigvals = eigvals[top_k_indices[-1]] - eigvals[top_k_indices[0]]\n    adaptive_threshold += range_eigvals * 0.1\n\n    if use_regularization:\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - custom_lambda * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1544,
+      "generation": 5
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    eigval_diff_sq = np.diff(eigvals, 2)**2\n    top_k_indices = np.argsort(eigval_diff_sq)[-min(max(1, len(eigvals) // 10), len(eigvals) - 1):]\n\n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.1688,
+      "generation": 5
+    },
+    {
+      "code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n    \n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    eigval_diff = np.diff(eigvals)\n    change_threshold = np.mean(eigval_diff) * 0.5\n    k = np.sum(eigval_diff > change_threshold) + 1\n    k = min(k, len(eigvals) - 1)\n\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+      "fitness": 0.156,
+      "generation": 5
+    }
+  ],
+  "best_fitness": 0.1544,
+  "best_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    sparsity_factor = np.sum(s > adaptive_threshold) / len(s)\n    adaptive_threshold *= (1 + sparsity_factor)\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary",
+  "best_ever_fitness": 0.1544,
+  "best_ever_code": "import numpy as np\nfrom scipy.linalg import svd\n\ndef denoise_network(noisy_adj, threshold_factor=1.5, use_regularization=True):\n    def soft_thresholding(matrix, tau):\n        return np.sign(matrix) * np.maximum(np.abs(matrix) - tau, 0)\n\n    diag_matrix = np.diag(np.sum(noisy_adj, axis=1))\n    laplacian_matrix = diag_matrix - noisy_adj\n\n    eigvals, eigvecs = np.linalg.eigh(laplacian_matrix)\n\n    k = min(max(1, len(eigvals) // 10), len(eigvals) - 1)\n    top_k_indices = np.argsort(eigvals)[:k]\n    \n    filtered_laplacian = eigvecs[:, top_k_indices] @ np.diag(eigvals[top_k_indices]) @ eigvecs[:, top_k_indices].T\n    denoised_matrix = diag_matrix - filtered_laplacian\n\n    U, s, VT = svd(denoised_matrix, full_matrices=False)\n\n    mean_s = np.mean(s)\n    std_s = np.std(s)\n    adaptive_threshold = mean_s + threshold_factor * std_s\n\n    if use_regularization:\n        lambda_reg = 0.1\n        s_thresholded = soft_thresholding(s, adaptive_threshold) - lambda_reg * s\n    else:\n        s_thresholded = soft_thresholding(s, adaptive_threshold)\n\n    denoised_matrix = np.dot(U, np.dot(np.diag(s_thresholded), VT))\n\n    denoised_adj_normalized = denoised_matrix / np.max(np.abs(denoised_matrix))\n\n    mean_value = np.mean(denoised_adj_normalized)\n    max_value = np.max(denoised_adj_normalized)\n    denoised_adj_binary = (denoised_adj_normalized > (mean_value + max_value) / 2).astype(float)\n\n    return denoised_adj_binary"
+}