LRP_test _cal_multi_img_acc.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/wangad/anaconda3/envs/test/lib/python3.10/site-packages/torch/cuda/__init__.py:88: UserWarning: CUDA initialization: Unexpected error from cudaGetDeviceCount(). Did you run some cuda functions before calling NumCudaDevices() that might have already set an error? Error 804: forward compatibility was attempted on non supported HW (Triggered internally at /opt/conda/conda-bld/pytorch_1666642969563/work/c10/cuda/CUDAFunctions.cpp:109.)\n",
      "  return torch._C._cuda_getDeviceCount() > 0\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "from torch import from_numpy as from_numpy\n",
    "import os\n",
    "import pickle\n",
    "import copy\n",
    "import edt\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics.cluster import adjusted_rand_score\n",
    "from skimage.metrics import adapted_rand_error\n",
    "import pandas as pd\n",
    "import h5py\n",
    "import time\n",
    "\n",
    "from func.run_pipeline_super_vox import segment_super_vox_2_channel\n",
    "from func.cal_accuracy import IOU_and_Dice_Accuracy, VOI\n",
    "from func.network import CellSegNet_basic_lite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_obj(name ):\n",
    "    with open(name + '.pkl', 'rb') as f:\n",
    "        return pickle.load(f)\n",
    "\n",
    "def save_obj(obj, name):\n",
    "    with open(name + '.pkl', 'wb') as f:\n",
    "        pickle.dump(obj, f, pickle.HIGHEST_PROTOCOL)\n",
    "        \n",
    "data_dict = load_obj(\"data_dict/LRP_data_dict\")\n",
    "data_dict_test = data_dict[\"test\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model=CellSegNet_basic_lite(input_channel=1, n_classes=2, output_func = \"softmax\")\n",
    "load_path='output/model_LRP.pkl'\n",
    "checkpoint = torch.load(load_path)\n",
    "print(checkpoint['model_state_dict'].keys())\n",
    "model.load_state_dict(checkpoint['model_state_dict'])\n",
    "model.eval()\n",
    "\n",
    "device = torch.device('cuda:5' if torch.cuda.is_available() else 'cpu')\n",
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def img_3d_interpolate(img_3d, output_size, device = torch.device('cpu'), mode='nearest'):\n",
    "    img_3d = img_3d.reshape(1,1,img_3d.shape[0],img_3d.shape[1],img_3d.shape[2])\n",
    "    img_3d=torch.from_numpy(img_3d).float().to(device)\n",
    "    img_3d=torch.nn.functional.interpolate(img_3d, size=output_size, mode='nearest')\n",
    "    img_3d=img_3d.detach().cpu().numpy()\n",
    "    img_3d=img_3d.reshape(img_3d.shape[2],img_3d.shape[3],img_3d.shape[4])\n",
    "    \n",
    "    return img_3d\n",
    "\n",
    "def pipeline(raw_img, hand_seg, model, device,\n",
    "             crop_cube_size, stride,\n",
    "             how_close_are_the_super_vox_to_boundary=2,\n",
    "             min_touching_area=30,\n",
    "             min_touching_percentage=0.51,\n",
    "             min_cell_size_threshold=10,\n",
    "             transposes = [[0,1,2],[2,0,1],[0,2,1],[1,0,2]], reverse_transposes = [[0,1,2],[1,2,0],[0,2,1],[1,0,2]]):\n",
    "    \n",
    "    seg_final=segment_super_vox_2_channel(raw_img, model, device,\n",
    "                                          crop_cube_size=crop_cube_size, stride=stride,\n",
    "                                          how_close_are_the_super_vox_to_boundary=how_close_are_the_super_vox_to_boundary,\n",
    "                                          min_touching_area=min_touching_area,\n",
    "                                          min_touching_percentage=min_touching_percentage,\n",
    "                                          min_cell_size_threshold=min_cell_size_threshold,\n",
    "                                          transposes = transposes, reverse_transposes = reverse_transposes)\n",
    "    \n",
    "    unique_vals, counts = np.unique(seg_final, return_counts=True)\n",
    "    locs = np.argsort(counts)\n",
    "    hand_seg_revise = copy.deepcopy(hand_seg)\n",
    "    hand_seg_revise[seg_final==unique_vals[locs[::-1]][0]]=0\n",
    "    \n",
    "    are, precision, recall = adapted_rand_error(hand_seg.astype(np.int).flatten(), seg_final.astype(np.int).flatten())\n",
    "    ari = adjusted_rand_score(hand_seg.flatten(), seg_final.flatten())\n",
    "    voi = VOI(seg_final.astype(np.int),hand_seg.astype(np.int))\n",
    "    \n",
    "    are_revise, precision_revise, recall_revise = adapted_rand_error(hand_seg_revise.astype(np.int).flatten(), seg_final.astype(np.int).flatten())\n",
    "    ari_revise = adjusted_rand_score(hand_seg_revise.flatten(), seg_final.flatten())\n",
    "    voi_revise = VOI(hand_seg_revise.astype(np.int),seg_final.astype(np.int))\n",
    "    \n",
    "    scale_factor = 0.3\n",
    "    org_shape = seg_final.shape\n",
    "    output_size = (int(org_shape[0]*scale_factor), int(org_shape[1]*scale_factor), int(org_shape[2]*scale_factor))\n",
    "    print(str(org_shape)+\" --> \"+str(output_size))\n",
    "    \n",
    "    accuracy=IOU_and_Dice_Accuracy(img_3d_interpolate(hand_seg, output_size = output_size),\n",
    "                                   img_3d_interpolate(seg_final, output_size = output_size))\n",
    "    accuracy_record=accuracy.cal_accuracy_II()\n",
    "    hand_seg_after_accuracy=accuracy.gt\n",
    "    seg_final_after_accuracy=accuracy.pred\n",
    "    \n",
    "    return accuracy_record, hand_seg_after_accuracy, seg_final_after_accuracy, ari, voi, are, precision, recall, seg_final, \\\n",
    "are_revise, precision_revise, recall_revise, ari_revise, voi_revise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# mass process\n",
    "seg_final_dict={}\n",
    "accuracy_record_dict = {}\n",
    "ari_dict = {}\n",
    "voi_dict = {}\n",
    "are_dict = {}\n",
    "ari_revised_dict = {}\n",
    "voi_revised_dict = {}\n",
    "are_revised_dict = {}\n",
    "for test_file in data_dict_test.keys():\n",
    "    print(test_file)\n",
    "    hf = h5py.File(data_dict_test[test_file], 'r')\n",
    "    raw_img = np.array(hf[\"raw\"], dtype=np.float)\n",
    "    hand_seg = np.array(hf[\"ins\"], dtype=np.float)\n",
    "    print(\"raw_img shape: \"+str(raw_img.shape))\n",
    "    print(\"hand_seg shape: \"+str(hand_seg.shape))\n",
    "    \n",
    "    accuracy_record, hand_seg_after_accuracy, seg_final_after_accuracy, ari, voi, are, precision, recall, seg_final, \\\n",
    "    are_revise, precision_revise, recall_revise, ari_revise, voi_revise=\\\n",
    "    pipeline(raw_img, hand_seg, model, device,\n",
    "             crop_cube_size=128,\n",
    "             stride=64)\n",
    "    \n",
    "    seg_final_dict[test_file] = seg_final\n",
    "    accuracy_record_dict[test_file] = accuracy_record\n",
    "    ari_dict[test_file] = ari\n",
    "    voi_dict[test_file] = voi\n",
    "    are_dict[test_file] = (are, precision, recall)\n",
    "    ari_revised_dict[test_file] = ari_revise\n",
    "    voi_revised_dict[test_file] = voi_revise\n",
    "    are_revised_dict[test_file] = (are_revise, precision_revise, recall_revise)\n",
    "    \n",
    "    iou=np.array(accuracy_record[:,1]>0.7, dtype=np.float)\n",
    "    print('cell count accuracy iou >0.7: '+str(sum(iou)/len(iou)))\n",
    "\n",
    "    dice=np.array(accuracy_record[:,2]>0.7, dtype=np.float)\n",
    "    print('cell count accuracy dice >0.7: '+str(sum(dice)/len(dice)))\n",
    "    \n",
    "    iou=np.array(accuracy_record[:,1]>0.5, dtype=np.float)\n",
    "    print('cell count accuracy iou >0.5: '+str(sum(iou)/len(iou)))\n",
    "\n",
    "    dice=np.array(accuracy_record[:,2]>0.5, dtype=np.float)\n",
    "    print('cell count accuracy dice >0.5: '+str(sum(dice)/len(dice)))\n",
    "\n",
    "    print('avg iou: '+str(np.mean(accuracy_record[:,1])))\n",
    "    print('avg dice: '+str(np.mean(accuracy_record[:,2])))\n",
    "    print(\"ari: \"+str(ari))\n",
    "    print(\"are, precision, recall: \"+str((are, precision, recall)))\n",
    "    print(\"voi: \"+str(voi))\n",
    "    print(\"ari_revise: \"+str(ari_revise))\n",
    "    print(\"are_revise, precision_revise, recall_revise: \"+str((are_revise, precision_revise, recall_revise)))\n",
    "    print(\"voi_revise: \"+str(voi_revise))\n",
    "    print(\"----------\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for item in seg_final_dict.keys():\n",
    "    print(item)\n",
    "    accuracy_record = accuracy_record_dict[item]\n",
    "    ari = ari_dict[item]\n",
    "    voi = voi_dict[item]\n",
    "    (are, precision, recall) = are_dict[item]\n",
    "    ari_revise = ari_revised_dict[item]\n",
    "    voi_revise = voi_revised_dict[item]\n",
    "    (are_revise, precision_revise, recall_revise) = are_revised_dict[item]\n",
    "    iou=np.array(accuracy_record[:,1]>0.7, dtype=np.float)\n",
    "    print('cell count accuracy iou >0.7: '+str(sum(iou)/len(iou)))\n",
    "\n",
    "    dice=np.array(accuracy_record[:,2]>0.7, dtype=np.float)\n",
    "    print('cell count accuracy dice >0.7: '+str(sum(dice)/len(dice)))\n",
    "    \n",
    "    iou=np.array(accuracy_record[:,1]>0.5, dtype=np.float)\n",
    "    print('cell count accuracy iou >0.5: '+str(sum(iou)/len(iou)))\n",
    "\n",
    "    dice=np.array(accuracy_record[:,2]>0.5, dtype=np.float)\n",
    "    print('cell count accuracy dice >0.5: '+str(sum(dice)/len(dice)))\n",
    "\n",
    "    print('avg iou: '+str(np.mean(accuracy_record[:,1])))\n",
    "    print('avg dice: '+str(np.mean(accuracy_record[:,2])))\n",
    "    print(\"ari: \"+str(ari))\n",
    "    print(\"are, precision, recall: \"+str((are, precision, recall)))\n",
    "    print(\"voi: \"+str(voi))\n",
    "    print(\"ari_revise: \"+str(ari_revise))\n",
    "    print(\"are_revise, precision_revise, recall_revise: \"+str((are_revise, precision_revise, recall_revise)))\n",
    "    print(\"voi_revise: \"+str(voi_revise))\n",
    "    print(\"----------\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df_show = pd.DataFrame(columns=[\"name\", \"ari\", \"are\", \"are_precision\", \"are_recall\", \"voi_split\", \"voi_merge\",\n",
    "                                \"ari_revise\", \"are_revise\", \"are_precision_revise\", \"are_recall_revise\", \"voi_split_revise\", \"voi_merge_revise\",\n",
    "                                \"avg iou\", \"avg dice\", \"iou>0.7\", \"dice>0.7\", \"iou>0.5\", \"dice>0.5\"])\n",
    "\n",
    "for item in seg_final_dict.keys():\n",
    "    accuracy_record = accuracy_record_dict[item]\n",
    "    ari = ari_dict[item]\n",
    "    voi = voi_dict[item]\n",
    "    (are, precision, recall) = are_dict[item]\n",
    "    ari_revise = ari_revised_dict[item]\n",
    "    voi_revise = voi_revised_dict[item]\n",
    "    (are_revise, precision_revise, recall_revise) = are_revised_dict[item]\n",
    "    iou=np.array(accuracy_record[:,1]>0.7, dtype=np.float)\n",
    "    iou_07 = sum(iou)/len(iou)\n",
    "    dice=np.array(accuracy_record[:,2]>0.7, dtype=np.float)\n",
    "    dice_07 = sum(dice)/len(dice)\n",
    "    iou=np.array(accuracy_record[:,1]>0.5, dtype=np.float)\n",
    "    iou_05 = sum(iou)/len(iou)\n",
    "    dice=np.array(accuracy_record[:,2]>0.5, dtype=np.float)\n",
    "    dice_05 = sum(dice)/len(dice)\n",
    "    avg_iou = np.mean(accuracy_record[:,1])\n",
    "    avg_dice = np.mean(accuracy_record[:,2])\n",
    "    \n",
    "    data={\"name\": item,\n",
    "          \"ari\": ari,\n",
    "          \"are\": are,\n",
    "          \"are_precision\": precision,\n",
    "          \"are_recall\": recall,\n",
    "          \"voi_split\": voi[0],\n",
    "          \"voi_merge\": voi[1],\n",
    "          \"ari_revise\": ari_revise,\n",
    "          \"are_revise\": are_revise,\n",
    "          \"are_precision_revise\": precision_revise,\n",
    "          \"are_recall_revise\": recall_revise,\n",
    "          \"voi_split_revise\": voi_revise[0],\n",
    "          \"voi_merge_revise\": voi_revise[1],\n",
    "          \"avg iou\": avg_iou,\n",
    "          \"avg dice\": avg_dice,\n",
    "          \"iou>0.7\": iou_07,\n",
    "          \"dice>0.7\": dice_07,\n",
    "          \"iou>0.5\": iou_05,\n",
    "          \"dice>0.5\": dice_05}\n",
    "    df_show = df_show.append(data, ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_show.mean()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}