diff --git a/notebooks/plot_scores.ipynb b/notebooks/plot_scores.ipynb
new file mode 100644
index 000000000..7ab21cbe9
--- /dev/null
+++ b/notebooks/plot_scores.ipynb
@@ -0,0 +1,144 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def headmap(scores, name=''):\n",
+    "    import matplotlib.pyplot as plt\n",
+    "    import numpy as np\n",
+    "    import seaborn\n",
+    "    fig, ax = plt.subplots(1, 1, figsize=(4, 4), sharey=True)\n",
+    "    vmin = np.nanmin(scores)\n",
+    "    vmax = np.nanmax(scores)\n",
+    "\n",
+    "    seaborn.heatmap(scores, ax=ax, square=False, cbar=False, annot=True, fmt='.2f', vmin=vmin, vmax=vmax)\n",
+    "    # Remove only the ticks, keep labels\n",
+    "    ax.tick_params(left=False, bottom=False)\n",
+    "    ax.xaxis.set_tick_params(width=0)\n",
+    "    ax.yaxis.set_tick_params(width=0)\n",
+    "    ax.set_title(name, pad=10)\n",
+    "\n",
+    "\n",
+    "    plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                ex(True)_tf(-1)  ex(False)_tf(-1)  ex(True)_tf(140)   \n",
+      "seurat_lognorm         0.278739          0.193066          0.278739  \\\n",
+      "lognorm                0.279906          0.194220          0.279906   \n",
+      "pearson                0.373893          0.301601          0.373893   \n",
+      "scgen_pearson          0.453783          0.377673          0.453783   \n",
+      "seurat_pearson         0.366976          0.290578          0.366976   \n",
+      "scgen_lognorm          0.376297          0.279118          0.376297   \n",
+      "\n",
+      "                ex(False)_tf(140)      Mean  \n",
+      "seurat_lognorm           0.193066  0.235902  \n",
+      "lognorm                  0.194220  0.237063  \n",
+      "pearson                  0.301601  0.337747  \n",
+      "scgen_pearson            0.377673  0.415728  \n",
+      "seurat_pearson           0.290578  0.328777  \n",
+      "scgen_lognorm            0.279118  0.327708  \n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "import yaml\n",
+    "\n",
+    "# Load the YAML file\n",
+    "result_file = '../resources/results/0/scores.yaml'\n",
+    "with open(result_file, 'r') as file:\n",
+    "    data = yaml.safe_load(file)\n",
+    "\n",
+    "# Initialize a dictionary to hold DataFrames for each method_id\n",
+    "dfs = {}\n",
+    "\n",
+    "# Process each entry in the YAML file\n",
+    "for entry in data:\n",
+    "    method_id = entry['method_id']\n",
+    "    dataset_id = entry['dataset_id']\n",
+    "    \n",
+    "    # If the method_id is not yet in the dictionary, initialize an empty DataFrame\n",
+    "    if method_id not in dfs:\n",
+    "        dfs[method_id] = pd.DataFrame()\n",
+    "    \n",
+    "    # Create a dictionary with metric_ids as keys and metric_values as values\n",
+    "    metrics_dict = dict(zip(entry['metric_ids'], entry['metric_values']))\n",
+    "    \n",
+    "    # Convert the dictionary to a DataFrame with dataset_id as the index\n",
+    "    df_entry = pd.DataFrame(metrics_dict, index=[dataset_id])\n",
+    "    \n",
+    "    # Append the entry to the corresponding DataFrame\n",
+    "    dfs[method_id] = pd.concat([dfs[method_id], df_entry])\n",
+    "\n",
+    "# Example: Access the DataFrame for 'reg1-scenicplus'\n",
+    "df_scenicplus = dfs.get('reg1-scenicplus')\n",
+    "print(df_scenicplus)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import pandas as pd\n",
+    "# output_dir = '../out'\n",
+    "# grn_models = ['celloracle','scenicplus','figr']\n",
+    "\n",
+    "# col = 'ex(False)_tf(-1)'\n",
+    "# scores = pd.DataFrame()\n",
+    "# for grn in grn_models:\n",
+    "#     df = pd.read_csv(f\"{output_dir}/{grn}.csv\", index_col=0)\n",
+    "#     scores[grn] = df[col]\n",
+    "# headmap(scores, name=col)\n",
+    "\n",
+    "# col = 'ex(True)_tf(-1)'\n",
+    "# scores = pd.DataFrame()\n",
+    "# for grn in grn_models:\n",
+    "#     df = pd.read_csv(f\"{output_dir}/{grn}.csv\", index_col=0)\n",
+    "#     scores[grn] = df[col]\n",
+    "# headmap(scores, name=col)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "py10",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/params/params.yaml b/params/params.yaml
index eace60e73..a34550360 100644
--- a/params/params.yaml
+++ b/params/params.yaml
@@ -1,9 +1,9 @@
-# param_list:
-#   - id: test_process_perturbation
-#     perturbation_counts: "s3://openproblems-data/resources/grn/datasets_raw/perturbation_counts.h5ad"
+param_list:
+  - id: test_process_perturbation
+    perturbation_counts: "s3://openproblems-data/resources/grn/datasets_raw/perturbation_counts.h5ad"
 
