bluecellulab 2.6.62__tar.gz → 2.6.64__tar.gz

{bluecellulab-2.6.62 → bluecellulab-2.6.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bluecellulab
-Version: 2.6.62
+Version: 2.6.64
 Summary: Biologically detailed neural network simulations and analysis.
 Author: Blue Brain Project, EPFL
 License: Apache2.0

{bluecellulab-2.6.62 → bluecellulab-2.6.64}/bluecellulab/analysis/analysis.py

@@ -4,9 +4,11 @@ try:
 except ImportError:
     efel = None
 from itertools import islice
+from itertools import repeat
 import logging
 from matplotlib.collections import LineCollection
 import matplotlib.pyplot as plt
+from multiprocessing import Pool
 import neuron
 import numpy as np
 import pathlib
@@ -40,7 +42,8 @@ def compute_plot_iv_curve(cell,
                           show_figure=True,
                           save_figure=False,
                           output_dir="./",
-                          output_fname="iv_curve.pdf"):
+                          output_fname="iv_curve.pdf",
+                          n_processes=None):
     """Compute and plot the Current-Voltage (I-V) curve for a given cell by
     injecting a range of currents.
 
@@ -72,6 +75,9 @@ def compute_plot_iv_curve(cell,
         save_figure (bool): Whether to save the figure. Default is False.
         output_dir (str): The directory to save the figure if save_figure is True. Default is "./".
         output_fname (str): The filename to save the figure as if save_figure is True. Default is "iv_curve.png".
+        n_processes (int, optional): The number of processes to use for parallel execution.
+            If None or if it is higher than the number of steps,
+            it will use the number of steps as the number of processes.
 
     Returns:
         tuple: A tuple containing:
@@ -95,15 +101,22 @@ def compute_plot_iv_curve(cell,
         for amp in list_amp
     ]
 
-    recordings = []
-    for step in steps:
-        recording = run_stimulus(cell.template_params,
-                                 step,
-                                 section=injecting_section,
-                                 segment=injecting_segment,
-                                 recording_section=recording_section,
-                                 recording_segment=recording_segment)
-        recordings.append(recording)
+    if n_processes is None or n_processes > len(steps):
+        n_processes = len(steps)
+    with Pool(n_processes) as p:
+        recordings = p.starmap(
+            run_stimulus,
+            zip(
+                repeat(cell.template_params),
+                steps,
+                repeat(injecting_section),
+                repeat(injecting_segment),
+                repeat(True),  # cvode
+                repeat(True),  # add_hypamp
+                repeat(recording_section),
+                repeat(recording_segment),
+            )
+        )
 
     steady_states = []
     # compute steady state response
@@ -148,7 +161,8 @@ def compute_plot_fi_curve(cell,
                           show_figure=True,
                           save_figure=False,
                           output_dir="./",
-                          output_fname="fi_curve.pdf"):
+                          output_fname="fi_curve.pdf",
+                          n_processes=None):
     """Compute and plot the Frequency-Current (F-I) curve for a given cell by
     injecting a range of currents.
 
