From 2cc91783df8fffaf949e97bd880dc01e72cb1490 Mon Sep 17 00:00:00 2001 From: wangjunang Date: Thu, 21 Mar 2024 14:53:59 +0800 Subject: [PATCH] tune v5 and plot v1 --- .vscode/settings.json | 5 + Modeling eMNS/Generative_model_v2.ipynb | 406 ++++++++++++++++-- Modeling eMNS/Neural_network.py | 6 +- Modeling eMNS/Training_loop_v2.py | 182 ++------ Modeling eMNS/utils.py | 203 ++++++++- .../mcr_radiologyInstrumentDOFs.py | 8 - 6 files changed, 599 insertions(+), 211 deletions(-) create mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 00000000..edbfa7b0 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,5 @@ +{ + "cSpell.words": [ + "denorm" + ] +} \ No newline at end of file diff --git a/Modeling eMNS/Generative_model_v2.ipynb b/Modeling eMNS/Generative_model_v2.ipynb index 5b4e4e5e..8fa372ba 100644 --- a/Modeling eMNS/Generative_model_v2.ipynb +++ b/Modeling eMNS/Generative_model_v2.ipynb @@ -18,9 +18,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using cpu\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/qubot/.pyenv/versions/3.10.13/lib/python3.10/site-packages/torch/cuda/__init__.py:628: UserWarning: Can't initialize NVML\n", + " warnings.warn(\"Can't initialize NVML\")\n" + ] + } + ], "source": [ "%reload_ext autoreload\n", "%autoreload 2\n", @@ -38,9 +54,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([146, 6, 21, 21, 21])\n", + "current shape torch.Size([146, 12])\n", + "Bfield shape torch.Size([146, 3, 16, 16, 16])\n" + ] + } + ], "source": [ "from ReadData import ReadCurrentAndField_CNN\n", "import glob\n", @@ -50,7 +76,7 @@ "# print(os.getcwd())\n", "foldername=\"./Data/\"\n", "filepattern = \"MagneticField[0-9]*.txt\"\n", - "train_file_num= 1400\n", + "train_file_num= 146\n", "#data = ReadFolder(foldername,filepattern)\n", "current,data = ReadCurrentAndField_CNN (foldername,filepattern,train_file_num)\n", "\n", @@ -108,13 +134,188 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + "
\n", + "

Tune Status

\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Current time:2024-03-21 11:57:19
Running for: 00:00:43.56
Memory: 10.8/31.0 GiB
\n", + "
\n", + "
\n", + "
\n", + "

System Info

\n", + " Using FIFO scheduling algorithm.
Logical resource usage: 2.0/16 CPUs, 0/0 GPUs\n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "

Trial Status

\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Trial name status loc iter total time (s) rmse_val rmse_train loss
TorchTrainer_0385f_00000TERMINATED192.168.8.117:20581 10 38.5563 3.16977 2.374340.0456446
\n", + "
\n", + "
\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[36m(TorchTrainer pid=20581)\u001b[0m Started distributed worker processes: \n", + "\u001b[36m(TorchTrainer pid=20581)\u001b[0m - (ip=192.168.8.117, pid=20651) world_rank=0, local_rank=0, node_rank=0\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Setting up process group for: env:// [rank=0, world_size=1]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Epoch 0, Iteration 16, loss = 0.1583, l1 loss=0.1200, grad loss=0.0383\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 9.797602653503418\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Checkpoint successfully created at: Checkpoint(filesystem=local, path=/home/qubot/Trained_model/EMS_CNN_s_2r_1b_3/TorchTrainer_0385f_00000_0_2024-03-21_11-56-36/checkpoint_000000)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 8.676706314086914\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-03-21 11:56:48,192\tWARNING experiment_state.py:323 -- Experiment checkpoint syncing has been triggered multiple times in the last 30.0 seconds. A sync will be triggered whenever a trial has checkpointed more than `num_to_keep` times since last sync or if 300 seconds have passed since last sync. If you have set `num_to_keep` in your `CheckpointConfig`, consider increasing the checkpoint frequency or keeping more checkpoints. You can supress this warning by changing the `TUNE_WARN_EXCESSIVE_EXPERIMENT_CHECKPOINT_SYNC_THRESHOLD_S` environment variable.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Epoch 1, Iteration 32, loss = 0.1101, l1 loss=0.0793, grad loss=0.0308\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 6.467669486999512\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 5.52919864654541\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m \n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Epoch 2, Iteration 48, loss = 0.0885, l1 loss=0.0615, grad loss=0.0270\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 5.83610725402832\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 4.7611260414123535\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m \n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Epoch 3, Iteration 64, loss = 0.0745, l1 loss=0.0504, grad loss=0.0241\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 4.861945152282715\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 4.036675930023193\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m \n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Epoch 4, Iteration 80, loss = 0.0710, l1 loss=0.0473, grad loss=0.0238\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 4.330577373504639\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 3.654207944869995\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m \n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Epoch 5, Iteration 96, loss = 0.0633, l1 loss=0.0413, grad loss=0.0219\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 3.7916672229766846\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 3.040168285369873\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m \n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Epoch 6, Iteration 112, loss = 0.0529, l1 loss=0.0326, grad loss=0.0203\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 3.4171268939971924\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 2.6344687938690186\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m \n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Epoch 7, Iteration 128, loss = 0.0482, l1 loss=0.0292, grad loss=0.0191\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 3.147188186645508\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 2.4714787006378174\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m \n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Epoch 8, Iteration 144, loss = 0.0521, l1 loss=0.0321, grad loss=0.0200\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 3.2194416522979736\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 2.39068865776062\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m \n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Epoch 9, Iteration 160, loss = 0.0456, l1 loss=0.0271, grad loss=0.0186\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 3.169771194458008\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Checkpoint successfully created at: Checkpoint(filesystem=local, path=/home/qubot/Trained_model/EMS_CNN_s_2r_1b_3/TorchTrainer_0385f_00000_0_2024-03-21_11-56-36/checkpoint_000001)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m Got rmse 2.3743371963500977\n", + "\u001b[36m(RayTrainWorker pid=20651)\u001b[0m \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-03-21 11:57:19,905\tWARNING experiment_state.py:323 -- Experiment checkpoint syncing has been triggered multiple times in the last 30.0 seconds. A sync will be triggered whenever a trial has checkpointed more than `num_to_keep` times since last sync or if 300 seconds have passed since last sync. If you have set `num_to_keep` in your `CheckpointConfig`, consider increasing the checkpoint frequency or keeping more checkpoints. You can supress this warning by changing the `TUNE_WARN_EXCESSIVE_EXPERIMENT_CHECKPOINT_SYNC_THRESHOLD_S` environment variable.\n", + "2024-03-21 11:57:19,911\tINFO tune.py:1042 -- Total run time: 43.58 seconds (42.73 seconds for the tuning loop).\n" + ] + } + ], "source": [ - "from Neural_network import Generative_net, Generative_net_test, ResidualEMNSBlock_3d, BigBlock, weight_init, eMNS_Dataset\n", - "from Training_loop_v2 import train_GM, train_GM_ray\n", - "from functools import partial\n", + "from Neural_network import eMNS_Dataset\n", + "from Training_loop_v2 import train_GM\n", "from ray.train import RunConfig, ScalingConfig, CheckpointConfig\n", "from ray.train.torch import TorchTrainer\n", "from ray.tune.tuner import Tuner\n", @@ -124,11 +325,11 @@ "\n", "# construct dataset\n", "dataset = eMNS_Dataset(\n", - " train_x=current,\n", - " train_y=Bfield\n", + " x=current,\n", + " y=Bfield\n", ")\n", "# split the dataset to train, validation, test\n", - "train_set, valid_set = torch.utils.data.random_split(dataset, [0.9,0.1])\n", + "train_set, valid_set, test_set = torch.utils.data.random_split(dataset, [0.85,0.1,0.05])\n", "\n", "# normailzation\n", "extremes = dataset.train_norm(train_indices = train_set.indices)\n", @@ -144,7 +345,7 @@ " \"scaling_config\": ScalingConfig(\n", " num_workers = 1,\n", " use_gpu = use_gpu,\n", - " resources_per_worker = {\"CPU\":4, \"GPU\":1}\n", + " resources_per_worker = {\"CPU\":4, \"GPU\":0}\n", " ),\n", " # You can even grid search various datasets in Tune.\n", " # \"datasets\": {\n", @@ -170,6 +371,7 @@ " 'minB' : extremes[3],\n", " 'train_set' : train_set,\n", " 'valid_set' : valid_set,\n", + " 'num_input' : 12,\n", " }\n", "\n", "}\n", @@ -188,8 +390,8 @@ "################################################\n", "\n", "train_loop_config = {\n", - " 'epochs': 350,\n", - " 'lr_max': 1e-4,\n", + " 'epochs': 10,\n", + " 'lr_max': 5e-4,\n", " 'lr_min': 2.5e-6,\n", " 'batch_size': 8,\n", " 'L2_norm' : 0,\n", @@ -198,14 +400,15 @@ " 'schedule': [],\n", " 'grid_space': 16**3,\n", " 'learning_rate_decay': 0.5,\n", - " 'skip_spacing': 1,\n", - " 'num_repeat' : 4,\n", - " 'num_block' : 2,\n", + " 'skip_spacing': 2,\n", + " 'num_repeat' : 1,\n", + " 'num_block' : 3,\n", " 'maxB' : extremes[2],\n", " 'minB' : extremes[3],\n", " 'device' : device,\n", " 'train_set' : train_set,\n", - " 'valid_set' : valid_set\n", + " 'valid_set' : valid_set,\n", + " 'num_input' : 12,\n", " # You can even grid search various datasets in Tune.\n", " # \"datasets\": tune.grid_search(\n", " # [ds1, ds2]\n", @@ -218,7 +421,8 @@ " # resources_per_worker = {\"CPU\":4, \"GPU\":1}\n", ")\n", "\n", - "run_config = RunConfig(checkpoint_config=CheckpointConfig(num_to_keep=1))\n", + "run_config = RunConfig(checkpoint_config=CheckpointConfig(num_to_keep=1),storage_path='~/Trained_model', \n", + " name='EMS_CNN_'+'s_'+str(train_loop_config['skip_spacing'])+'r_'+str(train_loop_config['num_repeat'])+'b_'+str(train_loop_config['num_block']) )\n", "\n", "# def train_loop_per_worker(params):\n", "# train_GM(train_set=train_set, valid_set=valid_set, device=device, config=params)\n", @@ -230,37 +434,74 @@ " run_config = run_config,\n", "\n", ")\n", - "\n", - "# result = trainer.fit()\n", - "tuner = tune.Tuner(\n", - " trainer,\n", - " param_space = param_space,\n", - " tune_config =tune.TuneConfig(\n", - " scheduler=tune_schedule,\n", - " num_samples=1, # number of samples of hyperparameter space\n", - " ),\n", - " # run_config = RunConfig(storage_path=\"./results\", name=\"test_experiment\")\n", - ")\n", - " \n", - "results = tuner.fit()" + "# train the model\n", + "result = trainer.fit()\n", + "#----------------------------------------------\n", + "# tuner = tune.Tuner(\n", + "# trainer,\n", + "# param_space = param_space,\n", + "# tune_config =tune.TuneConfig(\n", + "# scheduler=tune_schedule,\n", + "# num_samples=1, # number of samples of hyperparameter space\n", + "# ),\n", + "# # run_config = RunConfig(checkpoint_config=CheckpointConfig(num_to_keep=2),storage_path=\"/home/qubot/ray_results\", name=\"test_experiment\"),\n", + " # checkpoint_score_attribute='rmse_val', checkpoint_score_order='min\n", + "# )\n", + "# # tune the model \n", + "# results = tuner.fit()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 44, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Result(\n", + " metrics={'rmse_val': 3.169771194458008, 'rmse_train': 2.3743371963500977, 'loss': 0.045644618570804596},\n", + " path='/home/qubot/Trained_model/EMS_CNN_s_2r_1b_3/TorchTrainer_0385f_00000_0_2024-03-21_11-56-36',\n", + " filesystem='local',\n", + " checkpoint=Checkpoint(filesystem=local, path=/home/qubot/Trained_model/EMS_CNN_s_2r_1b_3/TorchTrainer_0385f_00000_0_2024-03-21_11-56-36/checkpoint_000001)\n", + ")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "print(torch.device(type='cuda', index=0))\n", - "print(ray.train.torch.get_device())\n", - "print(torch.device('cuda:0'))" + "from utils import plot_ray_results\n", + "print(result)\n", + "plot_ray_results(result, metrics_names=['rmse_train','rmse_val'],ylim=[1,5])" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'Result' object has no attribute 'get_best_result'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[7], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m best_result \u001b[38;5;241m=\u001b[39m \u001b[43mresults\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_best_result\u001b[49m(metric\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mrmse_val\u001b[39m\u001b[38;5;124m'\u001b[39m,mode\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmin\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(best_result)\n", + "\u001b[0;31mAttributeError\u001b[0m: 'Result' object has no attribute 'get_best_result'" + ] + } + ], "source": [ "best_result = results.get_best_result(metric='rmse_val',mode='min')\n", "print(best_result)" @@ -282,16 +523,88 @@ "metadata": {}, "outputs": [], "source": [ - "plot_ray_results(results, metrics_names=['rmse_train','rmse_val'],ylim=[0,1])" + "!tensorboard --logdir=~/ray_results" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 92, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Got rmse 2.705864906311035\n", + "rmse for test set: 2.7059mT\n", + " mse for test set: 7.3217mT\n", + " R2 for test set: 0.9840\n", + "plot sample rmse: 2.2255mT\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "!tensorboard --logdir=~/ray_results" + "\n", + "from utils import estimate_test_set \n", + "test_estimator = estimate_test_set(result.checkpoint, test_set, train_loop_config)\n", + "test_estimator.fit()\n", + "test_estimator.peek_z(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([16])\n", + "torch.Size([3, 16, 16, 16])\n", + "torch.Size([3, 16, 16, 16])\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "test_estimator.peek_3D(length=0.15)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Old version of training loop" ] }, { @@ -325,6 +638,7 @@ " 'num_repeat' : 2,\n", " 'num_block' : 3,\n", " 'device' : device,\n", + " 'num_input' : 12,\n", "}\n", "train_percents = np.arange(1.0,1.01,0.1)\n", "RMSE_history_end = np.zeros(len(train_percents))\n", @@ -453,7 +767,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.10.13" } }, "nbformat": 4, diff --git a/Modeling eMNS/Neural_network.py b/Modeling eMNS/Neural_network.py index b3096553..123ff4a4 100644 --- a/Modeling eMNS/Neural_network.py +++ b/Modeling eMNS/Neural_network.py @@ -5,10 +5,10 @@ import numpy as np # set up dataset class class eMNS_Dataset(torch.utils.data.Dataset): - def __init__(self,train_x,train_y): + def __init__(self,x,y): #data loading - self.x = train_x - self.y = train_y + self.x = x + self.y = y self.n_samples = self.x.shape[0] diff --git a/Modeling eMNS/Training_loop_v2.py b/Modeling eMNS/Training_loop_v2.py index 24420075..4c99da53 100644 --- a/Modeling eMNS/Training_loop_v2.py +++ b/Modeling eMNS/Training_loop_v2.py @@ -5,7 +5,7 @@ from torch.nn.parallel import DistributedDataParallel import torch.nn.functional as F from early_stopping import EarlyStopping, EarlyDecay -from utils import compute_discrete_curl, denorm, max_min_norm, denorm_ray +from utils import Jacobian3, grad_loss_Jacobain, check_rmse_CNN, compute_discrete_curl, compute_discrete_divergence, grad_loss, get_mean_of_dataloader, gridData_reshape from Neural_network import ResidualEMNSBlock_3d, BigBlock, Generative_net import numpy as np import ray @@ -84,7 +84,6 @@ def train_GM(config): """ #---------------unpack config--------------------- # print(config) - batch_size = config['batch_size'] epochs = config["epochs"] verbose = config['verbose'] lr_max = config['lr_max'] @@ -95,9 +94,6 @@ def train_GM(config): learning_rate_decay = config['learning_rate_decay'] maxB = config['maxB'] minB = config['minB'] - skip_spacing = config['skip_spacing'] - num_repeat = config['num_repeat'] - num_block = config['num_block'] device = config['device'] train_set = config['train_set'] valid_set = config['valid_set'] @@ -105,15 +101,7 @@ def train_GM(config): #################################################### #--------------model construction------------------ #################################################### - num_input = 12 - output_shape = (3,16,16,16) - SB_args = (64,64,skip_spacing,num_repeat) # (Cin, Cout, skip_spacing, num_repeat) - BB_args = (2,num_block) # (scale_factor, num_block) - SB_block = ResidualEMNSBlock_3d - BB_block = BigBlock - - - model = Generative_net(SB_args, BB_args, SB_block, BB_block, num_input=num_input, output_shape= output_shape) + model = construct_model_GM(config) @@ -226,20 +214,24 @@ def train_GM(config): print() adjust_epoch_count += 1 - # # create checkpoint - # base_model = (model.module - # if isinstance(model, DistributedDataParallel) else model) - # checkpoint_dir = tempfile.mkdtemp() - # # load back training state - # checkpoint_data = { - # "epoch": epoch, - # "net_state_dict": base_model.state_dict(), - # "optimizer_state_dict": optimizer.state_dict(), - # } - # torch.save(checkpoint_data, os.path.join(checkpoint_dir, "model.pt")) - # checkpoint = Checkpoint.from_directory(checkpoint_dir) - #Send the current training result back to Tune - train.report({'rmse_val':rmse_val.item(), 'rmse_train': rmse.item(), 'loss':loss.item()}) + if epoch % (epochs-1) == 0: + # create checkpoint only at the begin and the end of epochs + base_model = (model.module + if isinstance(model, DistributedDataParallel) else model) + checkpoint_dir = tempfile.mkdtemp() + # load back training state + checkpoint_data = { + "epoch": epoch, + "net_state_dict": base_model.state_dict(), + 'model': base_model + # "optimizer_state_dict": optimizer.state_dict(), + } + torch.save(checkpoint_data, os.path.join(checkpoint_dir, "model.pt")) + checkpoint = Checkpoint.from_directory(checkpoint_dir) + # Send the current training result back to Tune + train.report({'rmse_val':rmse_val.item(), 'rmse_train': rmse.item(), 'loss':loss.item()},checkpoint=checkpoint) + else: + train.report({'rmse_val':rmse_val.item(), 'rmse_train': rmse.item(), 'loss':loss.item()}) @@ -250,131 +242,23 @@ def train_GM(config): return rmse_history, rmse_val_history,loss_history, iter_history,mse_history, mse_val_history,epoch_stop,Rsquare #------------------------------------------------------------------------------------------------------- +def construct_model_GM(config): + num_input = config['num_input'] + skip_spacing = config['skip_spacing'] + num_repeat = config['num_repeat'] + num_block = config['num_block'] + output_shape = (3,16,16,16) + SB_args = (64,64,skip_spacing,num_repeat) # (Cin, Cout, skip_spacing, num_repeat) + BB_args = (2,num_block) # (scale_factor, num_block) + SB_block = ResidualEMNSBlock_3d + BB_block = BigBlock + model = Generative_net(SB_args, BB_args, SB_block, BB_block, num_input=num_input, output_shape= output_shape) + return model -def get_mean_of_dataloader(dataloader,model,device): - num_samples = 0 - b = torch.zeros(1,device=device) - model.eval() - for x,y in dataloader: - y = y.to(device=device,dtype=torch.float) - # use sum instead of mean, what do you think? - y_sum = y.sum(dim=0,keepdim=True) - num_samples += y.shape[0] - # print(y.shape[0]) - b =b+y_sum - return b/num_samples - - -def check_rmse_CNN(dataloader,model, grid_space, device, DF, maxB=[],minB=[]): - ''' - Check RMSE of CNN - ''' - mse_temp = 0 - R_temp=0 - Rsquare=0 - num_samples = 0 - # print(Bfield_mean) - - data = next(iter(dataloader)) - mean = data[0].mean() - - Bfield_mean=get_mean_of_dataloader(dataloader,model,device) - - model.eval() # set model to evaluation model - - with torch.no_grad(): - for x,y in dataloader: - x = x.to(device=device,dtype=torch.float) - y = y.to(device=device,dtype=torch.float) - num_samples += x.shape[0] - if DF: - _, scores = Jacobian3(model(x)) - else: - scores = model(x) - - # compute mse and R2 by de-normalize data - mse_temp += F.mse_loss(1e3*denorm(scores,maxB,minB,device), 1e3*denorm(y,maxB,minB, device) ,reduction='sum') - R_temp += F.mse_loss(1e3*denorm(Bfield_mean.expand_as(y),maxB,minB,device), 1e3*denorm(y,maxB,minB,device), reduction='sum') - - - rmse = torch.sqrt(mse_temp/num_samples/grid_space/3) - - Rsquare=1-mse_temp/R_temp/num_samples - print(f'Got rmse {rmse}') - - - - - return rmse, mse_temp/num_samples/grid_space/3, Rsquare #----------------------------------------------------------------- -#---------------------------------------------------------------- -def grad_loss(preds, y): - ''' - preds, y shape: (batch, dimension, grid_x, grid_y, grid_z) - This function computes lamda_g*| nabla(y) - nabla(preds)| - ''' - grad_preds = torch.gradient(preds,spacing=1.0) - grad_y = torch.gradient(y, spacing=1) - grad_loss = 0 - for i in range(2,5): - # accumulate grad loss for grad_x,y,z - grad_loss += torch.mean(torch.abs(grad_y[i]-grad_preds[i]))/3 - return grad_loss - -def grad_loss_Jacobain(preds,y): - ''' - preds, y shape: (batch, dimension, grid_x, grid_y, grid_z) - This function computes lamda_g*| nabla(y) - nabla(preds)| by Jacobian - ''' - Jaco_preds,_ = Jacobian3(preds) - Jaco_y ,_ = Jacobian3(y) - - grad_loss = torch.mean(torch.abs(Jaco_preds - Jaco_y)) - - return grad_loss - - -def Jacobian3(x): - ''' - Jacobian for 3D vector field - -------input---------- - x shape: (batch, dimension,grid_x, grid_y, grid_z) - ''' - - dudx = x[:, 0, 1:, :, :] - x[:, 0, :-1, :, :] - dvdx = x[:, 1, 1:, :, :] - x[:, 1, :-1, :, :] - dwdx = x[:, 2, 1:, :, :] - x[:, 2, :-1, :, :] - - dudy = x[:, 0, :, 1:, :] - x[:, 0, :, :-1, :] - dvdy = x[:, 1, :, 1:, :] - x[:, 1, :, :-1, :] - dwdy = x[:, 2, :, 1:, :] - x[:, 2, :, :-1, :] - - dudz = x[:, 0, :, :, 1:] - x[:, 0, :, :, :-1] - dvdz = x[:, 1, :, :, 1:] - x[:, 1, :, :, :-1] - dwdz = x[:, 2, :, :, 1:] - x[:, 2, :, :, :-1] - - dudx = torch.cat((dudx, torch.unsqueeze(dudx[:,-1],dim=1)), dim=1) - dvdx = torch.cat((dvdx, torch.unsqueeze(dvdx[:,-1],dim=1)), dim=1) - dwdx = torch.cat((dwdx, torch.unsqueeze(dwdx[:,-1],dim=1)), dim=1) - - dudy = torch.cat((dudy, torch.unsqueeze(dudy[:,:,-1],dim=2)), dim=2) - dvdy = torch.cat((dvdy, torch.unsqueeze(dvdy[:,:,-1],dim=2)), dim=2) - dwdy = torch.cat((dwdy, torch.unsqueeze(dwdy[:,:,-1],dim=2)), dim=2) - - dudz = torch.cat((dudz, torch.unsqueeze(dudz[:,:,:,-1],dim=3)), dim=3) - dvdz = torch.cat((dvdz, torch.unsqueeze(dvdz[:,:,:,-1],dim=3)), dim=3) - dwdz = torch.cat((dwdz, torch.unsqueeze(dwdz[:,:,:,-1],dim=3)), dim=3) - - u = dwdy - dvdz - v = dudz - dwdx - w = dvdx - dudy - - j = torch.stack([dudx,dudy,dudz,dvdx,dvdy,dvdz,dwdx,dwdy,dwdz],axis=1) - c = torch.stack([u,v,w],axis=1) #vorticity - - return j,c + diff --git a/Modeling eMNS/utils.py b/Modeling eMNS/utils.py index dd13c56f..6c7d7c3c 100644 --- a/Modeling eMNS/utils.py +++ b/Modeling eMNS/utils.py @@ -1,5 +1,7 @@ -import torch,ray +import torch,ray,os import matplotlib.pyplot as plt +import torch.nn.functional as F +import numpy as np def compute_discrete_curl(A_field, device): ''' A_field: (batch, Dimensions, grid_x, grid_y, grid_z) @@ -42,10 +44,10 @@ def plot_3D_vector_field(position, vectorField, figsize=(5,5), length=1): ''' Plot 3D vector field -----------input---------- - position: position of grids shape: (1,dimensions,grid_x,grid_y,grid_z) - vectorField: shape (1,dimensions,grid_x,grid_y,grid_z) + position: position of grids shape: (dimensions,grid_x,grid_y,grid_z) + vectorField: shape (dimensions,grid_x,grid_y,grid_z) ''' - fig = plt.figure(figsize=(5,5)) + fig = plt.figure(figsize=figsize) ax = fig.add_subplot(111,projection='3d') p = gridData_reshape(position) #(-1, dimension) vector = gridData_reshape(vectorField) #(-1, dimension) @@ -96,4 +98,195 @@ def plot_ray_results(results, metrics_names,legend=False, ylim=None, xlim=None): ax = None for data in dfs.values(): - ax = data[metrics_name].plot(ax=ax, legend=legend, ylim=ylim, xlim=xlim) \ No newline at end of file + ax = data[metrics_name].plot(ax=ax, legend=legend, ylim=ylim, xlim=xlim) + +#------------------------------------------------------------------------------------------------------- + +def get_mean_of_dataloader(dataloader,model,device): + num_samples = 0 + b = torch.zeros(1,device=device) + model.eval() + for x,y in dataloader: + y = y.to(device=device,dtype=torch.float) + # use sum instead of mean, what do you think? + y_sum = y.sum(dim=0,keepdim=True) + num_samples += y.shape[0] + # print(y.shape[0]) + b =b+y_sum + return b/num_samples + + + +def check_rmse_CNN(dataloader,model, grid_space, device, DF, maxB=[],minB=[]): + ''' + Check RMSE of CNN + ''' + mse_temp = 0 + R_temp=0 + Rsquare=0 + num_samples = 0 + # print(Bfield_mean) + + data = next(iter(dataloader)) + mean = data[0].mean() + + Bfield_mean=get_mean_of_dataloader(dataloader,model,device) + + model.eval() # set model to evaluation model + + with torch.no_grad(): + for x,y in dataloader: + x = x.to(device=device,dtype=torch.float) + y = y.to(device=device,dtype=torch.float) + num_samples += x.shape[0] + if DF: + _, scores = Jacobian3(model(x)) + else: + scores = model(x) + + # compute mse and R2 by de-normalize data + mse_temp += F.mse_loss(1e3*denorm(scores,maxB,minB,device), 1e3*denorm(y,maxB,minB, device) ,reduction='sum') + R_temp += F.mse_loss(1e3*denorm(Bfield_mean.expand_as(y),maxB,minB,device), 1e3*denorm(y,maxB,minB,device), reduction='sum') + + + rmse = torch.sqrt(mse_temp/num_samples/grid_space/3) + + Rsquare=1-mse_temp/R_temp/num_samples + print(f'Got rmse {rmse}') + + return rmse, mse_temp/num_samples/grid_space/3, Rsquare +class estimate_test_set(): + ''' + This class estimate the error of the test set + ''' + def __init__(self, checkpoint, test_set, train_loop_config) -> None: + + self.train_loop_config = train_loop_config + #--------------------create test loader------------ + self.test_set = test_set + self.test_loader = torch.utils.data.DataLoader(dataset=test_set,batch_size=train_loop_config['batch_size'],shuffle=True) + + # load checkpoint and model + if checkpoint: + with checkpoint.as_directory() as checkpoint_dir: + self.model = torch.load( + os.path.join(checkpoint_dir, "model.pt"),map_location=train_loop_config['device'])['model'] + + def fit(self): + # estimate rmse for test set + rmse_test, mse_test, R2_test = check_rmse_CNN( + self.test_loader, self.model, self.train_loop_config['grid_space'], self.train_loop_config['device'], self.train_loop_config['DF'], self.train_loop_config['maxB'], self.train_loop_config['minB']) + + print(f'rmse for test set: {rmse_test:.4f}mT') + print(f' mse for test set: {mse_test:.4f}mT') + print(f' R2 for test set: {R2_test:.4f}') + return rmse_test, mse_test, R2_test + + def peek_z(self, z_plane_index): + # for plotting a random choice sample in test set + plot_index = np.random.choice(self.test_set.indices) + plot_sample = self.test_set.dataset[plot_index] + + # prediction B field + + self.plot_B_pred = 1e3*denorm(self.model(torch.unsqueeze(plot_sample[0],0).to(dtype=torch.float)), self.train_loop_config['maxB'], self.train_loop_config['minB'], self.train_loop_config['device']) + self.plot_B = 1e3*denorm(plot_sample[1], self.train_loop_config['maxB'], self.train_loop_config['minB'], self.train_loop_config['device']) + + ylables=['Bx(mT)','By(mT)','Bz(mT)'] + plot_rmse = torch.sqrt(F.mse_loss(self.plot_B, torch.squeeze(self.plot_B_pred,0), reduction='mean')) + print(f'plot sample rmse: {plot_rmse:.4f}mT') + + f = plt.figure(figsize=(15,15)) + for i in range(1,4): + + B_est_temp =self.plot_B_pred[0,i-1,:,:,z_plane_index].detach() + ax = f.add_subplot(3,2,2*i-1) + img_plot = ax.imshow( B_est_temp ) + plt.ylabel(ylables[i-1]) + + Bfield_temp = self.plot_B[i-1,:,:,z_plane_index] + ax2 = f.add_subplot(3,2,2*i) + img_plot=ax2.imshow(Bfield_temp) + plt.colorbar(img_plot,ax=[ax,ax2]) + # plt.ylabel(ylables[i-1]) + plt.show() + + def peek_3D(self,length=0.1): + from utils import plot_3D_vector_field + x = torch.linspace(-10,10,16) + y = torch.linspace(-10,10,16) + z = torch.linspace(-10,10,16) + print(x.shape) + position = torch.cat(torch.meshgrid([x,y,z],indexing='ij')).reshape(3,16,16,16) + print(position.shape) + print(torch.squeeze(self.plot_B_pred,0).shape) + plot_3D_vector_field(position[:,:,:,::15], torch.squeeze(self.plot_B_pred,0).detach()[:,:,:,::15], length=length) + + plot_3D_vector_field(position[:,:,:,::15], self.plot_B[:,:,:,::15], length=length) + +#---------------------------------------------------------------- +def grad_loss(preds, y): + ''' + preds, y shape: (batch, dimension, grid_x, grid_y, grid_z) + This function computes lamda_g*| nabla(y) - nabla(preds)| + ''' + grad_preds = torch.gradient(preds,spacing=1.0) + grad_y = torch.gradient(y, spacing=1) + grad_loss = 0 + for i in range(2,5): + # accumulate grad loss for grad_x,y,z + grad_loss += torch.mean(torch.abs(grad_y[i]-grad_preds[i]))/3 + return grad_loss + +def grad_loss_Jacobain(preds,y): + ''' + preds, y shape: (batch, dimension, grid_x, grid_y, grid_z) + This function computes lamda_g*| nabla(y) - nabla(preds)| by Jacobian + ''' + Jaco_preds,_ = Jacobian3(preds) + Jaco_y ,_ = Jacobian3(y) + + grad_loss = torch.mean(torch.abs(Jaco_preds - Jaco_y)) + + return grad_loss + + +def Jacobian3(x): + ''' + Jacobian for 3D vector field + -------input---------- + x shape: (batch, dimension,grid_x, grid_y, grid_z) + ''' + + dudx = x[:, 0, 1:, :, :] - x[:, 0, :-1, :, :] + dvdx = x[:, 1, 1:, :, :] - x[:, 1, :-1, :, :] + dwdx = x[:, 2, 1:, :, :] - x[:, 2, :-1, :, :] + + dudy = x[:, 0, :, 1:, :] - x[:, 0, :, :-1, :] + dvdy = x[:, 1, :, 1:, :] - x[:, 1, :, :-1, :] + dwdy = x[:, 2, :, 1:, :] - x[:, 2, :, :-1, :] + + dudz = x[:, 0, :, :, 1:] - x[:, 0, :, :, :-1] + dvdz = x[:, 1, :, :, 1:] - x[:, 1, :, :, :-1] + dwdz = x[:, 2, :, :, 1:] - x[:, 2, :, :, :-1] + + dudx = torch.cat((dudx, torch.unsqueeze(dudx[:,-1],dim=1)), dim=1) + dvdx = torch.cat((dvdx, torch.unsqueeze(dvdx[:,-1],dim=1)), dim=1) + dwdx = torch.cat((dwdx, torch.unsqueeze(dwdx[:,-1],dim=1)), dim=1) + + dudy = torch.cat((dudy, torch.unsqueeze(dudy[:,:,-1],dim=2)), dim=2) + dvdy = torch.cat((dvdy, torch.unsqueeze(dvdy[:,:,-1],dim=2)), dim=2) + dwdy = torch.cat((dwdy, torch.unsqueeze(dwdy[:,:,-1],dim=2)), dim=2) + + dudz = torch.cat((dudz, torch.unsqueeze(dudz[:,:,:,-1],dim=3)), dim=3) + dvdz = torch.cat((dvdz, torch.unsqueeze(dvdz[:,:,:,-1],dim=3)), dim=3) + dwdz = torch.cat((dwdz, torch.unsqueeze(dwdz[:,:,:,-1],dim=3)), dim=3) + + u = dwdy - dvdz + v = dudz - dwdx + w = dvdx - dudy + + j = torch.stack([dudx,dudy,dudz,dvdx,dvdy,dvdz,dwdx,dwdy,dwdz],axis=1) + c = torch.stack([u,v,w],axis=1) #vorticity + + return j,c \ No newline at end of file diff --git a/SOFA_playground/Qubot/MagneticCatheterSim/mcr_radiologyInstrumentDOFs.py b/SOFA_playground/Qubot/MagneticCatheterSim/mcr_radiologyInstrumentDOFs.py index bf3de873..affa816d 100644 --- a/SOFA_playground/Qubot/MagneticCatheterSim/mcr_radiologyInstrumentDOFs.py +++ b/SOFA_playground/Qubot/MagneticCatheterSim/mcr_radiologyInstrumentDOFs.py @@ -78,14 +78,6 @@ def Instrument_DOFs( indexFromEnd=True, showArrowSize=1e-2, showColor=[1,0,0,1]) - # PhysicsModel.addObject( - # 'ConstantForceField', - # name='CollectorMagneticForceField_test', - # indices=np.arange(topo_instruments[0].nbsections[-1]), - # forces=np.tile(np.array([100,1000,0,0,0,100]), (topo_instruments[0].nbsections[-1],1)), - # indexFromEnd=True, - # showArrowSize=1e-2, - # showColor=[1,0,0,1]) PhysicsModel.addObject( 'ConstantForceField', name='MagneticFieldVisual',