-# output_state: "state.yaml"
-# publish_dir: "s3://openproblems-data/resources/grn/results/process_perturbation/run_5"
+output_state: "state.yaml"
+publish_dir: "s3://openproblems-data/resources/grn/results/process_perturbation/run_5"
 
 
 
diff --git a/params/params_0.yaml b/params/params_0.yaml
new file mode 100644
index 000000000..57db7192a
--- /dev/null
+++ b/params/params_0.yaml
@@ -0,0 +1,299 @@
+param_list:
+  - id: pearson_celloracle
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: pearson
+    prediction: resources/grn_models/celloracle.csv 
+    reg_type: ridge
+    method_id: celloracle
+    subsample: 2
+
+  - id: lognorm_celloracle
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: lognorm
+    prediction: resources/grn_models/celloracle.csv 
+    reg_type: ridge
+    method_id: celloracle
+    subsample: 2
+
+  - id: scgen_pearson_celloracle
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: scgen_pearson
+    prediction: resources/grn_models/celloracle.csv 
+    reg_type: ridge
+    method_id: celloracle
+    subsample: 2
+
+  - id: scgen_lognorm_celloracle
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: scgen_lognorm
+    prediction: resources/grn_models/celloracle.csv 
+    reg_type: ridge
+    method_id: celloracle
+    subsample: 2
+
+  - id: seurat_pearson_celloracle
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: seurat_pearson
+    prediction: resources/grn_models/celloracle.csv 
+    reg_type: ridge
+    method_id: celloracle
+    subsample: 2
+
+  - id: seurat_lognorm_celloracle
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: seurat_lognorm
+    prediction: resources/grn_models/celloracle.csv 
+    reg_type: ridge
+    method_id: celloracle
+    subsample: 2
+
+  - id: pearson_scenicplus
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: pearson
+    prediction: resources/grn_models/scenicplus.csv 
+    reg_type: ridge
+    method_id: scenicplus
+    subsample: 2
+
+  - id: lognorm_scenicplus
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: lognorm
+    prediction: resources/grn_models/scenicplus.csv 
+    reg_type: ridge
+    method_id: scenicplus
+    subsample: 2
+
+  - id: scgen_pearson_scenicplus
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: scgen_pearson
+    prediction: resources/grn_models/scenicplus.csv 
+    reg_type: ridge
+    method_id: scenicplus
+    subsample: 2
+
+  - id: scgen_lognorm_scenicplus
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: scgen_lognorm
+    prediction: resources/grn_models/scenicplus.csv 
+    reg_type: ridge
+    method_id: scenicplus
+    subsample: 2
+
+  - id: seurat_pearson_scenicplus
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: seurat_pearson
+    prediction: resources/grn_models/scenicplus.csv 
+    reg_type: ridge
+    method_id: scenicplus
+    subsample: 2
+
+  - id: seurat_lognorm_scenicplus
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: seurat_lognorm
+    prediction: resources/grn_models/scenicplus.csv 
+    reg_type: ridge
+    method_id: scenicplus
+    subsample: 2
+
+  - id: pearson_figr
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: pearson
+    prediction: resources/grn_models/figr.csv 
+    reg_type: ridge
+    method_id: figr
+    subsample: 2
+
+  - id: lognorm_figr
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: lognorm
+    prediction: resources/grn_models/figr.csv 
+    reg_type: ridge
+    method_id: figr
+    subsample: 2
+
+  - id: scgen_pearson_figr
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: scgen_pearson
+    prediction: resources/grn_models/figr.csv 
+    reg_type: ridge
+    method_id: figr
+    subsample: 2
+
+  - id: scgen_lognorm_figr
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: scgen_lognorm
+    prediction: resources/grn_models/figr.csv 
+    reg_type: ridge
+    method_id: figr
+    subsample: 2
+
+  - id: seurat_pearson_figr
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: seurat_pearson
+    prediction: resources/grn_models/figr.csv 
+    reg_type: ridge
+    method_id: figr
+    subsample: 2
+
+  - id: seurat_lognorm_figr
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: seurat_lognorm
+    prediction: resources/grn_models/figr.csv 
+    reg_type: ridge
+    method_id: figr
+    subsample: 2
+
+  - id: pearson_granie
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: pearson
+    prediction: resources/grn_models/granie.csv 
+    reg_type: ridge
+    method_id: granie
+    subsample: 2
+
+  - id: lognorm_granie
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: lognorm
+    prediction: resources/grn_models/granie.csv 
+    reg_type: ridge
+    method_id: granie
+    subsample: 2
+
+  - id: scgen_pearson_granie
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: scgen_pearson
+    prediction: resources/grn_models/granie.csv 
+    reg_type: ridge
+    method_id: granie
+    subsample: 2
+
+  - id: scgen_lognorm_granie
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: scgen_lognorm
+    prediction: resources/grn_models/granie.csv 
+    reg_type: ridge
+    method_id: granie
+    subsample: 2
+
+  - id: seurat_pearson_granie
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: seurat_pearson
+    prediction: resources/grn_models/granie.csv 
+    reg_type: ridge
+    method_id: granie
+    subsample: 2
+
+  - id: seurat_lognorm_granie
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: seurat_lognorm
+    prediction: resources/grn_models/granie.csv 
+    reg_type: ridge
+    method_id: granie
+    subsample: 2
+
+  - id: pearson_scglue
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: pearson
+    prediction: resources/grn_models/scglue.csv 
+    reg_type: ridge
+    method_id: scglue
+    subsample: 2
+
+  - id: lognorm_scglue
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: lognorm
+    prediction: resources/grn_models/scglue.csv 
+    reg_type: ridge
+    method_id: scglue
+    subsample: 2
+
+  - id: scgen_pearson_scglue
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: scgen_pearson
+    prediction: resources/grn_models/scglue.csv 
+    reg_type: ridge
+    method_id: scglue
+    subsample: 2
+
+  - id: scgen_lognorm_scglue
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: scgen_lognorm
+    prediction: resources/grn_models/scglue.csv 
+    reg_type: ridge
+    method_id: scglue
+    subsample: 2
+
+  - id: seurat_pearson_scglue
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: seurat_pearson
+    prediction: resources/grn_models/scglue.csv 
+    reg_type: ridge
+    method_id: scglue
+    subsample: 2
+
+  - id: seurat_lognorm_scglue
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: seurat_lognorm
+    prediction: resources/grn_models/scglue.csv 
+    reg_type: ridge
+    method_id: scglue
+    subsample: 2
+
+  - id: pearson_positive_control
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: pearson
+    prediction: resources/control_models/pearson_positive_control.csv 
+    reg_type: ridge
+    method_id: positive_control
+    subsample: 2
+
+  - id: lognorm_positive_control
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: lognorm
+    prediction: resources/control_models/lognorm_positive_control.csv 
+    reg_type: ridge
+    method_id: positive_control
+    subsample: 2
+
+  - id: scgen_pearson_positive_control
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: scgen_pearson
+    prediction: resources/control_models/scgen_pearson_positive_control.csv 
+    reg_type: ridge
+    method_id: positive_control
+    subsample: 2
+
+  - id: scgen_lognorm_positive_control
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: scgen_lognorm
+    prediction: resources/control_models/scgen_lognorm_positive_control.csv 
+    reg_type: ridge
+    method_id: positive_control
+    subsample: 2
+
+  - id: seurat_pearson_positive_control
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: seurat_pearson
+    prediction: resources/control_models/seurat_pearson_positive_control.csv 
+    reg_type: ridge
+    method_id: positive_control
+    subsample: 2
+
+  - id: seurat_lognorm_positive_control
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: seurat_lognorm
+    prediction: resources/control_models/seurat_lognorm_positive_control.csv 
+    reg_type: ridge
+    method_id: positive_control
+    subsample: 2
+
+  - id: seurat_lognorm_negative_control
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: seurat_lognorm
+    prediction: resources/control_models/negative_control.csv 
+    reg_type: ridge
+    method_id: negative_control
+    subsample: 2
+
+output_state: "state.yaml"
+publish_dir: "s3://openproblems-data/resources/grn/results/0"
diff --git a/params/params_2.yaml b/params/params_2.yaml
index a0db77c83..183af9d2d 100644
--- a/params/params_2.yaml
+++ b/params/params_2.yaml
@@ -4,12 +4,14 @@ param_list:
     layer: "lognorm"
     prediction: resources/grn_models/scenicplus.csv 
     reg_type: ridge
