add function parameters

Author: Sallyliubj

docs/api/spiking/eval_go_nogo.rst

@@ -19,12 +19,16 @@ Main Function
 Function Parameters
 -------------------
 
-The main evaluation function can be called with optional parameters:
+The main evaluation function accepts:
 
-* **model_path** (str, optional): Path to trained model file
-* **scaling_factor** (float, optional): Scaling factor for conversion
-* **n_trials** (int, optional): Number of trials to evaluate
-* **plot_results** (bool, optional): Whether to generate plots
+* **model_path** (str): Path to directory containing trained model files
+  (default: '../models/go-nogo/P_rec_0.2_Taus_4.0_20.0')
+
+The function will:
+1. Load the first .mat model file from the specified directory
+2. Extract the optimal scaling factor from the model
+3. Run example Go and NoGo trials
+4. Generate visualizations of network behavior
 
 Example Usage
 -------------
@@ -33,34 +37,33 @@ Example Usage
 
    from spiking import eval_go_nogo
 
-   # Evaluate with default parameters
+   # Evaluate with default model path
    eval_go_nogo()
 
-   # Evaluate specific model with custom parameters
+   # Evaluate specific model
    eval_go_nogo(
-       model_path='models/go-nogo/trained_model.mat',
-       scaling_factor=50.0,
-       n_trials=100,
-       plot_results=True
+       model_path='models/go-nogo/my_trained_models'
    )
 
 Output Metrics
 --------------
 
 The evaluation generates the following metrics:
 
-* **Go Trial Accuracy**: Percentage of correct responses to Go stimuli
-* **NoGo Trial Accuracy**: Percentage of correct response inhibition to NoGo stimuli
-* **Overall Accuracy**: Combined accuracy across all trials
-* **Response Time**: Average response time for Go trials
-* **Spike Count**: Total number of spikes generated during trials
+* **Network Output**: Response curves for both Go and NoGo trials
+* **Spike Patterns**: Detailed spike raster plots showing:
+  - Excitatory neuron activity (red)
+  - Inhibitory neuron activity (blue)
+* **Temporal Dynamics**: Network behavior over the full trial duration
 
 Visualization
 -------------
 
 The function generates several plots:
 
-* Spike raster plots for Go and NoGo trials
-* Network output comparison between rate and spiking models
-* Performance summary statistics
-* Response time distributions 
+* Network output comparison between Go and NoGo trials
+* Spike raster plots showing:
+  - NoGo trial neural activity
+  - Go trial neural activity
+* Color-coded neuron types (excitatory in red, inhibitory in blue)
+* Time-resolved network responses 

docs/api/spiking/lambda_grid_search.rst

@@ -25,20 +25,24 @@ Grid Search Parameters
 
 The main grid search function accepts:
 
-* **model_path** (str, optional): Path to trained rate RNN model
-* **scaling_range** (tuple, optional): Range of scaling factors to test (default: 20-75)
-* **n_trials_per_factor** (int, optional): Number of trials per scaling factor
-* **task_type** (str, optional): Task type ('go-nogo', 'xor', 'mante')
-* **parallel** (bool, optional): Whether to use parallel processing
+* **model_dir** (str): Directory containing trained rate RNN model .mat files
+  (default: '../models/go-nogo/P_rec_0.2_Taus_4.0_20.0')
+* **n_trials** (int): Number of trials to evaluate each scaling factor
+  (default: 100)
+* **scaling_factors** (list): List of scaling factors to test
+  (default: [20, 25, 30, ..., 75])
+* **task_name** (str): Task type ('go-nogo', 'xor', or 'mante')
+  (default: 'go-nogo')
 
 Single Trial Evaluation
 ----------------------------------------------------
 
 The evaluate_single_trial function tests a specific scaling factor:
 
-* **model_path** (str): Path to model file
+* **curr_full** (str): Full path to model file
 * **scaling_factor** (float): Scaling factor to test
 * **trial_params** (dict): Trial parameters including stimulus and task settings
+* **task_name** (str): Name of the task to evaluate
 
 Returns performance metrics for the given scaling factor.
 
@@ -54,28 +58,28 @@ Example Usage
 
    # Grid search with custom parameters
    lambda_grid_search(
-       model_path='models/go-nogo/trained_model.mat',
-       scaling_range=(30, 80),
-       n_trials_per_factor=50,
-       task_type='go-nogo',
-       parallel=True
+       model_dir='models/go-nogo',
+       n_trials=50,
+       scaling_factors=list(range(30, 81, 5)),
+       task_name='go-nogo'
    )
 
-   # Evaluate a single scaling factor
+   # Evaluate a single trial
    from spiking.lambda_grid_search import evaluate_single_trial
    
    performance = evaluate_single_trial(
        model_path='models/go-nogo/trained_model.mat',
        scaling_factor=50.0,
-       trial_params={'stimulus': stimulus, 'task': 'go-nogo'}
+       trial_params={},
+       task_name='go-nogo'
    )
 
 Optimization Process
 ----------------------------------------------------
 
 The grid search follows these steps:
 
