scores.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import os.path as op\n",
    "import nibabel as nib\n",
    "import numpy as np\n",
    "import csv\n",
    "from sklearn.metrics import f1_score, jaccard_score, precision_recall_fscore_support\n",
    "from sklearn.utils import resample\n",
    "from nilearn import maskers\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "deriv_dir = \"./derivatives\"\n",
    "aub_dir = \"./data/aub\"\n",
    "hcp_dir = \"./data/hcp-resampled\"\n",
    "roi_dir = op.join(deriv_dir, \"avg-masks\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "f1_dir = op.join(deriv_dir, \"f1\")\n",
    "icc_dir = op.join(deriv_dir, \"icc\")\n",
    "jac_dir = op.join(deriv_dir, \"jac\")\n",
    "if not op.exists(f1_dir, jac_dir):\n",
    "    os.makedirs(f1_dir, jac_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## F1 Scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1 Score: 0.5762237762237762\n"
     ]
    }
   ],
   "source": [
    "# F1 score with the two average masks\n",
    "# Prepare the CSV file to store the results\n",
    "csv_file_path = op.join(f1_dir, \"f1avg_scores.csv\")\n",
    "\n",
    "with open(csv_file_path, mode=\"w\", newline=\"\") as csv_file:\n",
    "    csv_writer = csv.writer(csv_file)\n",
    "    # Write the header\n",
    "    csv_writer.writerow([\"Subject\", \"F1 Score\"])\n",
    "    file_to_check = op.join(roi_dir, \"aub_dil-hb_avg.nii.gz\")\n",
    "\n",
    "    if op.isfile(file_to_check):\n",
    "        hcp_mask = op.join(roi_dir, \"hcp_dil-hb_avg_resample.nii.gz\")\n",
    "        hcp_nii_image = nib.load(hcp_mask)\n",
    "        hcp_nii_data = hcp_nii_image.get_fdata()\n",
    "        hcp_nii_data = np.where(hcp_nii_data > 0, 1, 0)\n",
    "\n",
    "        aub_nii_image = nib.load(file_to_check)\n",
    "        aub_nii_data = aub_nii_image.get_fdata()\n",
    "\n",
    "        # Convert aub_nii_data to binary\n",
    "        aub_nii_data = np.where(aub_nii_data > 0, 1, 0)\n",
    "\n",
    "        # Ensure both arrays have the same shape\n",
    "        if hcp_nii_data.shape == aub_nii_data.shape:\n",
    "            # Flatten the arrays for F1 score calculation\n",
    "            hcp_flat = hcp_nii_data.flatten()\n",
    "            aub_flat = aub_nii_data.flatten()\n",
    "\n",
    "            # Calculate the F1 score\n",
    "            f1 = f1_score(hcp_flat, aub_flat, average=\"binary\", zero_division=\"warn\")\n",
    "            print(f\"F1 Score: {f1}\")\n",
    "\n",
    "            # Print the shape of the data for reference\n",
    "            # print(\"Shape of the NIfTI data:\", aub_nii_data.shape)\n",
    "\n",
    "            # Find the indices where the value is 1 in aub_nii_data\n",
    "            indices_where_one = np.argwhere(aub_nii_data == 1)\n",
    "\n",
    "            # Print the indices\n",
    "            # print(\"Indices where the value is 1 in aub_nii_data:\")\n",
    "            # print(indices_where_one)\n",
    "            csv_writer.writerow(\n",
    "                [\"subject_id_placeholder\", f1]\n",
    "            )  # Replace \"subject_id_placeholder\" with actual subject ID variable\n",
    "        else:\n",
    "            print(\n",
    "                f\"Shape mismatch: HCP shape {hcp_nii_data.shape}, AUB shape {aub_nii_data.shape}\"\n",
    "            )\n",
    "    else:\n",
    "        print(\"File not found\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Balanced F1 Score: 0.6959459459459459\n"
     ]
    }
   ],
   "source": [
    "# Prepare the CSV file to store the results\n",
    "csv_file_path = op.join(f1_dir, \"f1balancedavg_scores.csv\")\n",
    "\n",
    "with open(csv_file_path, mode=\"w\", newline=\"\") as csv_file:\n",
    "    csv_writer = csv.writer(csv_file)\n",
    "    # Write the header\n",
    "    csv_writer.writerow([\"Subject\", \"F1 Score\"])\n",
    "    file_to_check = op.join(roi_dir, \"aub_dil-hb_avg.nii.gz\")\n",
    "\n",
    "    if op.isfile(file_to_check):\n",
    "        hcp_mask = op.join(roi_dir, \"hcp_dil-hb_avg_resample.nii.gz\")\n",
    "\n",
    "        try:\n",
    "            hcp_nii_image = nib.load(hcp_mask)\n",
    "            hcp_nii_data = hcp_nii_image.get_fdata()\n",
    "            hcp_nii_data = np.where(hcp_nii_data > 0, 1, 0)\n",
    "\n",
    "            aub_nii_image = nib.load(file_to_check)\n",
    "            aub_nii_data = aub_nii_image.get_fdata()\n",
    "            aub_nii_data = np.where(aub_nii_data > 0, 1, 0)\n",
    "\n",
    "            # Ensure both arrays have the same shape\n",
    "            if hcp_nii_data.shape == aub_nii_data.shape:\n",
    "                # Flatten the arrays for F1 score calculation\n",
    "                hcp_flat = hcp_nii_data.flatten()\n",
    "                aub_flat = aub_nii_data.flatten()\n",
    "\n",
    "                # Downsample the majority class in aub_flat (zeros)\n",
    "                aub_flat_1s = aub_flat[aub_flat == 1]\n",
    "                aub_flat_0s = aub_flat[aub_flat == 0]\n",
    "                aub_flat_0s_downsampled = resample(\n",
    "                    aub_flat_0s,\n",
    "                    replace=False,\n",
    "                    n_samples=len(aub_flat_1s),\n",
    "                    random_state=42,\n",
    "                )\n",
    "\n",
    "                # Combine downsampled zeros and ones\n",
    "                aub_flat_balanced = np.concatenate(\n",
    "                    [aub_flat_1s, aub_flat_0s_downsampled]\n",
    "                )\n",
    "\n",
    "                # Ensure the corresponding hcp_flat is also downsampled similarly\n",
    "                hcp_flat_1s = hcp_flat[aub_flat == 1]\n",
    "                hcp_flat_0s = hcp_flat[aub_flat == 0]\n",
    "                hcp_flat_0s_downsampled = resample(\n",
    "                    hcp_flat_0s,\n",
    "                    replace=False,\n",
    "                    n_samples=len(hcp_flat_1s),\n",
    "                    random_state=42,\n",
    "                )\n",
    "\n",
    "                hcp_flat_balanced = np.concatenate(\n",
    "                    [hcp_flat_1s, hcp_flat_0s_downsampled]\n",
    "                )\n",
    "\n",
    "                # Calculate the F1 score on balanced data\n",
    "                f1 = f1_score(\n",
    "                    hcp_flat_balanced,\n",
    "                    aub_flat_balanced,\n",
    "                    average=\"binary\",\n",
    "                    zero_division=\"warn\",\n",
    "                )\n",
    "                print(f\"Balanced F1 Score: {f1}\")\n",
    "\n",
    "                # Replace \"subject_id_placeholder\" with the actual subject ID variable\n",
    "                subject_id = (\n",
    "                    \"subject_id_placeholder\"  # Replace with actual subject ID logic\n",
    "                )\n",
    "                csv_writer.writerow([subject_id, f1])\n",
    "            else:\n",
    "                print(\n",
    "                    f\"Shape mismatch: HCP shape {hcp_nii_data.shape}, AUB shape {aub_nii_data.shape}\"\n",
    "                )\n",
    "        except Exception as e:\n",
    "            print(f\"An error occurred: {e}\")\n",
    "    else:\n",
    "        print(\"File not found\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# F1 precision/recall score with the two average masks\n",
    "# Prepare the CSV file to store the results\n",
    "csv_file_path = op.join(f1_dir, \"fbeta_scores.csv\")\n",
    "\n",
    "with open(csv_file_path, mode=\"w\", newline=\"\") as csv_file:\n",
    "    csv_writer = csv.writer(csv_file)\n",
    "    # Write the header\n",
    "    csv_writer.writerow([\"Subject\", \"F1 Score\"])\n",
    "    file_to_check = op.join(roi_dir, \"aub_dil-hb_avg.nii.gz\")\n",
    "\n",
    "    if op.isfile(file_to_check):\n",
    "        hcp_mask = op.join(roi_dir, \"hcp_dil-hb_avg_resample.nii.gz\")\n",
    "        hcp_nii_image = nib.load(hcp_mask)\n",
    "        hcp_nii_data = hcp_nii_image.get_fdata()\n",
    "        hcp_nii_data = np.where(hcp_nii_data > 0, 1, 0)\n",
    "\n",
    "        aub_nii_image = nib.load(file_to_check)\n",
    "        aub_nii_data = aub_nii_image.get_fdata()\n",
    "\n",
    "        # Convert aub_nii_data to binary\n",
    "        aub_nii_data = np.where(aub_nii_data > 0, 1, 0)\n",
    "\n",
    "        # Ensure both arrays have the same shape\n",
    "        if hcp_nii_data.shape == aub_nii_data.shape:\n",
    "            # Flatten the arrays for F1 score calculation\n",
    "            hcp_flat = hcp_nii_data.flatten()\n",
    "            aub_flat = aub_nii_data.flatten()\n",
    "\n",
    "            # Calculate the F1 score\n",
    "            f1 = precision_recall_fscore_support(\n",
    "                hcp_flat, aub_flat, average=\"binary\", zero_division=\"warn\"\n",
    "            )\n",
    "            print(f\"F1 Score: {f1}\")\n",
    "\n",
    "            # Print the shape of the data for reference\n",
    "            # print(\"Shape of the NIfTI data:\", aub_nii_data.shape)\n",
    "\n",
    "            # Find the indices where the value is 1 in aub_nii_data\n",
    "            indices_where_one = np.argwhere(aub_nii_data == 1)\n",
    "\n",
    "            # Print the indices\n",
    "            # print(\"Indices where the value is 1 in aub_nii_data:\")\n",
    "            # print(indices_where_one)\n",
    "            csv_writer.writerow(\n",
    "                [\"subject_id_placeholder\", f1]\n",
    "            )  # Replace \"subject_id_placeholder\" with actual subject ID variable\n",
    "        else:\n",
    "            print(\n",
    "                f\"Shape mismatch: HCP shape {hcp_nii_data.shape}, AUB shape {aub_nii_data.shape}\"\n",
    "            )\n",
    "    else:\n",
    "        print(\"File not found\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1 Score: 0.2441860465116279\n",
      "F1 Score: 0.08\n",
      "F1 Score: 0.3389830508474576\n",
      "F1 Score: 0.07228915662650602\n",
      "F1 Score: 0.10714285714285714\n",
      "F1 Score: 0.10126582278481013\n",
      "F1 Score: 0.0\n",
      "F1 Score: 0.0\n",
      "F1 Score: 0.3076923076923077\n",
      "File not found in for HIP010\n",
      "F1 Score: 0.2331288343558282\n",
      "File not found in for HIP012\n",
      "F1 Score: 0.2958579881656805\n",
      "F1 Score: 0.3352601156069364\n",
      "F1 Score: 0.23030303030303031\n",
      "F1 Score: 0.3176470588235294\n",
      "F1 Score: 0.08695652173913043\n",
      "F1 Score: 0.30057803468208094\n",
      "File not found in for HIP019\n",
      "File not found in for HIP020\n",
      "F1 Score: 0.29411764705882354\n",
      "F1 Score: 0.2235294117647059\n",
      "F1 Score: 0.2\n",
      "F1 Score: 0.27380952380952384\n",
      "F1 Score: 0.32748538011695905\n",
      "File not found in for HIP026\n",
      "F1 Score: 0.1893491124260355\n",
      "File not found in for HIP028\n",
      "File not found in for HIP029\n",
      "F1 Score: 0.0625\n",
      "F1 Score: 0.0\n",
      "File not found in for HIP032\n",
      "F1 Score: 0.2236024844720497\n",
      "F1 Score: 0.1951219512195122\n"
     ]
    }
   ],
   "source": [
    "# each aub particpant \n",
    "# Prepare the CSV file to store the results\n",
    "csv_file_path = op.join(f1_dir, \"f1_scores.csv\")\n",
    "\n",
    "\n",
    "hcp_mask = op.join(roi_dir, \"hcp_hb_avg_resample.nii.gz\")\n",
    "hcp_nii_image = nib.load(hcp_mask)\n",
    "hcp_nii_data = hcp_nii_image.get_fdata()\n",
    "hcp_nii_data = np.where(hcp_nii_data > 0, 1, 0)\n",
    "\n",
    "with open(csv_file_path, mode=\"w\", newline=\"\") as csv_file:\n",
    "    csv_writer = csv.writer(csv_file)\n",
    "    # Write the header\n",
    "    csv_writer.writerow([\"Subject\", \"F1 Score\"])\n",
    "    for i in range(1, 35):\n",
    "        subject = f\"HIP{i:03}\"\n",
    "        file_to_check = op.join(aub_dir, f\"{subject}_hbmask.nii.gz\")\n",
    "\n",
    "        if op.isfile(file_to_check):\n",
    "            aub_nii_image = nib.load(file_to_check)\n",
    "            aub_nii_data = aub_nii_image.get_fdata()\n",
    "\n",
    "            # Ensure both arrays have the same shape\n",
    "            if hcp_nii_data.shape == aub_nii_data.shape:\n",
    "                # Flatten the arrays for F1 score calculation\n",
    "                hcp_flat = hcp_nii_data.flatten()\n",
    "                aub_flat = aub_nii_data.flatten()\n",
    "\n",
    "                # Calculate the F1 score\n",
    "                f1 = f1_score(\n",
    "                    hcp_flat, aub_flat, average=\"binary\", zero_division=\"warn\"\n",
    "                )\n",
    "                print(f\"F1 Score: {f1}\")\n",
    "\n",
    "                csv_writer.writerow([subject, f1])\n",
    "            else:\n",
    "                print(\n",
    "                    f\"{subject} hape mismatch: HCP shape {hcp_nii_data.shape}, AUB shape {aub_nii_data.shape}\"\n",
    "                )\n",
    "\n",
    "        else:\n",
    "            print(f\"File not found in for {subject}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jaccard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jaccard Score: 0.3088803088803089\n"
     ]
    }
   ],
   "source": [
    "# F1 score with the two average masks\n",
    "# Prepare the CSV file to store the results\n",
    "csv_file_path = op.join(f1_dir, \"jacavg_scores.csv\")\n",
    "\n",
    "with open(csv_file_path, mode=\"w\", newline=\"\") as csv_file:\n",
    "    csv_writer = csv.writer(csv_file)\n",
    "    # Write the header\n",
    "    csv_writer.writerow([\"Subject\", \"Jaccard Score\"])\n",
    "    file_to_check = op.join(roi_dir, \"aub_hb_avg.nii.gz\")\n",
    "\n",
    "    if op.isfile(file_to_check):\n",
    "        hcp_mask = op.join(roi_dir, \"hcp_hb_avg_resample.nii.gz\")\n",
    "        hcp_nii_image = nib.load(hcp_mask)\n",
    "        hcp_nii_data = hcp_nii_image.get_fdata()\n",
    "        hcp_nii_data = np.where(hcp_nii_data > 0, 1, 0)\n",
    "\n",
    "        aub_nii_image = nib.load(file_to_check)\n",
    "        aub_nii_data = aub_nii_image.get_fdata()\n",
    "\n",
    "        # Convert aub_nii_data to binary\n",
    "        aub_nii_data = np.where(aub_nii_data > 0, 1, 0)\n",
    "\n",
    "        # Ensure both arrays have the same shape\n",
    "        if hcp_nii_data.shape == aub_nii_data.shape:\n",
    "            # Flatten the arrays for F1 score calculation\n",
    "            hcp_flat = hcp_nii_data.flatten()\n",
    "            aub_flat = aub_nii_data.flatten()\n",
    "\n",
    "            # Calculate the F1 score\n",
    "            jac = jaccard_score(\n",
    "                hcp_flat, aub_flat, average=\"binary\", zero_division=\"warn\"\n",
    "            )\n",
    "            print(f\"Jaccard Score: {jac}\")\n",
    "\n",
    "            # Print the shape of the data for reference\n",
    "            # print(\"Shape of the NIfTI data:\", aub_nii_data.shape)\n",
    "\n",
    "            # Find the indices where the value is 1 in aub_nii_data\n",
    "            indices_where_one = np.argwhere(aub_nii_data == 1)\n",
    "\n",
    "            # Print the indices\n",
    "            # print(\"Indices where the value is 1 in aub_nii_data:\")\n",
    "            # print(indices_where_one)\n",
    "            csv_writer.writerow(\n",
    "                [\"subject_id_placeholder\", jac]\n",
    "            )  # Replace \"subject_id_placeholder\" with actual subject ID variable\n",
    "        else:\n",
    "            print(\n",
    "                f\"Shape mismatch: HCP shape {hcp_nii_data.shape}, AUB shape {aub_nii_data.shape}\"\n",
    "            )\n",
    "    else:\n",
    "        print(\"File not found\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DSC Scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dsc Score: 0.2441860465116279\n",
      "Subject: HIP001, DSC: 0.2441860465116279\n",
      "dsc Score: 0.07999999999999996\n",
      "Subject: HIP002, DSC: 0.07999999999999996\n",
      "dsc Score: 0.3389830508474576\n",
      "Subject: HIP003, DSC: 0.3389830508474576\n",
      "dsc Score: 0.07228915662650603\n",
      "Subject: HIP004, DSC: 0.07228915662650603\n",
      "dsc Score: 0.1071428571428571\n",
      "Subject: HIP005, DSC: 0.1071428571428571\n",
      "dsc Score: 0.10126582278481011\n",
      "Subject: HIP006, DSC: 0.10126582278481011\n",
      "dsc Score: 0.0\n",
      "Subject: HIP007, DSC: 0.0\n",
      "dsc Score: 0.0\n",
      "Subject: HIP008, DSC: 0.0\n",
      "dsc Score: 0.3076923076923077\n",
      "Subject: HIP009, DSC: 0.3076923076923077\n",
      "File not found in for HIP010\n",
      "dsc Score: 0.2331288343558282\n",
      "Subject: HIP011, DSC: 0.2331288343558282\n",
      "File not found in for HIP012\n",
      "dsc Score: 0.29585798816568043\n",
      "Subject: HIP013, DSC: 0.29585798816568043\n",
      "dsc Score: 0.33526011560693647\n",
      "Subject: HIP014, DSC: 0.33526011560693647\n",
      "dsc Score: 0.23030303030303034\n",
      "Subject: HIP015, DSC: 0.23030303030303034\n",
      "dsc Score: 0.3176470588235294\n",
      "Subject: HIP016, DSC: 0.3176470588235294\n",
      "dsc Score: 0.08695652173913049\n",
      "Subject: HIP017, DSC: 0.08695652173913049\n",
      "dsc Score: 0.3005780346820809\n",
      "Subject: HIP018, DSC: 0.3005780346820809\n",
      "File not found in for HIP019\n",
      "File not found in for HIP020\n",
      "dsc Score: 0.2941176470588235\n",
      "Subject: HIP021, DSC: 0.2941176470588235\n",
      "dsc Score: 0.22352941176470587\n",
      "Subject: HIP022, DSC: 0.22352941176470587\n",
      "dsc Score: 0.19999999999999996\n",
      "Subject: HIP023, DSC: 0.19999999999999996\n",
      "dsc Score: 0.27380952380952384\n",
      "Subject: HIP024, DSC: 0.27380952380952384\n",
      "dsc Score: 0.32748538011695905\n",
      "Subject: HIP025, DSC: 0.32748538011695905\n",
      "File not found in for HIP026\n",
      "dsc Score: 0.18934911242603547\n",
      "Subject: HIP027, DSC: 0.18934911242603547\n",
      "File not found in for HIP028\n",
      "File not found in for HIP029\n",
      "dsc Score: 0.0625\n",
      "Subject: HIP030, DSC: 0.0625\n",
      "dsc Score: 0.0\n",
      "Subject: HIP031, DSC: 0.0\n",
      "File not found in for HIP032\n",
      "dsc Score: 0.22360248447204967\n",
      "Subject: HIP033, DSC: 0.22360248447204967\n",
      "dsc Score: 0.19512195121951215\n",
      "Subject: HIP034, DSC: 0.19512195121951215\n"
     ]
    }
   ],
   "source": [
    "# Prepare the CSV file to store the results\n",
    "csv_file_path = op.join(f1_dir, \"ddc_scores.csv\")\n",
    "\n",
    "with open(csv_file_path, mode=\"w\", newline=\"\") as csv_file:\n",
    "    csv_writer = csv.writer(csv_file)\n",
    "    # Write the header\n",
    "    csv_writer.writerow([\"Subject\", \"DSC Score\"])\n",
    "    for i in range(1, 35):\n",
    "        subject = f\"HIP{i:03}\"\n",
    "        file_to_check = op.join(aub_dir, f\"{subject}_hbmask.nii.gz\")\n",
    "\n",
    "        if op.isfile(file_to_check):\n",
    "            aub_nii_image = nib.load(file_to_check)\n",
    "            aub_nii_data = aub_nii_image.get_fdata()\n",
    "\n",
    "\n",
    "            # Ensure both arrays have the same shape\n",
    "            if hcp_nii_data.shape == aub_nii_data.shape:\n",
    "                # Flatten the arrays for F1 score calculation\n",
    "                hcp_flat = hcp_nii_data.flatten()\n",
    "                aub_flat = aub_nii_data.flatten()\n",
    "\n",
    "                # Calculate the dsc score\n",
    "                ddc = float(dice(hcp_flat, aub_flat))\n",
    "\n",
    "                dsc = 1 - ddc\n",
    "                print(f\"dsc Score: {dsc}\")\n",
    "\n",
    "                print(f\"Subject: {subject}, DSC: {dsc}\")\n",
    "\n",
    "                # Write the results to the CSV file\n",
    "                csv_writer.writerow([subject, dsc])\n",
    "            else:\n",
    "                print(\n",
    "                    f\"{subject} hape mismatch: HCP shape {hcp_nii_data.shape}, AUB shape {aub_nii_data.shape}\"\n",
    "                )\n",
    "\n",
    "        else:\n",
    "            print(f\"File not found in for {subject}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Plot saved to ./derivatives/f1/scores_comparison.png\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "# Paths to the CSV files\n",
    "dsc_csv_path = op.join(f1_dir, \"dsc_scores.csv\")\n",
    "f1_csv_path = op.join(f1_dir, \"f1_scores.csv\")\n",
    "\n",
    "# Read the DSC and F1 CSV files into pandas DataFrames\n",
    "dsc_df = pd.read_csv(dsc_csv_path)\n",
    "f1_df = pd.read_csv(f1_csv_path)\n",
    "\n",
    "# Merge the DataFrames on the \"Subject\" column using an outer op.join\n",
    "combined_df = pd.merge(dsc_df, f1_df, on=\"Subject\", how=\"outer\")\n",
    "\n",
    "# Print the combined DataFrame to ensure it is correct\n",
    "#print(combined_df)\n",
    "\n",
    "# Initialize the matplotlib figure\n",
    "plt.figure(figsize=(12, 6))\n",
    "\n",
    "# Plot the DSC scores\n",
    "sns.barplot(\n",
    "    x=\"Subject\",\n",
    "    y=\"DSC Score\",\n",
    "    data=combined_df,\n",
    "    label=\"DSC Score\",\n",
    "    color=\"b\",\n",
    "    alpha=0.6,\n",
    ")\n",
    "\n",
    "# Plot the F1 scores\n",
    "sns.barplot(\n",
    "    x=\"Subject\", y=\"F1 Score\", data=combined_df, label=\"F1 Score\", color=\"r\", alpha=0.6\n",
    ")\n",
    "\n",
    "# Add a legend and informative axis labels\n",
    "plt.legend(ncol=2, loc=\"upper right\", frameon=True)\n",
    "plt.ylabel(\"Scores\")\n",
    "plt.xlabel(\"Subject\")\n",
    "plt.title(\"DSC and F1 Scores by Subject\")\n",
    "\n",
    "# Set y-axis limits\n",
    "plt.ylim(0, 1)\n",
    "\n",
    "# Add horizontal lines at y = 0.75 and y = 0.9 with labels\n",
    "plt.axhline(y=0.75, color=\"red\", linestyle=\"--\")\n",
    "plt.text(-0.5, 0.77, \"Baseline Score\", color=\"red\", fontsize=12, va=\"bottom\")\n",
    "plt.axhline(y=0.9, color=\"green\", linestyle=\"--\")\n",
    "plt.text(-0.5, 0.92, \"Optimal Score\", color=\"green\", fontsize=12, va=\"bottom\")\n",
    "\n",
    "# Rotate the x labels for better readability\n",
    "plt.xticks(rotation=90)\n",
    "\n",
    "# Show the plot\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# Save the plot if needed\n",
    "plot_path = op.join(f1_dir, \"scores_comparison.png\")\n",
    "plt.savefig(plot_path)\n",
    "print(f\"Plot saved to {plot_path}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}