+    method_id: scenicplus
     subsample: 2
   - id: pearson_scenicplus
     perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
     layer: "lognorm"
     prediction: resources/grn_models/scenicplus.csv 
     reg_type: ridge
+    method_id: scenicplus
     subsample: 2
 publish_dir: "./out/"
 output_state: "state.yaml"
\ No newline at end of file
diff --git a/scripts/run_evaluation.sh b/scripts/_run_evaluation.sh
similarity index 100%
rename from scripts/run_evaluation.sh
rename to scripts/_run_evaluation.sh
diff --git a/scripts/run_evaluation_all.sh b/scripts/_run_evaluation_all.sh
similarity index 95%
rename from scripts/run_evaluation_all.sh
rename to scripts/_run_evaluation_all.sh
index 56c45e05e..bb424e664 100644
--- a/scripts/run_evaluation_all.sh
+++ b/scripts/_run_evaluation_all.sh
@@ -8,6 +8,8 @@ grn_names=(
     "granie"
     "scglue"
 )
+layers=("pearson" "lognorm" "scgen_pearson" "scgen_lognorm" "seurat_pearson" "seurat_lognorm")
+
 
 reg_type="ridge" 
 subsample="2"
diff --git a/scripts/generate_resources.sh b/scripts/generate_resources.sh
deleted file mode 100644
index 0a58fb094..000000000
--- a/scripts/generate_resources.sh
+++ /dev/null
@@ -1,63 +0,0 @@
-# download multiome from open problems and rename it
-# aws s3 cp s3://openproblems-bio/public/neurips-2023-competition/2023-09-14_kaggle_upload/2023-08-31_sc_multiome_expression_atac.h5ad ./datasets_raw --no-sign-request
-# aws s3 cp s3://openproblems-bio/public/neurips-2023-competition/sc_counts.h5ad  ./resources/datasets_raw/ --no-sign-request
-# mv ./resources/datasets_raw/2023-08-31_sc_multiome_expression_atac.h5ad ./resources/datasets_raw/multiome_counts.h5ad
-# mv ./resources/datasets_raw/2023-08-31_sc_multiome_expression_atac.h5ad ./resources/datasets_raw/perturbation_counts.h5ad
-# aws s3 sync ./resources/datasets_raw/ s3://openproblems-data/resources/grn/datasets_raw/ --delete
-
-echo ">> download raw data"
-aws s3 sync s3://openproblems-data/resources/grn/datasets_raw ./resources/datasets_raw/ --delete
-
-echo ">> Create test datasets for sc perturbation and multiome" 
-viash run src/process_data/test_data_counts/config.novsh.yaml
-
-echo ">> process multiome"
-viash run src/process_data/multiomics/multiome/config.vsh.yaml 
-
-echo ">> Preprocess perturbation data"
-echo "> QC, pseudobulk, and filter"
-viash run src/process_data/perturbation/sc_counts/config.vsh.yaml 
-echo "> Normalize counts"
-viash run src/process_data/perturbation/normalization/config.vsh.yaml 
-echo "> Batch correction using scgen"
-viash run src/process_data/perturbation/batch_correction_scgen/config.vsh.yaml 
-echo "> Batch correction using seurat"
-viash run src/process_data/perturbation/batch_correction_seurat/config.vsh.yaml 
-
-
-
-# echo ">> Perturbation data: batch correction" TODO"
-
-# echo ">> Create prior data: TODO"
-
-# echo ">> process supp: TODO"
-
-echo ">> Format multiomics data for R "
-echo ">> Extract matrix and annotations from multiome "
-viash run  src/process_data/multiomics/multiome_matrix/config.vsh.yaml 
-
-
-echo ">> Construct rds files from multiomics count matrix and annotations"
-viash run  src/process_data/multiomics/multiome_r/config.vsh.yaml 
-
-
-echo ">> Create test resources"
-echo ">> Extract matrix and annotations from multiome: test data "
-viash run  src/process_data/multiomics/multiome_matrix/config.vsh.yaml --  --multiomics_rna resources_test/grn-benchmark/multiomics_rna.h5ad \
-    --multiomics_atac resources_test/grn-benchmark/multiomics_atac.h5ad \
-    --rna_matrix output/scRNA/X_matrix.mtx \
-    --atac_matrix output/scATAC/X_matrix.mtx \
-    --rna_gene_annot output/scRNA/annotation_gene.csv \
-    --rna_cell_annot output/scRNA/annotation_cell.csv \
-    --atac_peak_annot output/scATAC/annotation_gene.csv \
-    --atac_cell_annot output/scATAC/annotation_cell.csv
-
-echo ">> Construct rds files from multiomics count matrix and annotations: test data"
-viash run  src/process_data/multiomics/multiome_r/config.vsh.yaml --  --rna_matrix output/scRNA/X_matrix.mtx \
-    --atac_matrix output/scATAC/X_matrix.mtx \
-    --rna_gene_annot output/scRNA/annotation_gene.csv \
-    --rna_cell_annot output/scRNA/annotation_cell.csv \
-    --atac_peak_annot output/scATAC/annotation_gene.csv \
-    --atac_cell_annot output/scATAC/annotation_cell.csv \
-    --rna_rds resources_test/grn-benchmark/multiomics_r/rna.rds \
-    --atac_rds resources_test/grn-benchmark/multiomics_r/atac.rds
diff --git a/scripts/run_benchmark_test.sh b/scripts/run_benchmark_test.sh
deleted file mode 100644
index 31a877db2..000000000
--- a/scripts/run_benchmark_test.sh
+++ /dev/null
@@ -1,24 +0,0 @@
-#!/bin/bash
-
-export NXF_VER=23.04.2
-
-resources_dir="resources"
-publish_dir="output/test_run_benchmark"
-
-cat > /tmp/params.yaml << HERE
-param_list:
-  - id: test_run_1
-    multiomics_rna: "$resources_dir/grn-benchmark/multiomics_rna.h5ad"
-    multiomics_atac: "$resources_dir/grn-benchmark/multiomics_atac.h5ad"
-    perturbation_data: "$resources_dir/grn-benchmark/perturbation_data.h5ad"
-    layer: lognorm
-
-output_state: "state.yaml"
-publish_dir: "$publish_dir"
-HERE
-
-nextflow run . \
-  -main-script target/nextflow/workflows/run_benchmark/main.nf \
-  -profile docker \
-  -resume \
-  -params-file /tmp/params.yaml
\ No newline at end of file
diff --git a/scripts/run_grn_evaluation_tw.sh b/scripts/run_grn_evaluation_tw.sh
new file mode 100644
index 000000000..558c376dc
--- /dev/null
+++ b/scripts/run_grn_evaluation_tw.sh
@@ -0,0 +1,87 @@
+#!/bin/bash
+
+# RUN_ID="run_$(date +%Y-%m-%d_%H-%M-%S)"
+RUN_ID=0
+resources_dir="s3://openproblems-data/resources/grn/"
+publish_dir="s3://openproblems-data/resources/grn/results/${RUN_ID}"
+reg_type=ridge
+subsample=2
+
+grn_names=(
+    "celloracle"
+    "scenicplus"
+    "figr"
+    "granie"
+    "scglue"
+)
+layers=("pearson" "lognorm" "scgen_pearson" "scgen_lognorm" "seurat_pearson" "seurat_lognorm")
+
+# Start writing to the YAML file
+cat > ./params/params_${RUN_ID}.yaml << HERE
+param_list:
+HERE
+
+# Nested loops to iterate over grn_names and layers
+for grn_name in "${grn_names[@]}"; do
+  for layer in "${layers[@]}"; do
+    cat >> ./params/params_${RUN_ID}.yaml << HERE
+  - id: ${layer}_${grn_name}
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: ${layer}
+    prediction: resources/grn_models/${grn_name}.csv 
+    reg_type: $reg_type
+    method_id: $grn_name
+    subsample: $subsample
+
+HERE
+  done
+done
+
+# append the positive controls
+grn_name="positive_control"
+for layer in "${layers[@]}"; do
+  cat >> ./params/params_${RUN_ID}.yaml << HERE
+  - id: ${layer}_${grn_name}
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: ${layer}
+    prediction: resources/control_models/${layer}_${grn_name}.csv 
+    reg_type: $reg_type
+    method_id: $grn_name
+    subsample: $subsample
+
+HERE
+done
+
+# append negative control
+grn_name="negative_control"
+cat >> ./params/params_${RUN_ID}.yaml << HERE
+  - id: ${layer}_${grn_name}
+    perturbation_data: resources/grn-benchmark/perturbation_data.h5ad
+    layer: ${layer}
+    prediction: resources/control_models/${grn_name}.csv 
+    reg_type: $reg_type
+    method_id: $grn_name
+    subsample: $subsample
+
+HERE
+# Append the remaining output_state and publish_dir to the YAML file
+cat >> ./params/params_${RUN_ID}.yaml << HERE
+output_state: "state.yaml"
+publish_dir: "$publish_dir"
+HERE
+
+
+
+
+# ./tw-windows-x86_64.exe launch openproblems-bio/task_grn_benchmark \
+#   --revision build/main \
+#   --pull-latest \
+#   --main-script target/nextflow/workflows/process_perturbation/main.nf \
+#   --workspace 53907369739130 \
+#   --compute-env 6TeIFgV5OY4pJCk8I0bfOh \
+#   --params-file ./params/params_${RUN_ID}.yaml \
+#   --config src/common/nextflow_helpers/labels_tw.config
+
+
+
+#   ./tw-windows-x86_64.exe launch openproblems-bio/task_grn_benchmark --revision build/main --pull-latest --main-script target/nextflow/workflows/process_perturbation/main.nf --workspace 53907369739130 --compute-env 6TeIFgV5OY4pJCk8I0bfOh --params-file /tmp/params.yaml --config src/common/nextflow_helpers/labels_tw.config
diff --git a/scripts/run_grn_inference.sh b/scripts/run_grn_inference.sh
deleted file mode 100644
index badcf9cfe..000000000
--- a/scripts/run_grn_inference.sh
+++ /dev/null
@@ -1,48 +0,0 @@
-#!/bin/bash
-
-models_folder="resources/control_models"
-layers=("pearson" "lognorm" "scgen_pearson" "scgen_lognorm" "seurat_pearson" "seurat_lognorm")
-
-# run for negative control
-prediction="$models_folder/negative_control.csv"
-echo $prediction
-viash run src/control_methods/negative_control/config.vsh.yaml -- --perturbation_data resources/grn-benchmark/perturbation_data.h5ad \
-    --prediction $prediction
-
-# run for positive control
-for layer in "${layers[@]}"; do
-  prediction="$models_folder/${layer}_positive_control.csv"
-  echo $prediction
-  viash run src/control_methods/positive_control/config.vsh.yaml -- --perturbation_data resources/grn-benchmark/perturbation_data.h5ad \
-      --layer $layer \
-      --prediction $prediction
-done
-
-
-
-
-
-
-RUN_ID="run_figr_$(date +%Y-%m-%d_%H-%M-%S)"
-resources_dir="s3://openproblems-data/resources/grn"
-publish_dir="s3://openproblems-data/resources/grn/results/${RUN_ID}"
-
-# layers=("pearson","lognorm")
-# predictions=("scenicplus","celloracle")
-cat > /params/params_2.yaml << HERE
-param_list:
-  - id: pearson_scenicplus
-    layer: "lognorm"
-    prediction: resources/grn_models/scenicplus.csv 
-publish_dir: "./"
-output_state: "state.yaml"
-HERE
-
-# tw launch openproblems-bio/task_perturbation_prediction \
-#   --revision build/main \
-#   --pull-latest \
-#   --main-script target/nextflow/workflows/run_benchmark/main.nf \
-#   --workspace 53907369739130 \
-#   --compute-env 6TeIFgV5OY4pJCk8I0bfOh \
-#   --params-file /tmp/params.yaml \
-#   --config src/common/nextflow_helpers/labels_tw.config
diff --git a/src/api/comp_metric.yaml b/src/api/comp_metric.yaml
index 740d37f15..0ba55a4ca 100644
--- a/src/api/comp_metric.yaml
+++ b/src/api/comp_metric.yaml
@@ -7,7 +7,7 @@ functionality:
       summary: A metric to evaluate the performance of the inferred GRN
       description: |
         A metric to evaluate the performance of the inferred GRN
