Use (unsafe) ruff fixes

Author: ninamiolane

.github/workflows/docs.yml

@@ -41,8 +41,7 @@ jobs:
           branch: main
           folder: docs/_build
           token: ${{ secrets.DOCUMENTATION_KEY }}
-          repository-name: geometric-intelligence/geometric-intelligence.github.io
-          target-folder: neurometry
+          repository-name: geometric-intelligence/neurometry.github.io
           clean: true
   numpydoc-validation:
     runs-on: ${{matrix.os}}

docs/conf.py

@@ -1,6 +1,5 @@
 """Sphinx configuration file."""
 
-import neurometry
 
 project = "neurometry"
 copyright = "2023, Geometric Intelligence Lab."

neurometry/curvature/datasets/experimental.py

@@ -145,7 +145,7 @@ def load_neural_activity(expt_id=34, vel_threshold=5, timestep_microsec=int(1e5)
             qw = _average_variable(qw, tracked_times, sampling_times)
             success = _average_variable(success, tracked_times, sampling_times)
 
-            radius2 = [xx**2 + yy**2 for xx, yy in zip(x, y)]
+            radius2 = [xx**2 + yy**2 for xx, yy in zip(x, y, strict=False)]
             angles_tracked = np.arctan2(y, x)
 
             quat_head = np.stack([qx, qy, qz, qw], axis=1)  # scalar-last format
@@ -350,9 +350,8 @@ def _average_variable(variable_to_average, recorded_times, sampling_times):
             variable_averaged.append(averaged)
             cum_count += int(count)
 
-    variable_averaged = np.array(variable_averaged)
+    return np.array(variable_averaged)
 
-    return variable_averaged
 
 
 def get_place_field_centers(neural_activity, task_variable):

neurometry/curvature/datasets/gridcells.py

@@ -2,7 +2,6 @@
 
 import os
 
-import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 
@@ -65,9 +64,8 @@ def create_reference_lattice(lx, ly, arena_dims, lattice_type="hexagonal"):
         X = lx * N_x
     Y = ly * N_y
 
-    ref_lattice = np.hstack((np.reshape(X, (-1, 1)), np.reshape(Y, (-1, 1))))
+    return np.hstack((np.reshape(X, (-1, 1)), np.reshape(Y, (-1, 1))))
 
-    return ref_lattice
 
 
 def generate_all_grids(
@@ -79,7 +77,7 @@ def generate_all_grids(
     warp=None,
     lattice_type="hexagonal",
 ):
-    """Create lattices for all grid cells within a module, with varying phase & orientation.
+    r"""Create lattices for all grid cells within a module, with varying phase & orientation.
 
     Parameters
     ----------
@@ -105,9 +103,9 @@ def generate_all_grids(
         scale=grid_scale, lattice_type=lattice_type, dimensions=arena_dims
     )
 
-    grids = np.zeros((n_cells,) + np.shape(ref_lattice))
+    grids = np.zeros((n_cells, *np.shape(ref_lattice)))
 
-    grids_warped = np.zeros((n_cells,) + np.shape(ref_lattice))
+    grids_warped = np.zeros((n_cells, *np.shape(ref_lattice)))
 
     arena_dims = np.array(arena_dims)
 
@@ -122,7 +120,7 @@ def generate_all_grids(
         lattice_i = np.matmul(rot_i, ref_lattice.T).T + phase_i
         # lattice_i = np.where(abs(lattice_i) < arena_dims / 2, lattice_i, None)
 
-        if warp == None:
+        if warp is None:
             pass
         else:
             for j, point in enumerate(lattice_i):

neurometry/curvature/datasets/structures.py

@@ -23,6 +23,5 @@ def get_lattice(scale, lattice_type, dimensions):
         X = lx * N_x
         Y = ly * N_y
 
-    lattice = np.hstack((np.reshape(X, (-1, 1)), np.reshape(Y, (-1, 1))))
+    return np.hstack((np.reshape(X, (-1, 1)), np.reshape(Y, (-1, 1))))
 
-    return lattice

neurometry/curvature/datasets/synthetic.py

@@ -8,7 +8,6 @@
 import numpy as np
 import pandas as pd
 import torch
-import torch.nn.functional as F
 from geomstats.geometry.special_orthogonal import SpecialOrthogonal  # NOQA
 from torch.distributions.multivariate_normal import MultivariateNormal
 

neurometry/curvature/datasets/utils.py

@@ -1,14 +1,10 @@
 """Utils to import data from matlab."""
 
-import curvature.datasets.experimental
-import curvature.datasets.gridcells
-import curvature.datasets.synthetic
 import mat73
 import numpy as np
 import scipy.io
 import torch
 from scipy.signal import savgol_filter
-from sklearn.decomposition import PCA
 
 
 def load(config):
@@ -40,7 +36,7 @@ def load(config):
         labels = labels[labels["velocities"] > 5]
         dataset = np.log(dataset.astype(np.float32) + 1)
 
-        if config.smooth == True:
+        if config.smooth is True:
             dataset_smooth = np.zeros_like(dataset)
             for _ in range(dataset.shape[1]):
                 dataset_smooth[:, _] = savgol_filter(
@@ -160,33 +156,26 @@ def load(config):
     test_labels = labels.iloc[test_indices]
 
     # The angles are positional angles in the lab frame
-    if config.dataset_name in ("experimental", "s1_synthetic"):
+    if config.dataset_name in ("experimental", "s1_synthetic") or config.dataset_name in ("three_place_cells_synthetic"):
         train = []
-        for d, l in zip(train_dataset, train_labels["angles"]):
+        for d, l in zip(train_dataset, train_labels["angles"], strict=False):
             train.append([d, float(l)])
         test = []
-        for d, l in zip(test_dataset, test_labels["angles"]):
-            test.append([d, float(l)])
-    elif config.dataset_name in ("three_place_cells_synthetic"):
-        train = []
-        for d, l in zip(train_dataset, train_labels["angles"]):
-            train.append([d, float(l)])
-        test = []
-        for d, l in zip(test_dataset, test_labels["angles"]):
+        for d, l in zip(test_dataset, test_labels["angles"], strict=False):
             test.append([d, float(l)])
     elif config.dataset_name in ("s2_synthetic", "t2_synthetic"):
         train = []
-        for d, t, p in zip(train_dataset, train_labels["thetas"], train_labels["phis"]):
+        for d, t, p in zip(train_dataset, train_labels["thetas"], train_labels["phis"], strict=False):
             train.append([d, torch.tensor([float(t), float(p)])])
         test = []
-        for d, t, p in zip(test_dataset, test_labels["thetas"], test_labels["phis"]):
+        for d, t, p in zip(test_dataset, test_labels["thetas"], test_labels["phis"], strict=False):
             test.append([d, torch.tensor([float(t), float(p)])])
     elif config.dataset_name == "grid_cells":
         train = []
-        for d, l in zip(train_dataset, train_labels["no_labels"]):
+        for d, l in zip(train_dataset, train_labels["no_labels"], strict=False):
             train.append([d, float(l)])
         test = []
-        for d, l in zip(test_dataset, test_labels["no_labels"]):
+        for d, l in zip(test_dataset, test_labels["no_labels"], strict=False):
             test.append([d, float(l)])
 
     train_loader = torch.utils.data.DataLoader(train, batch_size=config.batch_size)

neurometry/curvature/default_config.py

@@ -2,11 +2,9 @@
 
 import logging
 import os
-from datetime import datetime
 
 import numpy as np
 import torch
-from ray.tune.search.hyperopt import HyperOptSearch
 
 os.environ["GEOMSTATS_BACKEND"] = "pytorch"
 

neurometry/curvature/evaluate.py

@@ -2,6 +2,7 @@
 
 os.environ["GEOMSTATS_BACKEND"] = "pytorch"
 import geomstats.backend as gs
+
 #import gph
 import numpy as np
 import torch
@@ -10,7 +11,6 @@
     get_s2_synthetic_immersion,
     get_t2_synthetic_immersion,
 )
-from decorators import timer
 from geomstats.geometry.pullback_metric import PullbackMetric
 from geomstats.geometry.special_orthogonal import SpecialOrthogonal  # NOQA
 
@@ -51,9 +51,8 @@ def immersion(angle):
             )
 
         z = z.to(config.device)
-        x_mu = model.decode(z)
+        return model.decode(z)
 
-        return x_mu
 
     return immersion
 
@@ -112,7 +111,7 @@ def _compute_curvature(z_grid, immersion, dim, embedding_dim):
     neural_metric = PullbackMetric(
         dim=dim, embedding_dim=embedding_dim, immersion=immersion
     )
-    z0 = torch.unsqueeze(z_grid[0], dim=0)
+    torch.unsqueeze(z_grid[0], dim=0)
     if dim == 1:
         curv = gs.zeros(len(z_grid), embedding_dim)
         geodesic_dist = gs.zeros(len(z_grid))
@@ -214,8 +213,7 @@ def _integrate_s2(thetas, phis, h):
         sum_phis[t] = torch.trapz(
             y=h[len(phis) * t : len(phis) * (t + 1)], x=phis
         ) * np.sin(theta)
-    integral = torch.trapz(y=sum_phis, x=thetas)
-    return integral
+    return torch.trapz(y=sum_phis, x=thetas)
 
 
 def _compute_curvature_error_s2(thetas, phis, curv_norms_learned, curv_norms_true):
@@ -240,23 +238,17 @@ def _compute_curvature_error_t2(thetas, phis, curv_norms_learned, curv_norms_tru
 def compute_curvature_error(
     z_grid, curv_norms_learned, curv_norms_true, config
 ):  # Calculate method error
-    start_time = time.time()
+    time.time()
 
     if config.dataset_name == "s1_synthetic":
         thetas = z_grid
         error = _compute_curvature_error_s1(thetas, curv_norms_learned, curv_norms_true)
-    elif config.dataset_name == "s2_synthetic":
-        thetas = z_grid[:, 0]
-        phis = z_grid[:, 1]
-        error = _compute_curvature_error_s2(
-            thetas, phis, curv_norms_learned, curv_norms_true
-        )
-    elif config.dataset_name == "t2_synthetic":
+    elif config.dataset_name == "s2_synthetic" or config.dataset_name == "t2_synthetic":
         thetas = z_grid[:, 0]
         phis = z_grid[:, 1]
         error = _compute_curvature_error_s2(
             thetas, phis, curv_norms_learned, curv_norms_true
         )
-    end_time = time.time()
+    time.time()
     # print("Computation time: " + "%.3f" % (end_time - start_time) + " seconds.")
     return error

neurometry/curvature/grid-cells-curvature/make_animation.py

@@ -1,15 +1,15 @@
-import numpy as np
+import matplotlib.cm as cm
 import matplotlib.pyplot as plt
+import numpy as np
 from matplotlib.animation import FuncAnimation
-import matplotlib.cm as cm
 
 L = 10  # Length of the domain
 
 # Initialize parameters
 num_samples = 1000
 theta = np.linspace(0, 2 * np.pi, num_samples, endpoint=False)
 N = 4  # Number of harmonics
-activation = 'relu'
+activation = "relu"
 
 
 def gaussian_on_circle(theta, loc, sigma=0.1):
@@ -20,19 +20,19 @@ def relu(x):
     return np.maximum(0, x)
 
 # Function to plot a harmonic given amplitude and phase
-def plot_harmonic(ax, amplitude, phase, n, label, activation='relu'):
+def plot_harmonic(ax, amplitude, phase, n, label, activation="relu"):
 
     harmonic_values = amplitude * np.cos(n * theta + phase)
-    if activation == 'relu':
+    if activation == "relu":
         harmonic_values = relu(harmonic_values)
-    ax.plot(np.cos(theta), np.sin(theta), zs=0, zdir='z', linestyle='--',linewidth=3, color='black')
+    ax.plot(np.cos(theta), np.sin(theta), zs=0, zdir="z", linestyle="--",linewidth=3, color="black")
     normalized_phase = (phase + np.pi) / (2 * np.pi)  # Normalizing from -π to π to 0 to 1
     color = cm.hsv(normalized_phase)
     ax.plot(np.cos(theta), np.sin(theta), harmonic_values, label=label,linewidth=3,color=color,alpha=1-0.1*n)
-    ax.axis('off')
+    ax.axis("off")
 
 # Prepare figure for plotting
-fig, axs = plt.subplots(2, N+1, figsize=(20, 10), subplot_kw={'projection': '3d'})
+fig, axs = plt.subplots(2, N+1, figsize=(20, 10), subplot_kw={"projection": "3d"})
 plt.tight_layout()
 
 def update(loc):
@@ -46,36 +46,36 @@ def update(loc):
     for ax_row in axs:
         for ax in ax_row:
             ax.cla()
-            ax.axis('off')
+            ax.axis("off")
 
     # Plot original function
-    axs[0, 2].plot(np.cos(theta), np.sin(theta), zs=0, zdir='z', linestyle='--',linewidth=3,color='black')
-    axs[0, 2].plot(np.cos(theta), np.sin(theta), bump_samples, label='Original Function',linewidth=3,color='tomato')
-    axs[0, 2].set_title('Target place field, position = {:.2f}'.format(loc),fontsize=20)
-    axs[0, 2].scatter(np.cos(loc), np.sin(loc), zs=0, zdir='z', s=100, c='red')
+    axs[0, 2].plot(np.cos(theta), np.sin(theta), zs=0, zdir="z", linestyle="--",linewidth=3,color="black")
+    axs[0, 2].plot(np.cos(theta), np.sin(theta), bump_samples, label="Original Function",linewidth=3,color="tomato")
+    axs[0, 2].set_title(f"Target place field, position = {loc:.2f}",fontsize=20)
+    axs[0, 2].scatter(np.cos(loc), np.sin(loc), zs=0, zdir="z", s=100, c="red")
 
     # Plot each harmonic and the reconstructed function
     reconstructed = np.zeros(num_samples)
     for n in range(1, N+1):
         index = n if frequencies[n] >= 0 else num_samples + n
         amplitude = np.abs(coefficients_fft[index])
         phase = np.angle(coefficients_fft[index])
-        
-        plot_harmonic(axs[1, n-1], amplitude, phase, n, f'GC module {n}, period $\lambda=${L/n:0.1f}', activation=activation)
-        axs[1, n-1].set_title(f'GC module {n}, period $\lambda_{n}=${L/n:0.1f}',fontsize=18)
-        if activation == 'relu':
+
+        plot_harmonic(axs[1, n-1], amplitude, phase, n, rf"GC module {n}, period $\lambda=${L/n:0.1f}", activation=activation)
+        axs[1, n-1].set_title(rf"GC module {n}, period $\lambda_{n}=${L/n:0.1f}",fontsize=18)
+        if activation == "relu":
             reconstructed += relu(amplitude * np.cos(n * theta + phase))
         else:
             reconstructed += amplitude * np.cos(n * theta + phase)
 
     # Reconstructed function
-    axs[1, N].plot(np.cos(theta), np.sin(theta), zs=0, zdir='z', linestyle='--',linewidth=3,color='black')
-    axs[1, N].plot(np.cos(theta), np.sin(theta), reconstructed, label='Reconstructed',linewidth=3,color='limegreen')
-    axs[1, N].set_title('Place field readout',fontsize=20)
+    axs[1, N].plot(np.cos(theta), np.sin(theta), zs=0, zdir="z", linestyle="--",linewidth=3,color="black")
+    axs[1, N].plot(np.cos(theta), np.sin(theta), reconstructed, label="Reconstructed",linewidth=3,color="limegreen")
+    axs[1, N].set_title("Place field readout",fontsize=20)
 
 # Create animation
-loc_values = np.linspace(0, 2*np.pi, 100)  
+loc_values = np.linspace(0, 2*np.pi, 100)
 ani = FuncAnimation(fig, update, frames=loc_values, repeat=True)
 
 # Save the animation
-ani.save('position_from_grid_cells.gif', writer='imagemagick', fps=10)
+ani.save("position_from_grid_cells.gif", writer="imagemagick", fps=10)

neurometry/curvature/grid-cells-curvature/notebooks/12_path_int.ipynb

@@ -27,15 +27,12 @@
     "%autoreload 2\n",
     "%load_ext jupyter_black\n",
     "\n",
-    "import numpy as np\n",
+    "import os\n",
     "\n",
     "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
     "\n",
-    "\n",
-    "import os\n",
-    "\n",
-    "os.environ[\"GEOMSTATS_BACKEND\"] = \"pytorch\"\n",
-    "import geomstats.backend as gs"
+    "os.environ[\"GEOMSTATS_BACKEND\"] = \"pytorch\""
    ]
   },
   {

neurometry/curvature/hyperspherical/distributions/hyperspherical_uniform.py

@@ -22,7 +22,7 @@ def device(self, val):
         self._device = val if isinstance(val, torch.device) else torch.device(val)
 
     def __init__(self, dim, validate_args=None, device=None):
-        super(HypersphericalUniform, self).__init__(
+        super().__init__(
             torch.Size([dim]), validate_args=validate_args
         )
         self._dim = dim