@@ -182,6 +196,9 @@ def compute_plot_fi_curve(cell,
         save_figure (bool): Whether to save the figure. Default is False.
         output_dir (str): The directory to save the figure if save_figure is True. Default is "./".
         output_fname (str): The filename to save the figure as if save_figure is True. Default is "iv_curve.png".
+        n_processes (int, optional): The number of processes to use for parallel execution.
+            If None or if it is higher than the number of steps,
+            it will use the number of steps as the number of processes.
 
     Returns:
         tuple: A tuple containing:
@@ -201,19 +218,26 @@ def compute_plot_fi_curve(cell,
         for amp in list_amp
     ]
 
-    spikes = []
-    for step in steps:
-        recording = run_stimulus(cell.template_params,
-                                 step,
-                                 section=injecting_section,
-                                 segment=injecting_segment,
-                                 recording_section=recording_section,
-                                 recording_segment=recording_segment,
-                                 enable_spike_detection=True,
-                                 threshold_spike_detection=threshold_voltage)
-        spikes.append(recording.spike)
+    if n_processes is None or n_processes > len(steps):
+        n_processes = len(steps)
+    with Pool(n_processes) as p:
+        recordings = p.starmap(
+            run_stimulus,
+            zip(
+                repeat(cell.template_params),
+                steps,
+                repeat(injecting_section),
+                repeat(injecting_segment),
+                repeat(True),  # cvode
+                repeat(True),  # add_hypamp
+                repeat(recording_section),
+                repeat(recording_segment),
+                repeat(True),  # enable_spike_detection
+                repeat(threshold_voltage),  # threshold_spike_detection
+            )
+        )
 
-    spike_count = [len(spike) for spike in spikes]
+    spike_count = [len(recording.spike) for recording in recordings]
 
     plot_fi_curve(list_amp,
                   spike_count,
@@ -327,29 +351,32 @@ class BPAP:
         return soma_amp, dend_amps, dend_dist, apic_amps, apic_dist
 
     @staticmethod
-    def fit(soma_amp, dend_amps, dend_dist, apic_amps, apic_dist):
+    def fit(soma_amp, branch_amps, branch_dist):
         """Fit the amplitudes vs distances to an exponential decay function."""
         from scipy.optimize import curve_fit
 
-        popt_dend = None
-        if dend_amps and dend_dist:
-            dist = [0] + dend_dist  # add soma distance
-            amps = soma_amp + dend_amps  # add soma amplitude
-            popt_dend, _ = curve_fit(exp_decay, dist, amps)
-
-        popt_apic = None
-        if apic_amps and apic_dist:
-            dist = [0] + apic_dist  # add soma distance
-            amps = soma_amp + apic_amps  # add soma amplitude
-            popt_apic, _ = curve_fit(exp_decay, dist, amps)
-
-        return popt_dend, popt_apic
+        if not branch_amps or not branch_dist or len(branch_amps) != len(branch_dist):
+            return None, False
+        try:
+            dist = [0] + branch_dist
+            amps = soma_amp + branch_amps
+            popt, _ = curve_fit(exp_decay, dist, amps)
+            return popt, False
+        except RuntimeError:
+            return None, True
 
     def validate(self, soma_amp, dend_amps, dend_dist, apic_amps, apic_dist):
         """Check that the exponential fit is decaying."""
         validated = True
         notes = ""
-        popt_dend, popt_apic = self.fit(soma_amp, dend_amps, dend_dist, apic_amps, apic_dist)
+        popt_dend, dend_fit_error = self.fit(soma_amp, dend_amps, dend_dist)
+        popt_apic, apic_fit_error = self.fit(soma_amp, apic_amps, apic_dist)
+        if dend_fit_error or apic_fit_error:
+            logger.debug("Fitting error occurred.")
+            validated = False
+            notes += "Validation failed: Fitting error occurred.\n"
+            return validated, notes
+
         if dend_amps is not None:
             plt.cla()
             plt.plot([0], soma_amp, '.')
@@ -391,7 +418,8 @@ class BPAP:
         output_fname="bpap.pdf",
     ):
         """Plot the results of the BPAP analysis."""
-        popt_dend, popt_apic = self.fit(soma_amp, dend_amps, dend_dist, apic_amps, apic_dist)
+        popt_dend, _ = self.fit(soma_amp, dend_amps, dend_dist)
+        popt_apic, _ = self.fit(soma_amp, apic_amps, apic_dist)
 
         outpath = pathlib.Path(output_dir) / output_fname
         fig, ax1 = plt.subplots(figsize=(10, 6))

{bluecellulab-2.6.62 → bluecellulab-2.6.64}/bluecellulab/validation/validation.py

@@ -337,7 +337,7 @@ def rin_test(rin):
     }
 
 
-def iv_test(template_params, rheobase, out_dir, spike_threshold_voltage=-30.):
+def iv_test(template_params, rheobase, out_dir, spike_threshold_voltage=-30., n_processes=None):
     """IV curve should have a positive slope."""
     name = "Simulatable Neuron IV Curve Validation"
     amps, steady_states = compute_plot_iv_curve(
@@ -348,7 +348,9 @@ def iv_test(template_params, rheobase, out_dir, spike_threshold_voltage=-30.):
         show_figure=False,
         save_figure=True,
         output_dir=out_dir,
-        output_fname="iv_curve.pdf")
+        output_fname="iv_curve.pdf",
+        n_processes=n_processes,
+    )
 
     outpath = pathlib.Path(out_dir) / "iv_curve.pdf"
 
@@ -375,7 +377,7 @@ def iv_test(template_params, rheobase, out_dir, spike_threshold_voltage=-30.):
     }
 
 
-def fi_test(template_params, rheobase, out_dir, spike_threshold_voltage=-30.):
+def fi_test(template_params, rheobase, out_dir, spike_threshold_voltage=-30., n_processes=None):
     """FI curve should have a positive slope."""
     name = "Simulatable Neuron FI Curve Validation"
     amps, spike_counts = compute_plot_fi_curve(
@@ -386,7 +388,9 @@ def fi_test(template_params, rheobase, out_dir, spike_threshold_voltage=-30.):
         show_figure=False,
         save_figure=True,
         output_dir=out_dir,
-        output_fname="fi_curve.pdf")
+        output_fname="fi_curve.pdf",
+        n_processes=n_processes,
+    )
 
     outpath = pathlib.Path(out_dir) / "fi_curve.pdf"
 