-  arguments:
+  arguments: 
     - name: --perturbation_data
       __merge__: file_perturbation_h5ad.yaml
       required: false
@@ -47,6 +47,11 @@ functionality:
       type: integer
       direction: input
       default: 4
+    - name: --method_id 
+      type: string 
+      direction: input 
+      required: True
+      example: collectri
 
 
       
diff --git a/src/metrics/regression_1/plot_scores.ipynb b/src/metrics/regression_1/plot_scores.ipynb
deleted file mode 100644
index d35567fe0..000000000
--- a/src/metrics/regression_1/plot_scores.ipynb
+++ /dev/null
@@ -1,103 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def headmap(scores, name=''):\n",
-    "    import matplotlib.pyplot as plt\n",
-    "    import numpy as np\n",
-    "    import seaborn\n",
-    "    fig, ax = plt.subplots(1, 1, figsize=(4, 4), sharey=True)\n",
-    "    vmin = np.nanmin(scores)\n",
-    "    vmax = np.nanmax(scores)\n",
-    "\n",
-    "    seaborn.heatmap(scores, ax=ax, square=False, cbar=False, annot=True, fmt='.2f', vmin=vmin, vmax=vmax)\n",
-    "    # Remove only the ticks, keep labels\n",
-    "    ax.tick_params(left=False, bottom=False)\n",
-    "    ax.xaxis.set_tick_params(width=0)\n",
-    "    ax.yaxis.set_tick_params(width=0)\n",
-    "    ax.set_title(name, pad=10)\n",
-    "\n",
-    "\n",
-    "    plt.tight_layout()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 400x400 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 400x400 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import pandas as pd\n",
-    "output_dir = '../../../out'\n",
-    "grn_models = ['celloracle','scenicplus','figr']\n",
-    "\n",
-    "col = 'ex(False)_tf(-1)'\n",
-    "scores = pd.DataFrame()\n",
-    "for grn in grn_models:\n",
-    "    df = pd.read_csv(f\"{output_dir}/{grn}.csv\", index_col=0)\n",
-    "    scores[grn] = df[col]\n",
-    "headmap(scores, name=col)\n",
-    "\n",
-    "col = 'ex(True)_tf(-1)'\n",
-    "scores = pd.DataFrame()\n",
-    "for grn in grn_models:\n",
-    "    df = pd.read_csv(f\"{output_dir}/{grn}.csv\", index_col=0)\n",
-    "    scores[grn] = df[col]\n",
-    "headmap(scores, name=col)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "py10",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.14"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/src/metrics/regression_1/script.py b/src/metrics/regression_1/script.py
index 2a8018994..f7b4bb6ba 100644
--- a/src/metrics/regression_1/script.py
+++ b/src/metrics/regression_1/script.py
@@ -26,11 +26,18 @@
 # print(output)
 # output.to_csv(par['score'])
 