-1. **Load trained rate model** from the specified path
+1. **Load trained rate models** from the specified directory
 2. **Generate test stimuli** appropriate for the task type
 3. **Iterate through scaling factors** in the specified range
 4. **Convert to spiking network** for each scaling factor
@@ -101,18 +105,15 @@ Different metrics are used depending on the task:
 * Context-dependent decision accuracy
 * Sensory integration performance
 
-Parallel Processing
+Output Files
 ----------------------------------------------------
 
-The module supports parallel processing using Python's multiprocessing:
-
-.. code-block:: python
+The function modifies each input .mat file to include:
 
-   # Enable parallel processing (default)
-   lambda_grid_search(parallel=True)
+* **opt_scaling_factor**: The optimal scaling factor found
+* **all_perfs**: Performance scores for all tested scaling factors
+* **scaling_factors**: List of all scaling factors that were tested
 
-   # Disable for debugging
-   lambda_grid_search(parallel=False)
 
 Output
 ----------------------------------------------------

spiking/eval_go_nogo.py

@@ -28,11 +28,10 @@
 
 from .LIF_network_fnc import LIF_network_fnc
 
-def eval_go_nogo():
+def eval_go_nogo(model_path= '../models/go-nogo/P_rec_0.2_Taus_4.0_20.0'):
     # First, load one trained rate RNN
     # Make sure lambda_grid_search.py was performed on the model.
     # Update model_path to point where the trained model is
-    model_path = '../models/go-nogo/P_rec_0.2_Taus_4.0_20.0'
     mat_files = [f for f in os.listdir(model_path) if f.endswith('.mat')]
     model_name = mat_files[0]
     model_path = os.path.join(model_path, model_name)

spiking/lambda_grid_search.py

@@ -162,41 +162,52 @@ def evaluate_single_trial(args):
 
     return 0, np.zeros((1, 1000))
 
-def lambda_grid_search():
+def lambda_grid_search(model_dir =  '../models/go-nogo/P_rec_0.2_Taus_4.0_20.0', n_trials = 100, scaling_factors = list(range(20, 76, 5)), task_name = 'go-nogo'):
+    """
+    Perform a grid search to find the optimal scaling factor for a given task.
+    
+    Args:
+        model_dir (str): The directory containing the trained rate RNN model .mat files.
+            Default: '../models/go-nogo/P_rec_0.2_Taus_4.0_20.0'
+        n_trials (int): The number of trials to use to evaluate the LIF RNN.
+            Default: 100
+        scaling_factors (list): The scaling factor values to try for grid search.
+            Default: [20, 25, 30, ..., 75]
+        task_name (str): The name of the task to evaluate ('go-nogo', 'xor', or 'mante').
+            Default: 'go-nogo'
+    
+    The optimal scaling factor and performance metrics are saved back to the original .mat file
+    with the following new fields:
+    - opt_scaling_factor: The scaling factor that achieved best performance
+    - all_perfs: Performance scores for all tested scaling factors
+    - scaling_factors: List of all scaling factors that were tested
+    """
     # Directory containing all the trained rate RNN model .mat files
-    model_dir = '../models/go-nogo/P_rec_0.2_Taus_4.0_20.0'
+    # model_dir = '../models/go-nogo/P_rec_0.2_Taus_4.0_20.0'
+    
     mat_files = [f for f in os.listdir(model_dir) if f.endswith('.mat')]
 
     # Whether to use the initial random connectivity weights
     # This should be set to False unless you want to compare
     # the effects of pre-trained vs post-trained weights
     use_initial_weights = False
 
-    # Number of trials to use to evaluate the LIF RNN
-    n_trials = 100
-    
-    # Scaling factor values to try for grid search
-    # The more values it has, the longer the search
-    scaling_factors = list(range(20, 76, 5))  # [20, 25, 30, ..., 75]
-    
     # Grid search
     for i, mat_file in enumerate(mat_files):
         curr_fname = mat_file
         curr_full = os.path.join(model_dir, curr_fname)
         print(f'Analyzing {curr_fname}')
 
-        # Get the task name
-        task_name = None
-        if 'go-nogo' in curr_full:
-            task_name = 'go-nogo'
-        elif 'mante' in curr_full:
-            task_name = 'mante'
-        elif 'xor' in curr_full:
-            task_name = 'xor'
-        
         if task_name is None:
-            print(f"Unknown task type for {curr_fname}")
-            continue
+            if 'go-nogo' in curr_full:
+                task_name = 'go-nogo'
+            elif 'mante' in curr_full:
+                task_name = 'mante'
+            elif 'xor' in curr_full:
+                task_name = 'xor'
+            else:
+                print(f"Unknown task type for {curr_fname}")
+                continue
 
         # Load the model
         model_data = sio.loadmat(curr_full)