@@ -448,7 +452,8 @@ def run_validations(
     spike_threshold_voltage=-30,
     v_init=-80.0,
     celsius=34.0,
-    output_dir="./memodel_validation_figures"
+    output_dir="./memodel_validation_figures",
+    n_processes=None,
 ):
     """Run all the validations on the cell.
 
@@ -459,6 +464,9 @@ def run_validations(
         v_init: Initial membrane potential. Default is -80.0 mV.
         celsius: Temperature in Celsius. Default is 34.0.
         output_dir (str): The directory to save the validation figures.
+        n_processes (int, optional): The number of processes to use for parallel execution
+            in IV and FI curves computation. If None or higher than the number of steps,
+            then it will use the number of steps as the number of processes instead.
     """
     out_dir = pathlib.Path(output_dir) / cell_name
     out_dir.mkdir(parents=True, exist_ok=True)
@@ -484,41 +492,68 @@ def run_validations(
     )
 
     logger.debug("Running validations...")
-    # Validation 1: Spiking Test
-    spiking_test_result = spiking_test(
-        cell.template_params, rheobase, out_dir, spike_threshold_voltage
-    )
+    from bluecellulab.utils import NestedPool
+    val_n_processes = n_processes if n_processes is not None else 7
+    with NestedPool(processes=val_n_processes) as pool:
+        # Validation 1: Spiking Test
+        spiking_test_result_future = pool.apply_async(
+            spiking_test,
+            (cell.template_params, rheobase, out_dir, spike_threshold_voltage)
+        )
 
-    # Validation 2: Depolarization Block Test
-    depolarization_block_result = depolarization_block_test(
-        cell.template_params, rheobase, out_dir
-    )
+        # Validation 2: Depolarization Block Test
+        depolarization_block_result_future = pool.apply_async(
+            depolarization_block_test,
+            (cell.template_params, rheobase, out_dir)
+        )
 
-    # Validation 3: Backpropagating AP Test
-    bpap_result = bpap_test(cell.template_params, rheobase, out_dir)
+        # Validation 3: Backpropagating AP Test
+        bpap_result_future = pool.apply_async(
+            bpap_test,
+            (cell.template_params, rheobase, out_dir)
+        )
 
-    # Validation 4: Postsynaptic Potential Test
-    # We have to wait for ProbAMPANMDA_EMS to be present in entitycore to implement this test
+        # Validation 4: Postsynaptic Potential Test
+        # We have to wait for ProbAMPANMDA_EMS to be present in entitycore to implement this test
 
-    # Validation 5: AIS Spiking Test
-    ais_spiking_test_result = ais_spiking_test(
-        cell.template_params, rheobase, out_dir, spike_threshold_voltage
-    )
+        # Validation 5: AIS Spiking Test
+        ais_spiking_test_result_future = pool.apply_async(
+            ais_spiking_test,
+            (cell.template_params, rheobase, out_dir, spike_threshold_voltage)
+        )
 
-    # Validation 6: Hyperpolarization Test
-    hyperpolarization_result = hyperpolarization_test(cell.template_params, rheobase, out_dir)
+        # Validation 6: Hyperpolarization Test
+        hyperpolarization_result_future = pool.apply_async(
+            hyperpolarization_test,
+            (cell.template_params, rheobase, out_dir)
+        )
 
-    # Validation 7: Rin Test
-    rin_result = rin_test(rin)
+        # Validation 7: Rin Test
+        rin_result_future = pool.apply_async(
+            rin_test,
+            (rin,)
+        )
 
+        # Validation 10: Thumbnail Test
+        thumbnail_result_future = pool.apply_async(
+            thumbnail_test,
+            (cell.template_params, rheobase, out_dir)
+        )
+
+        spiking_test_result = spiking_test_result_future.get()
+        depolarization_block_result = depolarization_block_result_future.get()
+        bpap_result = bpap_result_future.get()
+        ais_spiking_test_result = ais_spiking_test_result_future.get()
+        hyperpolarization_result = hyperpolarization_result_future.get()
+        rin_result = rin_result_future.get()
+        thumbnail_result = thumbnail_result_future.get()
+
+    # IV and FI tests are outside of nestedpool, because they use multiprocessing internaly
     # Validation 8: IV Test
-    iv_test_result = iv_test(cell.template_params, rheobase, out_dir, spike_threshold_voltage)
+    iv_test_result = iv_test(cell.template_params, rheobase, out_dir, spike_threshold_voltage, n_processes)
 
     # Validation 9: FI Test
-    fi_test_result = fi_test(cell.template_params, rheobase, out_dir, spike_threshold_voltage)
-
-    # Validation 10: Thumbnail Test
-    thumbnail_result = thumbnail_test(cell.template_params, rheobase, out_dir)
+    fi_test_result = fi_test(cell.template_params, rheobase, out_dir, spike_threshold_voltage, n_processes)
 
     return {
         "memodel_properties": {

{bluecellulab-2.6.62 → bluecellulab-2.6.64}/bluecellulab.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bluecellulab
-Version: 2.6.62
+Version: 2.6.64
 Summary: Biologically detailed neural network simulations and analysis.
 Author: Blue Brain Project, EPFL
 License: Apache2.0