+print(output.values.shape, output.columns.to_numpy().shape)
 output = ad.AnnData(
     X=np.empty((0, 0)),
     uns={
+        "dataset_id": par["layer"],
+        "method_id": f"reg1-{par['method_id']}",
         "metric_ids": output.columns.to_numpy(),
-        "metric_values": output.values
+        "metric_values": output.values[0]
     }
 )
+
+
+# print(output.uns)
+
 output.write_h5ad(par["score"], compression="gzip")
\ No newline at end of file
diff --git a/src/workflows/run_grn_evaluation/config.vsh.yaml b/src/workflows/run_grn_evaluation/config.vsh.yaml
index fe971f6dd..008112be1 100644
--- a/src/workflows/run_grn_evaluation/config.vsh.yaml
+++ b/src/workflows/run_grn_evaluation/config.vsh.yaml
@@ -27,8 +27,12 @@ functionality:
           type: string
           direction: input
           default: ridge
+        - name: --method_id 
+          type: string 
+          direction: input 
+          required: True
+          example: collectri
         
-
     - name: Outputs
       arguments:
         - name: "--scores"
diff --git a/src/workflows/run_grn_evaluation/main.nf b/src/workflows/run_grn_evaluation/main.nf
index 00d51a397..8ab02d581 100644
--- a/src/workflows/run_grn_evaluation/main.nf
+++ b/src/workflows/run_grn_evaluation/main.nf
@@ -35,7 +35,8 @@ workflow run_wf {
         layer: "layer", 
         prediction: "prediction",
         subsample: "subsample",
-        reg_type: "reg_type"
+        reg_type: "reg_type",
+        method_id: "method_id"
       ],
       // use 'toState' to publish that component's outputs to the overall state
       toState: { id, output, state, comp ->