diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a2cb994 --- /dev/null +++ b/.gitignore @@ -0,0 +1,7 @@ +DataSet* +.vscode +log* +*.xlsx +*.mp4 +*.jpg +__pycache__ \ No newline at end of file diff --git a/CustomCallback.py b/CustomCallback.py new file mode 100644 index 0000000..eabba5c --- /dev/null +++ b/CustomCallback.py @@ -0,0 +1,78 @@ +from lightning.pytorch import Trainer, LightningModule, Callback +from torch.nn.modules.dropout import _DropoutNd +from typing import Any + +__all__ = ['StepDropout'] + + +class StepDropout(Callback): + def __init__( + self, + step_size, + base_drop_rate, + gamma=0., + update_interval='epoch', + log=True, + log_name='drop_rate', + ascending=False, + **kwargs + ): + """Step Dropout. + A simple Dropout Scheduler. + References: + - https://arxiv.org/abs/2303.01500 + Examples: + >>> from pytorch_lightning import Trainer + >>> # Early Dropout (drop rate from .1 to 0 after 50 epochs) + >>> trainer = Trainer(callbacks=[StepDropout(50, base_drop_rate=.1, gamma=0.)]) + >>> # Late Dropout (drop rate from 0 to .1 after 50 epochs) + >>> trainer = Trainer(callbacks=[StepDropout(50, base_drop_rate=.1, gamma=0., ascending=True)]) + Args: + step_size: Period of drop rate decay. + base_drop_rate: Base drop rate. + gamma: Multiplicative factor of drop rate decay. Default: 0. to replicate "Early Dropout". + update_interval: One of ``('step', 'epoch')``. + log: Whether to log drop rates using ``module.log(log_name, drop_rate)``. + log_name: Name for logging. + logger: If ``True`` logs to the logger. + ascending: If ``True`` drop rate decays from right to left, i.e. it starts at ``0`` and + ascends towards ``base_drop_rate``. Using ``ascending=True, gamma=0.`` replicates "Late Dropout". + **kwargs: Keyword arguments for ``module.log``. + """ + super().__init__() + self.step_size = step_size + self.gamma = gamma + self.base_drop_rate = base_drop_rate + assert update_interval in ('epoch', 'step') + self.update_interval = update_interval + self.last_rate = -1 + self.log = log + self.log_name = log_name + self.log_kwargs = {**dict( + on_step=self.update_interval == 'step', + on_epoch=self.update_interval == 'epoch', + ), **kwargs} + self.ascending = ascending + + def update_drop_rate(self, pl_module: "LightningModule", drop_rate: float): + self.last_rate = drop_rate + for mod in pl_module.modules(): + if isinstance(mod, _DropoutNd): + mod.p = drop_rate + if self.log: + pl_module.log(self.log_name, drop_rate, **self.log_kwargs) + + @staticmethod + def get_rate(base, gamma, step, step_size, ascending): + return base * (ascending + (-1 if ascending else 1) * gamma ** (step // step_size)) + + def on_train_epoch_start(self, trainer: "Trainer", pl_module: "LightningModule") -> None: + if self.update_interval == 'epoch': + self.update_drop_rate(pl_module, self.get_rate( + self.base_drop_rate, self.gamma, trainer.current_epoch, self.step_size, self.ascending)) + + def on_train_batch_start(self, trainer: "Trainer", pl_module: "LightningModule", batch: Any, + batch_idx: int) -> None: + if self.update_interval == 'step': + self.update_drop_rate(pl_module, self.get_rate( + self.base_drop_rate, self.gamma, trainer.global_step, self.step_size, self.ascending)) \ No newline at end of file diff --git a/EvalKFolds_RARP.ps1 b/EvalKFolds_RARP.ps1 new file mode 100644 index 0000000..f88846e --- /dev/null +++ b/EvalKFolds_RARP.ps1 @@ -0,0 +1,150 @@ +Write-Host " ---- Eval ---- " +$Ver=$args[0] +$Nombre=$args[1] +Write-Host "ROI-NO-distractors" +Write-Host "RestNet50" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 0 --Model 0 --Log_Name "log_ResNet50_$($Nombre)" -roi 1 -s 0.75 -ns 2 --sClass 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "RestNet18" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 0 --Model 1 --Log_Name "log_restnet18_$($Nombre)" -roi 1 -s 0.75 -ns 2 --sClass 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "MobileNetV2" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 0 --Model 2 --Log_Name "log_MobileNetV2_$($Nombre)" -roi 1 -s 0.75 -ns 2 --sClass 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "EfficientNetV2" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 0 --Model 3 --Log_Name "log_EfficientNetV2_$($Nombre)" -roi 1 -s 0.75 -ns 2 --sClass 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} +$Ver=5 +Write-Host "ROI-Fix" +Write-Host "RestNet50" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 0 --Model 0 --Log_Name "log_ResNet50_$($Nombre)" -roi 2 -s 0.75 -ns 2 --sClass 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "RestNet18" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 0 --Model 1 --Log_Name "log_restnet18_$($Nombre)" -roi 2 -s 0.75 -ns 2 --sClass 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "MobileNetV2" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 0 --Model 2 --Log_Name "log_MobileNetV2_$($Nombre)" -roi 2 -s 0.75 -ns 2 --sClass 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "EfficientNetV2" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 0 --Model 3 --Log_Name "log_EfficientNetV2_$($Nombre)" -roi 2 -s 0.75 -ns 2 --sClass 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} +$Ver=10 +Write-Host "Full-size" +Write-Host "RestNet50" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_$($Nombre)" -s 0.75 -ns 2 --sClass 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "RestNet18" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_$($Nombre)" -s 0.75 -ns 2 --sClass 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "MobileNetV2" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_$($Nombre)" -s 0.75 -ns 2 --sClass 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "EfficientNetV2" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_$($Nombre)" -s 0.75 -ns 2 --sClass 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + diff --git a/EvalKFolds_RARPFull-SizeImg.ps1 b/EvalKFolds_RARPFull-SizeImg.ps1 new file mode 100644 index 0000000..720bd96 --- /dev/null +++ b/EvalKFolds_RARPFull-SizeImg.ps1 @@ -0,0 +1,65 @@ +Write-Host " ---- Eval ---- " +$Ver=$args[0] +$Nombre=$args[1] + +Write-Host "Full-size" +Write-Host "RestNet50" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_$($Nombre)" -s 0.75 -ns 2 --sClass 1 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "RestNet18" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_$($Nombre)" -s 0.75 -ns 2 --sClass 1 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "MobileNetV2" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_$($Nombre)" -s 0.75 -ns 2 --sClass 1 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "EfficientNetV2" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_$($Nombre)" -s 0.75 -ns 2 --sClass 1 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "DenseNet169" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 3 --Log_Name "log_DenseNet169_$($Nombre)" -s 0.75 -ns 2 --sClass 1 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + diff --git a/EvalKFolds_RARPFullSize.ps1 b/EvalKFolds_RARPFullSize.ps1 new file mode 100644 index 0000000..c04dc82 --- /dev/null +++ b/EvalKFolds_RARPFullSize.ps1 @@ -0,0 +1,53 @@ +Write-Host " ---- Eval ---- " +$Ver=$args[0] +$Nombre=$args[1] +Write-Host "Full-size" +Write-Host "RestNet50" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_$($Nombre)" -roi 9 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "RestNet18" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_$($Nombre)" -roi 9 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "MobileNetV2" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_$($Nombre)" -roi 9 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "EfficientNetV2" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_$($Nombre)" -roi 9 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + + diff --git a/EvalKFolds_RARPFullSize_Norm.ps1 b/EvalKFolds_RARPFullSize_Norm.ps1 new file mode 100644 index 0000000..a646cab --- /dev/null +++ b/EvalKFolds_RARPFullSize_Norm.ps1 @@ -0,0 +1,28 @@ +Write-Host " ---- Eval ---- " +$Ver=$args[0] +$Nombre=$args[1] +Write-Host "Full-size" +Write-Host "RestNet50_2 No Scheduler" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 6 --Log_Name "log_ResNet50_2_$($Nombre)" -roi 7 --JIndex 1 --Metadata "./DataSet_smallBalaced/data.xlsx" + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} +$Ver = 5 +Write-Host "RestNet50_2" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 6 --Log_Name "log_ResNet50_2_$($Nombre)" -roi 7 --JIndex 1 --Metadata "./DataSet_smallBalaced/data.xlsx" --DyLr 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + diff --git a/EvalKFolds_RARPNew.ps1 b/EvalKFolds_RARPNew.ps1 new file mode 100644 index 0000000..09cb68b --- /dev/null +++ b/EvalKFolds_RARPNew.ps1 @@ -0,0 +1,16 @@ +Write-Host " ---- Eval ---- " +$Ver=$args[0] +$model = $args[1] +$Nombre=$args[2] +$roi = $args[3] +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model $model --Log_Name "log_$($Nombre)" -roi $roi --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + diff --git a/EvalKFolds_RARP_BD.ps1 b/EvalKFolds_RARP_BD.ps1 new file mode 100644 index 0000000..e8e4667 --- /dev/null +++ b/EvalKFolds_RARP_BD.ps1 @@ -0,0 +1,63 @@ +Write-Host " ---- Eval ---- " +$Ver=$args[0] +$Nombre=$args[1] +Write-Host "Full-size" +Write-Host "RestNet50" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_$($Nombre)" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "RestNet18" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_$($Nombre)" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "MobileNetV2" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_$($Nombre)" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "EfficientNetV2" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_$($Nombre)" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "ViT_B_16" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 3 --Log_Name "log_ViT_B_16_$($Nombre)" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} diff --git a/EvalKFolds_RARP_BD2.ps1 b/EvalKFolds_RARP_BD2.ps1 new file mode 100644 index 0000000..67010e8 --- /dev/null +++ b/EvalKFolds_RARP_BD2.ps1 @@ -0,0 +1,52 @@ +Write-Host " ---- Eval ---- " +$Ver=$args[0] +$Nombre=$args[1] +Write-Host "Full-size" +Write-Host "RestNet50" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_$($Nombre)" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 --JIndex 1 --AddTestSet "./DataSet_seed_505" + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "RestNet18" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_$($Nombre)" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 --JIndex 1 --AddTestSet "./DataSet_seed_505" + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "MobileNetV2" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_$($Nombre)" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 --JIndex 1 --AddTestSet "./DataSet_seed_505" + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "EfficientNetV2" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_$($Nombre)" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 --JIndex 1 --AddTestSet "./DataSet_seed_505" + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + diff --git a/EvalKFolds_RARP_Full.ps1 b/EvalKFolds_RARP_Full.ps1 new file mode 100644 index 0000000..c0ae414 --- /dev/null +++ b/EvalKFolds_RARP_Full.ps1 @@ -0,0 +1,63 @@ +Write-Host " ---- Eval ---- " +$Ver=$args[0] +$Nombre=$args[1] +Write-Host "Full-size" +Write-Host "RestNet50" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_$($Nombre)" -roi 6 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "RestNet18" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_$($Nombre)" -roi 6 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "MobileNetV2" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_$($Nombre)" -roi 6 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "EfficientNetV2" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_$($Nombre)" -roi 6 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} + +Write-Host "DenseNet169" +for ($i=0; $i -lt 5; $i++) +{ + $nextVer = $Ver+$i + Write-Host "Fold $($i) Ver. $($nextVer)" + python RARP_NVB.py --Phase "eval_all" --Fold $i -lv $nextVer --Remove_Blackbar 1 --Model 4 --Log_Name "log_DenseNet169_$($Nombre)" -roi 6 --JIndex 1 + read-host "Press ENTER to continue..." + if ($i -lt 3) { + Write-Host "Next Fold..." + } +} diff --git a/Loaders.py b/Loaders.py new file mode 100644 index 0000000..af01cce --- /dev/null +++ b/Loaders.py @@ -0,0 +1,891 @@ +import os +import torch +from torchvision.datasets.folder import make_dataset +from pathlib import Path +from torch.utils.data import Dataset, DataLoader, Subset +from lightning.pytorch import LightningDataModule +import numpy as np +import cv2 +from typing import Optional, Sequence, Tuple, Union, List, Any, Callable +from sklearn.model_selection import KFold, StratifiedKFold +import torchvision +import math +import defs +import csv +import pandas as pd +from enum import Enum +import shutil +from ultralytics import YOLO +import itertools + +def _find_classes(dir): + classes = [d.name for d in os.scandir(dir) if d.is_dir()] + classes.sort() + class_to_idx = {cls_name: i for i, cls_name in enumerate(classes)} + return classes, class_to_idx + +def get_samples(root, extensions=(".mp4", ".avi")): + _, class_to_idx = _find_classes(root) + return make_dataset(root, class_to_idx, extensions=extensions) + +class RARP_DatasetCreator(): + def _removeBlackBorder(self, image): + image = np.array(image) + + copyImg = cv2.cvtColor(image.copy(), cv2.COLOR_BGR2HSV) + h = copyImg[:,:,0] + mask = np.ones(h.shape, dtype=np.uint8) * 255 + th = (25, 175) + mask[(h > th[0]) & (h < th[1])] = 0 + copyImg = cv2.cvtColor(copyImg, cv2.COLOR_HSV2BGR) + resROI = cv2.bitwise_and(copyImg, copyImg, mask=mask) + + image_gray = cv2.cvtColor(resROI, cv2.COLOR_BGR2GRAY) + _, thresh = cv2.threshold(image_gray, 0, 255, cv2.THRESH_BINARY) + kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 15)) + morph = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel) + contours = cv2.findContours(morph, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) + contours = contours[0] if len(contours) == 2 else contours[1] + bigCont = max(contours, key=cv2.contourArea) + x, y, w, h = cv2.boundingRect(bigCont) + crop = image[y : y + h, x : x + w] + return crop + + def _crop(self, image:np, x:tuple, y:tuple): + return image[y[0]:y[1], x[0]:x[1], :] + + def _sliceImage(self, img:np, size:float): + h, w, _ = img.shape + xw = math.trunc(w*size) + xh = math.trunc(h*size) + ul = self._crop(img, (0, xw), (0, xh)) + ur = self._crop(img, (w-xw, w), (0, xh)) + dl = self._crop(img, (0, xw), (h-xh, h)) + dr = self._crop(img, (w-xw, w), (h-xh, h)) + + return [ul, ur, dl, dr] + + def _split(self, a, n): + k, m = divmod(len(a), n) + return (a[i*k+min(i, m):(i+1)*k+min(i+1, m)] for i in range(n)) + + def ROI_Extract_YOLO(self, YoloModel:YOLO, image, threshold=0.75): + listROIs = [] + res = YoloModel(image, stream=True) + for r in res: + pred = r.boxes.conf.cpu().numpy() + for i, box in enumerate(r.boxes.xyxy.cpu().numpy()): + if pred[i] >= threshold: + box = box.astype(int) + x, y = (box[0], box[1]) + xw, yh = (box[2], box[3]) + listROIs.append(image[y:yh, x:xw]) + + return listROIs + + def __init__(self, + RootPath = "", + extension="tiff", + FoldSeed=505, + createFile=False, + SavePath="", + Fold:int=None, + preResize=None, + RGBGama=False, + removeBlackBar=True, + SegImage:float=None, + Num_Img_Slices:int = 4, + SegmentClass:int = None, + colorSpace:int=None, + ROI_Yolo:YOLO=None, + thresholdYolo_Accuracy:float=0.75) -> None: + + root = Path(RootPath) + lMean = [] + lStd = [] + NO_NVB = [] + NVB = [] + + if createFile: + if len(SavePath) == 0: + raise Exception("If createFile is True, SavePath must have a value") + + sPath = Path(SavePath + f"_seed_{FoldSeed}") + dumpImgs = sPath/"dump" + dumpImgs.mkdir(parents=True, exist_ok=True) + self.CVS_File = dumpImgs/"dataset.csv" + if not self.CVS_File.exists(): + with open(self.CVS_File, "x", newline='') as csvfile: + writerOBJ = csv.writer(csvfile) + writerOBJ.writerow(["id", "label", "class", "path", "name", "mean_1", "mean_2", "mean_3", "std_1", "std_2", "std_3"]) + id = 0 + for i, file in enumerate(root.glob(f"**/*.{extension}")): + tempImg = cv2.imread(str(file), cv2.IMREAD_COLOR) + if removeBlackBar and ROI_Yolo is None: + tempImg = self._removeBlackBorder(tempImg) + if RGBGama: + tempImg = cv2.cvtColor(tempImg, cv2.COLOR_BGR2RGB) + if colorSpace is not None: + tempImg = cv2.cvtColor(tempImg, colorSpace) + if preResize is not None: + tempImg = cv2.resize(tempImg, preResize, interpolation=cv2.INTER_AREA)#Cambio de resolucion + + tempImgList = [tempImg] + + #ROI w/ YOLOv8 + if ROI_Yolo is not None: + tempImgList = self.ROI_Extract_YOLO(ROI_Yolo, tempImg, thresholdYolo_Accuracy) + + for k, tempImg in enumerate(tempImgList): + lineaCSV = [id, 0 if file.parent.name == "NOT_NVB" else 1, file.parent.name, (dumpImgs/f"Img{k}-{i}.npy").absolute(), file.name] + lMean.append(np.mean(tempImg, axis=tuple(range(tempImg.ndim-1)))) + lStd.append(np.std(tempImg, axis=tuple(range(tempImg.ndim-1)))) + lineaCSV += np.mean(tempImg, axis=tuple(range(tempImg.ndim-1))).tolist() + lineaCSV += np.std(tempImg, axis=tuple(range(tempImg.ndim-1))).tolist() + writerOBJ.writerow(lineaCSV) + #lista.append (np.mean(tempImg, axis=tuple(range(tempImg.ndim-1)))) + np.save(dumpImgs/f"Img{k}-{i}.npy", tempImg) + if lineaCSV[1] == 0: + NO_NVB.append(id) + else: + NVB.append(id) + + id += 1 + + if SegImage is not None: + if (SegmentClass is None) or (lineaCSV[1] == SegmentClass): + for j, newImg in enumerate(self._sliceImage(tempImg, SegImage)): + if j == Num_Img_Slices: + break + imgPath = dumpImgs/f"Img{k}-{i}-{j}.npy" + np.save(imgPath, newImg) + lineaCSV = [id, 0 if file.parent.name == "NOT_NVB" else 1, file.parent.name, (dumpImgs/f"Img{k}-{i}-{j}.npy").absolute(), file.name] + lineaCSV += np.mean(newImg, axis=tuple(range(newImg.ndim-1))).tolist() + lineaCSV += np.std(newImg, axis=tuple(range(newImg.ndim-1))).tolist() + writerOBJ.writerow(lineaCSV) + if lineaCSV[1] == 0: + NO_NVB.append(id) + else: + NVB.append(id) + + id += 1 + + csvfile.close() + + temp = np.asarray(lMean) + self.mean = list(np.mean(temp, axis=tuple(range(temp.ndim-1)))) + temp = np.asarray(lStd) + self.std = list(np.mean(temp, axis=tuple(range(temp.ndim-1)))) + else: + data = pd.read_csv(self.CVS_File) + self.mean = data[["mean_1", "mean_2", "mean_3"]].mean().to_list() + self.std = data[["std_1", "std_2", "std_3"]].mean().to_list() + + NO_NVB = data.loc[data["label"] == 0]["id"].to_list() + NVB = data.loc[data["label"] == 1]["id"].to_list() + + if Fold is not None: + self.Splits = [] + splitsToSave = [] + tempFoldsOrder = list(range(Fold)) + for _ in range(Fold): + self.Splits.append(tempFoldsOrder) + tempFoldsOrder = tempFoldsOrder[1:] + tempFoldsOrder[:1] + + if FoldSeed is not None: + np.random.seed(FoldSeed) + np.random.shuffle(NO_NVB) + np.random.shuffle(NVB) + + NO_NVB_Folds = list (self._split(NO_NVB, Fold)) + NVB_Fols = list(self._split(NVB, Fold)) + + setst = [ + math.trunc(0.60 * Fold), math.trunc(0.20 * Fold), math.trunc(0.20 * Fold) + ] + + for data in self.Splits: + ultimo = 0 + for s in setst: + tempArry = [] + for fold in data[ultimo: ultimo + s]: + tempArry += NO_NVB_Folds[fold] + NVB_Fols[fold] + splitsToSave.append(tempArry) + ultimo += s + self.Folds_File = dumpImgs/"Folds.npy" + np.save(self.Folds_File, np.asarray(splitsToSave, dtype=object)) + + def CreateClases(self): + if not (self.CVS_File.parent/"FOLDS_CREATED").exists(): + root = self.CVS_File.parent.parent + database = pd.read_csv(self.CVS_File, usecols=["id", "label", "class", "path"]) + + for _, row in database.iterrows(): + pathOriginal = Path(row["path"]) + pathNuevo = root/"dataset"/("NO_NVB" if row["label"] == 0 else "NVB")/pathOriginal.name + pathNuevo.parent.mkdir(parents=True, exist_ok=True) + shutil.copy(pathOriginal, pathNuevo) + + with open(self.CVS_File.parent/"FOLDS_CREATED", "x") as file: + file.close() + + for f in self.CVS_File.parent.glob("*.npy"): + f.unlink() + + def ExtractROI_YOLO(self, YOLOModel:YOLO, thresholdYolo:float = 0.70): + if (self.CVS_File.parent/"FOLDS_CREATED").exists() and not (self.CVS_File.parent/"YOLO_ROI_CREATED").exists(): + root = self.CVS_File.parent.parent + for img in root.glob(f"**/*.npy"): + if img.name == "Folds.npy": + continue + tempImgList = self.ROI_Extract_YOLO(YOLOModel, np.load(img), thresholdYolo) + for k, tempImg in enumerate(tempImgList): + if k == 0: + np.save(img, tempImg) + #else: + # newPath = img.parent/(img.name.replace(".npy", "") +f"-{k}.npy") + # np.save(newPath, tempImg) + + with open(self.CVS_File.parent/"YOLO_ROI_CREATED", "x") as file: + file.close() + + def CreateFolds(self): + if not (self.CVS_File.parent/"FOLDS_CREATED").exists(): + root = self.CVS_File.parent.parent + database = pd.read_csv(self.CVS_File, usecols=["id", "label", "class", "path"]) + arrFolds = np.load(self.Folds_File, allow_pickle=True) + + for foldNum, splits in enumerate(np.array_split(arrFolds, len(arrFolds)/3)): + foldPath = root/f"fold_{foldNum}" + for datasetType, subSet in enumerate(splits): + SubfoldPath = foldPath/f"{RARP_DataSetType(datasetType).name}" + for _, row in database.loc[database["id"].isin(subSet)].iterrows(): + PathOri = Path(row["path"]) + PathImg = SubfoldPath/("NO_NVB" if row["label"] == 0 else "NVB")/PathOri.name + PathImg.parent.mkdir(parents=True, exist_ok=True) + shutil.copy(PathOri, PathImg) + + with open(self.CVS_File.parent/"FOLDS_CREATED", "x") as file: + file.close() + + for f in self.CVS_File.parent.glob("*.npy"): + f.unlink() + +class RARP_DatasetFolder_ExtraData(torchvision.datasets.DatasetFolder): + def __init__(self, + root: str, + loader: Callable[[str], Any], + Extra_Data: pd.DataFrame, + Extra_Data_leg:int = 4, + extensions: Tuple[str, ...] | None = None, + transform: Callable[..., Any] | None = None, + target_transform: Callable[..., Any] | None = None, + is_valid_file: Callable[[str], bool] | None = None + ) -> None: + super().__init__(root, loader, extensions, transform, target_transform, is_valid_file) + self.Extra_Data = Extra_Data + self.Extra_Data_leg = Extra_Data_leg + + def __getitem__(self, index: int) -> Tuple[Any, Any]: + path, target = self.samples[index] + + name = Path(path).name + Extra_data = self.Extra_Data[self.Extra_Data["raw_name"] == name].values.flatten().tolist()[:self.Extra_Data_leg] + Extra_data = torch.tensor(Extra_data) + + #Loadres is 2 values + sample = self.loader(path) + if self.transform is not None: + sample = self.transform(sample) + if self.target_transform is not None: + target = self.target_transform(target) + + return (sample, Extra_data), target + +class RARP_DatasetFolder_DobleTransform(torchvision.datasets.DatasetFolder): + def __init__(self, + root: str, + loader: Callable[[str], Any], + extensions: Tuple[str, ...] | None = None, + transformT1: Callable[..., Any] | None = None, + transformT2: Callable[..., Any] | None = None, + target_transform: Callable[..., Any] | None = None, + is_valid_file: Callable[[str], bool] | None = None, + passOriginal: Callable[..., Any] | None = None, + ) -> None: + super().__init__(root, loader, extensions, None, target_transform, is_valid_file) + self.T1 = transformT1 + self.T2 = transformT2 if transformT2 is not None else transformT1 + self.PassOrigianlImage = passOriginal + + def __getitem__(self, index: int) -> Tuple[Any, Any]: + path, target = self.samples[index] + + sample = self.loader(path) + if self.T1 is not None: + sample1 = self.T1(sample) + + if self.T2 is not None: + sample2 = self.T2(sample) + + if self.PassOrigianlImage is not None: + return (sample1, sample2, self.PassOrigianlImage(sample)), target + else: + return (sample1, sample2), target + + +class RARP_PreprocessCreator(): + def removeBlackBorder(self, image): + image = np.array(image) + image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) + _, thresh = cv2.threshold(image_gray, 0, 255, cv2.THRESH_BINARY) + kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 15)) + morph = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel) + contours = cv2.findContours(morph, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) + contours = contours[0] if len(contours) == 2 else contours[1] + bigCont = max(contours, key=cv2.contourArea) + x, y, w, h = cv2.boundingRect(bigCont) + crop = image[y : y + h, x : x + w] + return crop + + def _crop(self, image:np, x:tuple, y:tuple): + return image[y[0]:y[1], x[0]:x[1], :] + + def _sliceImage(self, img:np, size:float): + h, w, _ = img.shape + ul = self._crop(img, (0, math.trunc(w*size)), (0, math.trunc(h*size))) + ur = self._crop(img, (math.trunc(w*size), w), (0, math.trunc(h*size))) + dl = self._crop(img, (0, math.trunc(w*size)), (math.trunc(h*size), h)) + dr = self._crop(img, (math.trunc(w*size), w), (math.trunc(h*size), h)) + + return [ul, ur, dl, dr] + + def __init__(self, + RootPath = "", + extension="tiff", + FoldSeed=505, + createFile=False, + SavePath="", + Fold=False, + preResize=None, + RGBGama=False, + removeBlackBar=True, + SegImage:float=None) -> None: + super().__init__() + + self.root = Path(RootPath) + self.mean = 0.0 + self.std = 0.0 + self.test_DataSet = [] + self.val_DataSet = [] + self.train_DataSet = [] + + self.nNVB = [] + self.yNVB = [] + + lista = [] + + dist = { + 'test': [5, 2], #[4, 3], [10, 4], + 'val': [8, 3], #[4, 3], [10, 4], + 'train': [28, 10] #[8, 6], [21, 7] + } + + sPath = Path(SavePath + f"_seed_{FoldSeed}") + dumpImgs = sPath/"dump" + dumpImgs.mkdir(parents=True, exist_ok=True) + for i, file in enumerate(self.root.glob(f"**/*.{extension}")): + tempImg = cv2.imread(str(file), cv2.IMREAD_COLOR) + if removeBlackBar: + tempImg = self.removeBlackBorder(tempImg) + if RGBGama: + tempImg = cv2.cvtColor(tempImg, cv2.COLOR_BGR2RGB) + if preResize is not None: + tempImg = cv2.resize(tempImg, preResize, interpolation=cv2.INTER_AREA)#Cambio de resolucion + + lista.append (np.mean(tempImg, axis=tuple(range(tempImg.ndim-1)))) + + if not (sPath/"train").exists(): + imgPath = dumpImgs/f"Img{i}.npy" + np.save(imgPath, tempImg) + #parImgClass = (tempImg.astype(float), 0 if file.parent.name == "NOT_NVB" else 1) + parImgClass = (imgPath, 0 if file.parent.name == "NOT_NVB" else 1) + + if file.parent.name == "NOT_NVB": + self.nNVB.append(parImgClass) + else: + self.yNVB.append(parImgClass) + + if SegImage is not None: + for j, newImg in enumerate(self._sliceImage(tempImg, SegImage)): + imgPath = dumpImgs/f"Img{i}-{j}.npy" + np.save(imgPath, newImg) + #parImgClass = (tempImg.astype(float), 0 if file.parent.name == "NOT_NVB" else 1) + parImgClass = (imgPath, 0 if file.parent.name == "NOT_NVB" else 1) + + if file.parent.name == "NOT_NVB": + self.nNVB.append(parImgClass) + else: + self.yNVB.append(parImgClass) + + temp = np.asarray(lista) + self.mean = list(np.mean(temp, axis=tuple(range(temp.ndim-1)))) + self.std = list(np.std(temp, axis=tuple(range(temp.ndim-1)))) + + if (sPath / "train").exists(): + self.test_DataSet = None + self.train_DataSet = None + self.val_DataSet = None + self.nNVB = None + self.yNVB = None + self.SaveFold = sPath + return + + if FoldSeed is not None: + np.random.seed(FoldSeed) + + shuffle_nNVB = list(range(len(self.nNVB))) + shuffle_NVB = list(range(len(self.yNVB))) + + np.random.shuffle(shuffle_nNVB) + np.random.shuffle(shuffle_NVB) + + pasoN, pasoY = (dist['train'][0], dist['train'][1]) + + self.train_DataSet = self.nNVB[:pasoN] + self.yNVB[:pasoY] + + nextPasoN, nextPasoY = (pasoN+dist['val'][0], pasoY+dist['val'][1]) + + self.val_DataSet = self.nNVB[pasoN:nextPasoN] + self.yNVB[pasoY:nextPasoY] + + self.test_DataSet = self.nNVB[nextPasoN:] + self.yNVB[nextPasoY:] + + if createFile: + if len(SavePath) == 0: + raise Exception("If createFile is True, SavePath must have a value") + + n=0 + for img, lb in self.train_DataSet: + trainPath = sPath / "train" / ("NOT_NVB" if lb == 0 else "NVB") / f"img{n}" + trainPath.parent.mkdir(parents=True, exist_ok=True) + np.save(trainPath, defs.load_file(img)) + n += 1 + + n=0 if not Fold else n + for img, lb in self.val_DataSet: + trainPath = sPath / ("val" if not Fold else "train") / ("NOT_NVB" if lb == 0 else "NVB") / f"img{n}" + trainPath.parent.mkdir(parents=True, exist_ok=True) + np.save(trainPath, defs.load_file(img)) + n += 1 + + n=0 if not Fold else n + for img, lb in self.test_DataSet: + trainPath = sPath / ("test" if not Fold else "train") / ("NOT_NVB" if lb == 0 else "NVB") / f"img{n}" + trainPath.parent.mkdir(parents=True, exist_ok=True) + np.save(trainPath, defs.load_file(img)) + n += 1 + + self.test_DataSet = None + self.train_DataSet = None + self.val_DataSet = None + self.nNVB = None + self.yNVB = None + self.SaveFold = sPath + + for f in dumpImgs.iterdir(): + f.unlink() + dumpImgs.rmdir() + +class DataloaderToDataModule(LightningDataModule): + """Converts a set of dataloaders into a lightning datamodule. + + Args: + train_dataloader: Training dataloader + val_dataloaders: Validation dataloader(s) + test_dataloaders: Test dataloader(s) + """ + + def __init__( + self, + train_dataloader: DataLoader, + val_dataloaders: Union[DataLoader, Sequence[DataLoader]], + ) -> None: + super().__init__() + self._train_dataloader = train_dataloader + self._val_dataloaders = val_dataloaders + + def train_dataloader(self) -> DataLoader: + """Return training dataloader.""" + return self._train_dataloader + + def val_dataloader(self) -> Union[DataLoader, Sequence[DataLoader]]: + """Return validation dataloader(s).""" + return self._val_dataloaders + +class RARP_DataModule(LightningDataModule): + def __init__(self, + KFold:bool=False, + num_fold:int=5, + shuffle: bool = False, + stratified: bool = False, + train_dataloader: DataLoader = None, + val_dataloader: DataLoader = None, + test_dataloader: DataLoader = None, + transforms = []) -> None: + super().__init__() + + self.fold_index = 0 + self.splits = None + self.Kfold_split = KFold + self.num_folds = num_fold + self.Folds = [] + self.shuffle = shuffle + self.stratified = stratified + self.label_extractor = lambda batch: batch[1] + + self.trainDL = train_dataloader + self.valDL = val_dataloader + self.testDL = test_dataloader + self.dataloader_settings = None + self.transforms = transforms + + tempFoldsOrder = list(range(num_fold)) + for _ in range(num_fold): + self.Folds.append(tempFoldsOrder) + tempFoldsOrder = tempFoldsOrder[1:] + tempFoldsOrder[:1] + + def get_Current_Folds(self) -> list: + return self.Folds[self.fold_index] + + def get_labels(self, dataloader: DataLoader) -> Optional[List]: + """Try to extract the training labels (for classification problems) from the underlying training dataset.""" + # Try to extract labels from the dataset through labels attribute + if hasattr(dataloader.dataset, "labels"): + return dataloader.dataset.labels.tolist() + + # Else iterate and try to extract + try: + return torch.cat([self.label_extractor(batch) for batch in dataloader], dim=0).tolist() + except Exception: + return None + + def _split(self, a, n): + k, m = divmod(len(a), n) + return (a[i*k+min(i, m):(i+1)*k+min(i+1, m)] for i in range(n)) + + def split_folds(self): + if self.splits is None: + self.splits = [] + self.FoldDataset = self.trainDL.dataset + + NO_NVB = [] + NVB = [] + for pos, label in enumerate(self.FoldDataset.targets): + if label==0: + NO_NVB.append(pos) + else: + NVB.append(pos) + + if self.shuffle: + np.random.shuffle(NO_NVB) + np.random.shuffle(NVB) + + NO_NVB_Folds = list (self._split(NO_NVB, self.num_folds)) + NVB_Fols = list(self._split(NVB, self.num_folds)) + + setst = [ + math.trunc(0.60 * self.num_folds), math.trunc(0.80 * self.num_folds), self.num_folds + ] + + tempArray = [] ##### FIX ... que puede hacer los grupos mal sin los folds son difrentes de 5 + for pos, index in enumerate(self.Folds[self.fold_index]): + if pos < setst[0]: + tempArray += NO_NVB_Folds[index] + NVB_Fols[index] + elif pos < setst[1]: + self.splits.append(tempArray) + self.splits.append(NO_NVB_Folds[index] + NVB_Fols[index]) + else: + self.splits.append(NO_NVB_Folds[index] + NVB_Fols[index]) + + + + def setup_folds(self): + if self.splits is None: + labels = None + if self.stratified: + labels = self.get_labels(self.trainDL) + if labels is None: + raise ValueError( + "Tried to extract labels for stratified K folds but failed." + " Make sure that the dataset of your train dataloader either" + " has an attribute `labels` or that `label_extractor` attribute" + " is initialized correctly" + ) + splitter = StratifiedKFold(self.num_folds, shuffle=self.shuffle) + else: + splitter = KFold(self.num_folds, shuffle=self.shuffle) + + self.FoldDataset = self.trainDL.dataset + + self.splits = [split for split in splitter.split(range(len(self.FoldDataset)), y=labels)] + + def train_dataloader(self) -> DataLoader: + if not self.Kfold_split: + return self.trainDL + else: + self.split_folds() + train_fold = RARP_Dataset(self.FoldDataset, self.splits[0], self.transforms[0]) + return DataLoader(train_fold, shuffle=True, **self.dataloader_setting) + + def val_dataloader(self) -> DataLoader: + if not self.Kfold_split: + return self.valDL + else: + self.split_folds() + val_fold = RARP_Dataset(self.FoldDataset, self.splits[1], self.transforms[1]) + return DataLoader(val_fold, shuffle=False, **self.dataloader_setting) + + def test_dataloader(self) -> DataLoader: + if not self.Kfold_split: + return self.testDL + else: + self.split_folds() + test_fold = RARP_Dataset(self.FoldDataset, self.splits[2], self.transforms[2]) + return DataLoader(test_fold, shuffle=False, **self.dataloader_setting) + + @property + def dataloader_setting(self) -> dict: + """Return the settings of the train dataloader.""" + if self.dataloader_settings is None: + orig_dl = self.trainDL + self.dataloader_settings = { + "batch_size": orig_dl.batch_size, + "num_workers": orig_dl.num_workers, + "collate_fn": orig_dl.collate_fn, + "pin_memory": orig_dl.pin_memory, + "drop_last": orig_dl.drop_last, + "timeout": orig_dl.timeout, + "worker_init_fn": orig_dl.worker_init_fn, + "prefetch_factor": orig_dl.prefetch_factor, + "persistent_workers": orig_dl.persistent_workers, + } + return self.dataloader_settings + +class RARP_Dataset(Dataset): + def __init__(self, RARP_dataset, indices, transform=None) -> None: + super().__init__() + self.transform = transform + self.samples = Subset(RARP_dataset, indices) + self.targets = [s[1] for s in self.samples] + self.classes = ["NO_NVB", "NVB"] ## **** Hacer esta parte correctamente */*** + + def __len__(self): + return len(self.samples) + + def __getitem__(self, index): + img, label = self.samples[index] + + if self.transform is not None: + img = self.transform(img) + + return (img, label) + +class RARP_ChannelSwap(torch.nn.Module): + def __init__(self) -> None: + super().__init__() + + def forward(self, img): + # It is assumed that the input image is in RGB format. + Channels = [0, 1, 2] + np.random.shuffle(Channels) + + return img[Channels] + +class RARP_Invert(torch.nn.Module): + def __init__(self, *args, **kwargs) -> None: + super().__init__(*args, **kwargs) + + def forward(self, img): + return 255 - img + +class RARP_DINO_Augmentation(): + def __init__( + self, + GloblaCropsScale=(0.4, 1), + LocalCropsScale=(0.05, 0.4), + NumLocalCrops:int=8, + Size:int=224, + device = None, + mean:float = None, + std:float = None, + Tranform_0 = None + ) -> None: + self.NumLocal_Crops= NumLocalCrops + + self.globalCrop1 = torch.nn.Sequential( + torchvision.transforms.RandomResizedCrop( + Size, + scale=GloblaCropsScale, + antialias=True, + interpolation=torchvision.transforms.InterpolationMode.BICUBIC + ), + torchvision.transforms.RandomHorizontalFlip(0.5), + torchvision.transforms.RandomErasing(0.2, value="random"), + #torchvision.transforms.RandomApply([ + # RARP_ChannelSwap() + #]), + torchvision.transforms.GaussianBlur(kernel_size=5, sigma=(0.1, 2)), + torchvision.transforms.Normalize(mean, std) + ).to(device) + + self.globalCrop2 = torch.nn.Sequential( + torchvision.transforms.RandomResizedCrop( + Size, + scale=GloblaCropsScale, + antialias=True, + interpolation=torchvision.transforms.InterpolationMode.BICUBIC + ), + torchvision.transforms.RandomHorizontalFlip(0.5), + torchvision.transforms.RandomErasing(0.8, value="random"), + #torchvision.transforms.RandomApply([ + # RARP_ChannelSwap() + #]), + torchvision.transforms.RandomApply([ + torchvision.transforms.GaussianBlur(kernel_size=5, sigma=(0.1, 2)) + ], 0.1), + torchvision.transforms.RandomApply([ + RARP_Invert() + ], 0.2), + torchvision.transforms.Normalize(mean, std) + ).to(device) + + self.local = torch.nn.Sequential( + torchvision.transforms.RandomResizedCrop( + Size, + scale=LocalCropsScale, + antialias=True, + interpolation=torchvision.transforms.InterpolationMode.BICUBIC + ), + torchvision.transforms.RandomHorizontalFlip(0.5), + torchvision.transforms.RandomErasing(0.5, value="random"), + #torchvision.transforms.RandomApply([ + # RARP_ChannelSwap() + #]), + torchvision.transforms.RandomApply([ + torchvision.transforms.GaussianBlur(kernel_size=5, sigma=(0.1, 2)) + ], 0.5), + torchvision.transforms.Normalize(mean, std) + ).to(device) + + InitResize = (256,256) + self.classification = torch.nn.Sequential( + torchvision.transforms.Resize( + InitResize, + antialias=True, + interpolation=torchvision.transforms.InterpolationMode.BICUBIC + ), + torchvision.transforms.CenterCrop(224), + torchvision.transforms.RandomAffine( + degrees=(-5, 5), scale=(0.9, 1.1), fill=5 + ), + torchvision.transforms.RandomHorizontalFlip(1.0), + torchvision.transforms.Normalize(mean, std), + ).to(device) if Tranform_0 == None else Tranform_0 + + def __call__(self, img): + all_Crops = [] + all_Crops.append(self.classification(img)) + all_Crops.append(self.globalCrop1(img)) + all_Crops.append(self.globalCrop2(img)) + + all_Crops.extend([self.local(img) for _ in range(self.NumLocal_Crops)]) + + return all_Crops + +class RARP_DataSetType(Enum): + train = 0 + val = 1 + test = 2 + +class RandomVideoDataset(torch.utils.data.IterableDataset): + def __init__(self, root, epoch_size=None, frame_transform=None, video_transform=None, clip_len=16): + super().__init__() + + self.samples = get_samples(root) + + # Allow for temporal jittering + if epoch_size is None: + epoch_size = len(self.samples) + self.epoch_size = epoch_size + + self.clip_len = clip_len + self.frame_transform = frame_transform + self.video_transform = video_transform + + def __iter__(self): + for i in range(self.epoch_size): + # Get random sample + path, target = np.random.choice(self.samples) + # Get video object + vid = torchvision.io.VideoReader(path, "video") + metadata = vid.get_metadata() + video_frames = [] # video frame buffer + + # Seek and return frames + max_seek = metadata["video"]['duration'][0] - (self.clip_len / metadata["video"]['fps'][0]) + start = np.random.uniform(0., max_seek) + for frame in itertools.islice(vid.seek(start), self.clip_len): + video_frames.append(self.frame_transform(frame['data'])) + current_pts = frame['pts'] + # Stack it into a tensor + video = torch.stack(video_frames, 0) + if self.video_transform: + video = self.video_transform(video) + output = { + 'path': path, + 'video': video, + 'target': target, + 'start': start, + 'end': current_pts} + yield output + +class VideoDataset(Dataset): + def __init__(self, time_depth, mean, std, transform=None) -> None: + super().__init__() + +class RARPDataset(Dataset): + def __init__(self, path_RARP_dataset:Path, path_RARP_Folds:Path=None, split=0, DataSetType:RARP_DataSetType="train", transform=None) -> None: + super().__init__() + self.samples = pd.read_csv(path_RARP_dataset, usecols=["id", "label", "class", "path"]) + self.classes = self.samples["class"].unique().tolist() + self.targets = self.samples["label"].to_list() + self.IDsplit = None + self.transform = transform + + if path_RARP_Folds is not None: + if split is None: + raise Exception("Is required the split index to do Folds") + + arrFolds = np.load(path_RARP_Folds, allow_pickle=True) + self.IDsplit = np.array_split(arrFolds, len(arrFolds)/3)[split][DataSetType.value] + + self.samples = self.samples.loc[self.samples["id"].isin(self.IDsplit)] + self.targets = self.samples["label"] + + def __len__(self): + return self.samples.shape[0] + + def __getitem__(self, index): + ID = index + if self.IDsplit is not None: + ID = self.IDsplit[index] + + rs = self.samples.loc[self.samples["id"] == ID] + + img = defs.load_file_tensor(rs["path"].item()) + label = rs["label"].item() + + if self.transform is not None: + img = self.transform(img) + + return img, label diff --git a/Models.py b/Models.py new file mode 100644 index 0000000..c3c7bf1 --- /dev/null +++ b/Models.py @@ -0,0 +1,1833 @@ +import math +from typing import Any, Union +import torch +import torchvision +import torchmetrics +import lightning as L +from enum import Enum +import timm +import van +import numpy as np + + +def js_divergence_sigmoid(p_logits, q_logits): + p_probs = torch.sigmoid(p_logits) + q_probs = torch.sigmoid(q_logits) + + m = 0.5 * (p_probs + q_probs) + + bce_p_m = torch.nn.functional.binary_cross_entropy(m, p_probs, reduction='none') + bce_q_m = torch.nn.functional.binary_cross_entropy(m, q_probs, reduction='none') + + js_div = 0.5 * (bce_p_m + bce_q_m) + + return js_div + +def getNVL(obj:dict, key, default): + return default if obj.get(key) is None else obj.get(key) + +class Decoder (torch.nn.Module): + def __init__(self, input_channels=2048, output_channels=3, num_blocks=4, hidden_channels=[1024, 512, 256, 64], *args, **kwargs): + super().__init__(*args, **kwargs) + + assert len(hidden_channels) == num_blocks, "Number of hidden channels must match the number of blocks." + + self.Activation = torch.nn.ReLU#torch.nn.GELU + self.input_channels = input_channels + + blocks = [] + + inCh = input_channels + + blocks.append(torch.nn.Conv2d(inCh, inCh, kernel_size=3, stride=1, padding=1, bias=False)) + blocks.append(torch.nn.BatchNorm2d(inCh)) + blocks.append(self.Activation()) + + for i, outCh in enumerate(hidden_channels): + blocks.append(torch.nn.ConvTranspose2d(inCh, outCh, kernel_size=4, stride=2, padding=1, bias=False)) + blocks.append(torch.nn.BatchNorm2d(outCh)) + blocks.append(self.Activation()) + blocks.append(torch.nn.Conv2d(outCh, outCh, kernel_size=3, stride=1, padding=1, bias=False)) + blocks.append(torch.nn.BatchNorm2d(outCh)) + blocks.append(self.Activation()) + + #blocks.append(torch.nn.ConvTranspose2d(inCh, outCh, kernel_size=3, stride=2, padding=1, output_padding=1)) + #blocks.append(torch.nn.BatchNorm2d(outCh)) + #blocks.append(self.Activation()) + inCh = outCh + + blocks.append(torch.nn.ConvTranspose2d(inCh, output_channels, kernel_size=4, stride=2, padding=1, bias=False)) + blocks.append(torch.nn.BatchNorm2d(output_channels)) + blocks.append(self.Activation()) + blocks.append(torch.nn.Conv2d(output_channels, output_channels, kernel_size=3, stride=1, padding=1, bias=False)) + blocks.append(torch.nn.BatchNorm2d(output_channels)) + blocks.append(self.Activation()) + + #blocks.append(torch.nn.ConvTranspose2d(inCh, output_channels, kernel_size=3, stride=2, padding=1, output_padding=1)) + + self.decoder = torch.nn.Sequential(*blocks) + + def forward(self, x): + + x = self.decoder(x) + return x + +class DynamicDecoder(torch.nn.Module): + def __init__(self, input_channels=2048, output_channels=3, num_blocks=4, hidden_channels=[1024, 512, 256, 64]): + super(DynamicDecoder, self).__init__() + + # Ensure the number of hidden channels matches the number of blocks + assert len(hidden_channels) == num_blocks, "Number of hidden channels must match the number of blocks." + + layers = [] + in_channels = input_channels + + # Loop to create the decoder blocks + for out_channels in hidden_channels: + layers.append(torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size=3, stride=2, padding=1, output_padding=1)) + layers.append(torch.nn.BatchNorm2d(out_channels)) + layers.append(torch.nn.ReLU(inplace=True)) + in_channels = out_channels + + # Final layer to get the output image + layers.append(torch.nn.ConvTranspose2d(in_channels, output_channels, kernel_size=3, stride=2, padding=1, output_padding=1)) + layers.append(torch.nn.Sigmoid()) # To get pixel values between 0 and 1 + + # Combine all layers into a Sequential module + self.decoder = torch.nn.Sequential(*layers) + + def forward(self, x): + return self.decoder(x) + + + +class ModelsList(Enum): + RestNet50 = 1 + DenseNet169 = 2 + Efficientnet_b0 = 3 + MobileNetV2 = 4 + Inception3 = 5 + ResNeXt_50_32x4d = 6 + RestNet50_Droput = 7 + +class TypeLossFunction(Enum): + CrossEntropy = 0 + BCEWithLogits = 1 + HingeLoss = 2 + FocalLoss = 3 + ContrastiveLoss = 4 + + +class FeatureAlignmentLoss(torch.nn.Module): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def forward(self, F_student, F_teacher): + fS = torch.nn.functional.normalize(F_student, p=2, dim=-1) + fT = torch.nn.functional.normalize(F_teacher, p=2, dim=-1) + + cos_Sim = torch.sum(fS * fT, dim=-1) + + loss = 1 - cos_Sim + + return loss.mean() + +class CosineAnnealingLR(torch.optim.lr_scheduler._LRScheduler): + def __init__( + self, + optimizer: torch.optim.Optimizer, + warmup_epochs: int, + max_epochs: int, + warmup_start_lr: float = 0.00001, + eta_min: float = 0.00001, + last_epoch: int = -1, + ): + """ + Args: + optimizer (torch.optim.Optimizer): + 最適化手法インスタンス + warmup_epochs (int): + linear warmupを行うepoch数 + max_epochs (int): + cosine曲線の終了に用いる 学習のepoch数 + warmup_start_lr (float): + linear warmup 0 epoch目の学習率 + eta_min (float): + cosine曲線の下限 + last_epoch (int): + cosine曲線の位相オフセット + 学習率をmax_epochsに至るまでコサイン曲線に沿ってスケジュールする + epoch 0からwarmup_epochsまでの学習曲線は線形warmupがかかる + https://pytorch-lightning-bolts.readthedocs.io/en/stable/schedulers/warmup_cosine_annealing.html + """ + self.warmup_epochs = warmup_epochs + self.max_epochs = max_epochs + self.warmup_start_lr = warmup_start_lr + self.eta_min = eta_min + super().__init__(optimizer, last_epoch, verbose=False) + return None + + def get_lr(self): + if self.last_epoch == 0: + return [self.warmup_start_lr] * len(self.base_lrs) + if self.last_epoch < self.warmup_epochs: + return [ + group["lr"] + (base_lr - self.warmup_start_lr) / (self.warmup_epochs - 1) + for base_lr, group in zip(self.base_lrs, self.optimizer.param_groups) + ] + if self.last_epoch == self.warmup_epochs: + return self.base_lrs + if (self.last_epoch - 1 - self.max_epochs) % (2 * (self.max_epochs - self.warmup_epochs)) == 0: + return [ + group["lr"] + (base_lr - self.eta_min) * (1 - math.cos(math.pi / (self.max_epochs - self.warmup_epochs))) / 2 + for base_lr, group in zip(self.base_lrs, self.optimizer.param_groups) + ] + + return [ + (1 + math.cos(math.pi * (self.last_epoch - self.warmup_epochs) / (self.max_epochs - self.warmup_epochs))) + / (1 + math.cos(math.pi * (self.last_epoch - self.warmup_epochs - 1) / (self.max_epochs - self.warmup_epochs))) + * (group["lr"] - self.eta_min) + + self.eta_min + for group in self.optimizer.param_groups + ] + +class ContrastiveLoss(torch.nn.Module): + def __init__(self, margin=1.0, distance:int = 0): + super(ContrastiveLoss, self).__init__() + self.margin = margin + self.TypeDistance = distance + + def forward(self, output1, output2, label): + # Calcula la distancia euclidiana entre las dos salidas + Distance = torch.nn.functional.pairwise_distance(output1, output2) + + # Calcula la pérdida contrastiva + loss_contrastive = torch.mean( + (1 - label) * torch.pow(Distance, 2) + + (label) * torch.pow(torch.clamp(self.margin - Distance, min=0.0), 2) + ) + + return loss_contrastive + +class GradCAM: + def __init__(self, model, target_layer): + self.model = model + self.target_layer = target_layer + self.gradients = None + self.activations = None + self.hook() + + def hook(self): + def forward_hook(module, Input, Output): + self.activations = Output + + def backward_hook(module, grad_in, grad_out): + self.gradients = grad_out[0] + + self.target_layer.register_forward_hook(forward_hook) + self.target_layer.register_backward_hook(backward_hook) + + def generate_cam(self, data:torch.Tensor, target_class): + self.model.zero_grad() + data.requires_grad= True + output = self.model(data).flatten() + loss = torch.nn.functional.binary_cross_entropy_with_logits(output, target_class) + loss.backward() + + pooled_Grad = torch.mean(self.gradients, dim=[0, 2, 3]) + for i in range (pooled_Grad.size(0)): + self.activations[:, i, :, :] *= pooled_Grad[i] + + cam = torch.mean(self.activations, dim=1).squeeze() + cam = np.maximum(cam.detach().numpy(), 0) + cam = (cam - cam.min()) / (cam.max() - cam.min()) + return cam + +class RARP_NVB_ResNet50_CAM(L.LightningModule): + def __init__(self) -> None: + super().__init__() + + self.model = torchvision.models.resnet50() + tempFC_ft = self.model.fc.in_features + self.model.fc = torch.nn.Linear(in_features=tempFC_ft, out_features=1) + + self.feature_map = torch.nn.Sequential(*list(self.model.children())[:-2]) + + def forward(self, data): + featureMap = self.feature_map(data) + Cont_Net = torch.nn.functional.adaptive_avg_pool2d(input=featureMap, output_size=(1, 1)) + Cont_Net = torch.flatten(Cont_Net, 1) + + pred = self.model.fc(Cont_Net) + + return pred, featureMap + +class RARP_NVB_VAN_CAM(L.LightningModule): #TODO + def __init__(self) -> None: + super().__init__() + + self.model = van.van_b2(pretrained = True) + tempFC_ft = self.model.head.in_features + self.model.head = torch.nn.Linear(in_features=tempFC_ft, out_features=1) + + self.feature_map = torch.nn.Sequential(*list(self.model.children())[:-2]) + + + def forward(self, data, label:torch.Tensor): + + cams = GradCAM(self.model, self.model.block4[-1]) + featureMap = cams.generate_cam(data, label) + + pred = self.model(featureMap) + + + return pred, featureMap + +class RARP_NVB_ResNet18_CAM(L.LightningModule): + def __init__(self) -> None: + super().__init__() + + self.model = torchvision.models.resnet18() + tempFC_ft = self.model.fc.in_features + self.model.fc = torch.nn.Linear(in_features=tempFC_ft, out_features=1) + + self.feature_map = torch.nn.Sequential(*list(self.model.children())[:-2]) + + def forward(self, data): + featureMap = self.feature_map(data) + Cont_Net = torch.nn.functional.adaptive_avg_pool2d(input=featureMap, output_size=(1, 1)) + Cont_Net = torch.flatten(Cont_Net) + + pred = self.model.fc(Cont_Net) + + return pred, featureMap + +class RARP_NVB_MobileNetV2_CAM(L.LightningModule): + def __init__(self) -> None: + super().__init__() + + self.model = torchvision.models.mobilenet_v2() + tempFC_ft = self.model.classifier[1].in_features + self.model.classifier[1] = torch.nn.Linear(in_features=tempFC_ft, out_features=1) + + self.feature_map = self.model.features + + def forward(self, data): + featureMap = self.feature_map(data) + Cont_Net = torch.nn.functional.adaptive_avg_pool2d(featureMap, (1, 1)) + Cont_Net = torch.flatten(Cont_Net, 1) + + pred = self.model.classifier(Cont_Net) + + return pred, featureMap + +class RARP_NVB_EfficientNetV2_CAM(L.LightningModule): + def __init__(self) -> None: + super().__init__() + + self.model = torchvision.models.efficientnet_v2_s(weights=torchvision.models.EfficientNet_V2_S_Weights.DEFAULT) + tempFC_ft = self.model.classifier[1].in_features + self.model.classifier[1] = torch.nn.Linear(in_features=tempFC_ft, out_features=1) + + self.feature_map = self.model.features + + def forward(self, data): + featureMap = self.feature_map(data) + Cont_Net = torch.nn.functional.adaptive_avg_pool2d(featureMap, (1, 1)) + Cont_Net = torch.flatten(Cont_Net, 1) + + pred = self.model.classifier(Cont_Net) + + return pred, featureMap + +class RARP_NVB_Model_BCEWithLogitsLoss(L.LightningModule): + def __init__(self, x=None) -> None: + super().__init__() + + self.model = None + + self.lossFN = torch.nn.BCEWithLogitsLoss() #pos_weight=torch.tensor([2.73]) + + self.train_acc = torchmetrics.Accuracy('binary') + self.val_acc = torchmetrics.Accuracy('binary') + self.test_acc = torchmetrics.Accuracy('binary') + self.f1Score = torchmetrics.F1Score('binary') + self.f1ScoreTest = torchmetrics.F1Score('binary') + + def forward(self, data): + data = data.float() + return self.model(data) + + def _shared_step(self, batch): + img, label = batch + label = label.float() + pred = self.forward(img).flatten() + loss = self.lossFN(pred, label) + + predicted_labels = torch.sigmoid(pred) + + return loss, label, predicted_labels + + def training_step(self, batch, batch_idx): + loss, true_labels, predicted_labels = self._shared_step(batch) + + self.log("train_loss", loss) + self.train_acc.update(predicted_labels, true_labels) + self.log("train_acc", self.train_acc, on_epoch=True, on_step=False) + + return loss + + def validation_step(self, batch, batch_idx): + loss, true_labels, predicted_labels = self._shared_step(batch) + self.log("val_loss", loss) + self.val_acc(predicted_labels, true_labels) + self.f1Score(predicted_labels, true_labels) + self.log("val_acc", self.val_acc, on_epoch=True, on_step=False, prog_bar=True) + self.log("val_f1", self.f1Score, on_epoch=True, on_step=False, prog_bar=True) + + return loss + + def test_step(self, batch, batch_idx): + loss, true_labels, predicted_labels = self._shared_step(batch) + self.test_acc(predicted_labels, true_labels) + self.f1ScoreTest(predicted_labels, true_labels) + self.log("test_acc", self.test_acc, on_epoch=True, on_step=False) + self.log("test_f1", self.f1ScoreTest, on_epoch=True, on_step=False) + + def configure_optimizers(self): + optimizer = torch.optim.Adam(self.model.parameters(), lr=1e-4) + return [optimizer] + +class RARP_NVB_FOCAL_loss(torch.nn.Module): + def __init__(self, alpha: float = 0.25, gamma: float = 2, reduction: str = "mean"): + super().__init__() + self.alpha = alpha + self.gamma = gamma + self.reduction = reduction + + def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor: + return torchvision.ops.focal_loss.sigmoid_focal_loss(input, target, self.alpha, self.gamma, self.reduction) + +#TODO +class RARP_NVB_MultiClassModel(L.LightningModule): + def __init__(self, + InitWeight = torch.tensor([1,1]), + schedulerLR:bool=False, + lr:float = 1e-4, + Model:torch.nn.Module = None + ) -> None: + super().__init__() + + self.model = Model + self.lossFN = torch.nn.CrossEntropyLoss() + self.InitWeight = InitWeight + self.scheduler = schedulerLR + self.lr = lr + self.Lambda_L1 = 1.31E-04 + self.Lambda_L2 = 0 + + self.train_acc = torchmetrics.Accuracy("multiclass", num_classes=2) + self.val_acc = torchmetrics.Accuracy("multiclass", num_classes=2) + self.test_acc = torchmetrics.Accuracy("multiclass", num_classes=2) + self.f1ScoreTest = torchmetrics.F1Score("multiclass", num_classes=2) + + def forward(self, data): + data = data.float() + pred = self.model(data) + return pred + + def _shared_step(self, batch): + img, label = batch + #label = label.float() + prediction = self(img) #.flatten() + predicted_labels = torch.softmax(prediction, dim=1) + loss = self.lossFN(prediction, label) + + if self.Lambda_L1 is not None: + loss_l1 = 0 + for params in self.parameters(): + loss_l1 += torch.sum(torch.abs(params)) + loss += self.Lambda_L1 * loss_l1 + + return loss, label, predicted_labels + + def training_step(self, batch, batch_idx): + loss, true_labels, predicted_labels = self._shared_step(batch) + + self.log("train_loss", loss, on_epoch=True) + self.train_acc.update(predicted_labels, true_labels) + self.log("train_acc", self.train_acc, on_epoch=True, on_step=False) + + return loss + + def validation_step(self, batch, batch_idx): + loss, true_labels, predicted_labels = self._shared_step(batch) + self.log("val_loss", loss, on_epoch=True, on_step=False, prog_bar=True) + self.val_acc.update(predicted_labels, true_labels) + self.log("val_acc", self.val_acc, on_epoch=True, on_step=False, prog_bar=True) + + def test_step(self, batch, batch_idx): + loss, true_labels, predicted_labels = self._shared_step(batch) + self.test_acc.update(predicted_labels, true_labels) + self.f1ScoreTest.update(predicted_labels, true_labels) + self.log("test_acc", self.test_acc, on_epoch=True, on_step=False) + self.log("test_f1", self.f1ScoreTest, on_epoch=True, on_step=False) + + def configure_optimizers(self): + optimizer = torch.optim.Adam(self.parameters(), lr=self.lr, weight_decay=self.Lambda_L2) + if self.scheduler: + #scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode="min", patience=1, verbose=True, factor=0.1) + scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, 6, eta_min=1e-8, verbose=True) + return { + "optimizer": optimizer, + "lr_scheduler": { + "scheduler": scheduler, + #"monitor": "val_loss", + } + } + else: + return [optimizer] + +class RARP_NVB_Model(L.LightningModule): + def __init__(self, + InitWeight = torch.tensor([1,1]), + typeLossFN:TypeLossFunction = TypeLossFunction.CrossEntropy, + schedulerLR:bool=True, + lr:float = 1e-4 + ) -> None: + super().__init__() + + self.model = None + self.lossFN = torch.nn.CrossEntropyLoss(label_smoothing=0.5) if typeLossFN == TypeLossFunction.CrossEntropy else torch.nn.BCEWithLogitsLoss() + self.InitWeight = InitWeight + self.scheduler = schedulerLR + self.lr = lr + self.Lambda_L1 = None #1.31E-04 # + self.Lambda_L2 = 0 + + print (f"LR= {self.lr}, L1= {self.Lambda_L1}") + + self.train_acc = torchmetrics.Accuracy('binary') + self.val_acc = torchmetrics.Accuracy('binary') + self.test_acc = torchmetrics.Accuracy('binary') + #self.f1Score = torchmetrics.F1Score('binary') + self.f1ScoreTest = torchmetrics.F1Score('binary') + + def forward(self, data): + data = data.float() + pred = self.model(data) + return pred + + def _shared_step(self, batch): + img, label = batch + if self.InitWeight is not None: + self.lossFN.weight = self.InitWeight[label] + + label = label.float() + prediction = self(img)[:,0] #.flatten() + loss = self.lossFN(prediction, label) + + if self.Lambda_L1 is not None: + loss_l1 = 0 + for params in self.parameters(): + loss_l1 += torch.sum(torch.abs(params)) + loss += self.Lambda_L1 * loss_l1 + + predicted_labels = torch.sigmoid(prediction) + + return loss, label, predicted_labels + + def training_step(self, batch, batch_idx): + loss, true_labels, predicted_labels = self._shared_step(batch) + + self.log("train_loss", loss, on_epoch=True) + self.train_acc.update(predicted_labels, true_labels) + self.log("train_acc", self.train_acc, on_epoch=True, on_step=False) + + return loss + + def validation_step(self, batch, batch_idx): + loss, true_labels, predicted_labels = self._shared_step(batch) + self.log("val_loss", loss, on_epoch=True, on_step=False, prog_bar=True) + self.val_acc.update(predicted_labels, true_labels) + #self.f1Score.update(predicted_labels, true_labels) + self.log("val_acc", self.val_acc, on_epoch=True, on_step=False, prog_bar=True) + self.log("hp_metric", self.val_acc, on_step=False, on_epoch=True) + #self.log("val_f1", self.f1Score, on_epoch=True, on_step=False, prog_bar=True) + + def test_step(self, batch, batch_idx): + loss, true_labels, predicted_labels = self._shared_step(batch) + self.test_acc.update(predicted_labels, true_labels) + self.f1ScoreTest.update(predicted_labels, true_labels) + self.log("test_acc", self.test_acc, on_epoch=True, on_step=False) + self.log("test_f1", self.f1ScoreTest, on_epoch=True, on_step=False) + + def configure_optimizers(self): + optimizer = torch.optim.Adam(self.parameters(), lr=self.lr, weight_decay=self.Lambda_L2) + if self.scheduler: + #scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode="min", patience=1, verbose=True, factor=0.1) + scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, 6, eta_min=1e-8, verbose=True) + return { + "optimizer": optimizer, + "lr_scheduler": { + "scheduler": scheduler, + #"monitor": "val_loss", + } + } + else: + return optimizer + +class RARP_Ensemble(L.LightningModule): + def __init__(self, ListModels, + InitWeight = torch.tensor([1,1]), + typeLossFN:TypeLossFunction = TypeLossFunction.CrossEntropy, + schedulerLR:bool=False, + lr:float = 1e-4) -> None: + super().__init__() + + self.ListModels = ListModels + #for m in self.ListModels: + # m.freeze() + input_p = len(self.ListModels) + + self.classifier = torch.nn.Sequential( + torch.nn.Linear(in_features=input_p, out_features=128), + torch.nn.SiLU(), + #torch.nn.Dropout(0.1), #0.5 + torch.nn.Linear(128, 1), + torch.nn.Sigmoid() + ) + + self.lossFN = torch.nn.CrossEntropyLoss(label_smoothing=0.5) if typeLossFN == TypeLossFunction.CrossEntropy else torch.nn.BCELoss(reduction="sum") + self.InitWeight = InitWeight + self.scheduler = schedulerLR + self.lr = lr + + self.train_acc = torchmetrics.Accuracy('binary') + self.val_acc = torchmetrics.Accuracy('binary') + self.test_acc = torchmetrics.Accuracy('binary') + self.f1Score = torchmetrics.F1Score('binary') + self.f1ScoreTest = torchmetrics.F1Score('binary') + + def forward(self, data): + data = data.float() + p = [m(data) for m in self.ListModels] + p = torch.cat(p, dim=1) + x = self.classifier(p) + return x + + def _shared_step(self, batch): + img, label = batch + if self.InitWeight is not None: + self.lossFN.weight = self.InitWeight[label] + + label = label.float() + prediction = self(img)[:,0] #.flatten() + loss = self.lossFN(prediction, label) + predicted_labels = prediction + + return loss, label, predicted_labels + + def training_step(self, batch, batch_idx): + loss, true_labels, predicted_labels = self._shared_step(batch) + + self.log("train_loss", loss, on_epoch=True) + self.train_acc.update(predicted_labels, true_labels) + self.log("train_acc", self.train_acc, on_epoch=True, on_step=False) + + return loss + + def validation_step(self, batch, batch_idx): + loss, true_labels, predicted_labels = self._shared_step(batch) + self.log("val_loss", loss, on_epoch=True, on_step=False, prog_bar=True) + self.val_acc.update(predicted_labels, true_labels) + self.f1Score.update(predicted_labels, true_labels) + self.log("val_acc", self.val_acc, on_epoch=True, on_step=False, prog_bar=True) + self.log("val_f1", self.f1Score, on_epoch=True, on_step=False, prog_bar=True) + + return loss + + def test_step(self, batch, batch_idx): + loss, true_labels, predicted_labels = self._shared_step(batch) + self.test_acc.update(predicted_labels, true_labels) + self.f1ScoreTest.update(predicted_labels, true_labels) + self.log("test_acc", self.test_acc, on_epoch=True, on_step=False) + self.log("test_f1", self.f1ScoreTest, on_epoch=True, on_step=False) + + def configure_optimizers(self): + optimizer = torch.optim.Adam(self.parameters(), lr=self.lr) + if self.scheduler: + #scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode="min", patience=1, verbose=True, factor=0.1) + scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, 6, 1e-8, verbose=True) + return { + "optimizer": optimizer, + "lr_scheduler": { + "scheduler": scheduler, + #"monitor": "val_loss", + } + } + else: + return [optimizer] + +class RARP_NVB_ResNet18(RARP_NVB_Model): + def __init__(self, InitWeight=None, TypeLoss=TypeLossFunction.CrossEntropy, **kwargs) -> None: + super().__init__(InitWeight, TypeLoss, **kwargs) + + self.model = torchvision.models.resnet18(weights=torchvision.models.ResNet18_Weights.DEFAULT) + tempFC_ft = self.model.fc.in_features + self.model.fc = torch.nn.Linear(in_features=tempFC_ft, out_features=1) + +class RARP_NVB_DaVit(RARP_NVB_Model): + def __init__(self, InitWeight=None, TypeLoss=TypeLossFunction.CrossEntropy, **kwargs) -> None: + super().__init__(InitWeight, TypeLoss, **kwargs) + + self.model = timm.create_model("davit_small.msft_in1k", pretrained=True, num_classes=1) + +class RARP_NVB_EfficientNetV2_Deep(RARP_NVB_Model): + def __init__(self, InitWeight=None, TypeLoss=TypeLossFunction.CrossEntropy, **kwargs) -> None: + super().__init__(InitWeight, TypeLoss, **kwargs) + + self.model = torchvision.models.efficientnet_v2_s(weights=torchvision.models.EfficientNet_V2_S_Weights.DEFAULT) + tempFC_ft = self.model.classifier[1].in_features + self.model.classifier[1] = torch.nn.Linear(in_features=tempFC_ft, out_features=128) + + self.model.classifier.append(torch.nn.SiLU(True)) + self.model.classifier.append(torch.nn.Linear(128, 8)) + self.model.classifier.append(torch.nn.SiLU(True)) + self.model.classifier.append(torch.nn.Linear(8, 1)) + +class RARP_NVB_ResNet50_Deep(RARP_NVB_Model): + def __init__(self, InitWeight=None, TypeLoss=TypeLossFunction.CrossEntropy, **kwargs) -> None: + super().__init__(InitWeight, TypeLoss, **kwargs) + + self.model = torchvision.models.resnet50(weights=torchvision.models.ResNet50_Weights.DEFAULT) + tempFC_ft = self.model.fc.in_features + self.model.fc = torch.nn.Sequential( + torch.nn.Dropout(0.2), + torch.nn.Linear(in_features=tempFC_ft, out_features=128), + torch.nn.SiLU(True), + torch.nn.Linear(128, 8), + torch.nn.SiLU(True), + torch.nn.Linear(8, 1) + ) + + def forward(self, img): + img = img.float() + pred = self.model(img) + return pred + +class RARP_NVB_ResNet50_Deep_OPTuna(RARP_NVB_Model): + def __init__(self, InitWeight=None, TypeLoss=TypeLossFunction.CrossEntropy, output_dims=[128, 8], dropuot=0.2, **kwargs) -> None: + super().__init__(InitWeight, TypeLoss, **kwargs) + + layers = [] + self.model = torchvision.models.resnet50(weights=torchvision.models.ResNet50_Weights.DEFAULT) + + inputDim = self.model.fc.in_features + + for outputDim in output_dims: + layers.append(torch.nn.Linear(inputDim, outputDim)) + layers.append(torch.nn.SiLU(True)) + layers.append(torch.nn.Dropout(dropuot)) + inputDim = outputDim + + layers.append(torch.nn.Linear(inputDim, 1)) + + self.model.fc = torch.nn.Sequential(*layers) + + def forward(self, img): + img = img.float() + pred = self.model(img) + return pred + +class RARP_NVB_ResNet50_V2(RARP_NVB_Model): + def __init__(self, InitWeight=None, TypeLoss=TypeLossFunction.CrossEntropy, InputNeurons:int = 8, **kwargs) -> None: + super().__init__(InitWeight, TypeLoss, **kwargs) + + self.model = torchvision.models.resnet50(weights=torchvision.models.ResNet50_Weights.DEFAULT) + tempFC_ft = self.model.fc.in_features + self.model.fc = torch.nn.Sequential( + torch.nn.Dropout(0.2), + torch.nn.Linear(in_features=tempFC_ft, out_features=128), + torch.nn.SiLU(True), + torch.nn.Linear(128, 8) + ) + self.model.fc2 = torch.nn.Linear(8 + InputNeurons, 1) + + def forward(self, data): + img, extra = data + img = img.float() + x = torch.nn.functional.silu(self.model(img), True) + extradata = torch.concat((x, extra), dim=1) + pred = self.model.fc2(extradata) + + return pred + +class RARP_NVB_ResNet50_V3(RARP_NVB_Model): + def __init__(self, InitWeight=None, TypeLoss=TypeLossFunction.CrossEntropy, InputNeurons:int = 8, **kwargs) -> None: + super().__init__(InitWeight, TypeLoss, **kwargs) + + self.model = torchvision.models.resnet50(weights=torchvision.models.ResNet50_Weights.DEFAULT) + tempFC_ft = self.model.fc.in_features + self.model.fc = torch.nn.Linear(in_features=tempFC_ft, out_features=128) + + self.model.extraFC = torch.nn.Linear(InputNeurons, 128) + + self.model.fc2 = torch.nn.Linear(256, 1) + + def forward(self, data): + img, extra = data + img = img.float() + + x = torch.nn.functional.silu(self.model(img), True) + y = torch.nn.functional.silu(self.model.extraFC(extra), True) + x = torch.concat((x, y), dim=1) + + pred = self.model.fc2(x) + + return pred + +class RARP_NVB_ResNet50_V1(RARP_NVB_Model): + def __init__(self, InitWeight=None, TypeLoss=TypeLossFunction.CrossEntropy, InputNeurons:int = 8, **kwargs) -> None: + super().__init__(InitWeight, TypeLoss, **kwargs) + + self.model = torchvision.models.resnet50(weights=torchvision.models.ResNet50_Weights.DEFAULT) + tempFC_ft = self.model.fc.in_features + InputNeurons + self.model.fc = torch.nn.Linear(in_features=tempFC_ft, out_features=1) + + self.Decoder = torch.nn.Sequential(*list(self.model.children())[:-2]) + + def forward(self, data): + img, extra = data + img = img.float() + featureMap = self.Decoder(img) + Cont_Net = torch.nn.functional.adaptive_avg_pool2d(input=featureMap, output_size=(1, 1)) + Cont_Net = torch.flatten(Cont_Net, 1) + + Cont_Net = torch.concat((Cont_Net, extra), dim=1) + + pred = self.model.fc(Cont_Net) + + return pred + +class RARP_NVB_VAN(RARP_NVB_Model): + def __init__(self, InitWeight=None, TypeLoss=TypeLossFunction.CrossEntropy, **kwargs) -> None: + super().__init__(InitWeight, TypeLoss, **kwargs) + + self.model = van.van_b2(pretrained = True) + tempFC_ft = self.model.head.in_features + self.model.head = torch.nn.Linear(in_features=tempFC_ft, out_features=1) + +class RARP_NVB_ResNet50(RARP_NVB_Model): + def __init__(self, InitWeight=None, TypeLoss=TypeLossFunction.CrossEntropy, **kwargs) -> None: + super().__init__(InitWeight, TypeLoss, **kwargs) + + self.model = torchvision.models.resnet50(weights=torchvision.models.ResNet50_Weights.DEFAULT) + tempFC_ft = self.model.fc.in_features + self.model.fc = torch.nn.Linear(in_features=tempFC_ft, out_features=1) + +class RARP_NVB_MLP(torch.nn.Module): + def __init__(self, in_dim, out_dim, hidden_dim=512, bottleneck=256, n_layers=3, norm_last_layer=False, *args, **kwargs) -> None: + super().__init__(*args, **kwargs) + + self.activationFN = torch.nn.GELU() + + if n_layers == 1: + self.mlp = torch.nn.Linear(in_dim, bottleneck) + else: + layers = [torch.nn.Linear(in_dim, hidden_dim)] + layers.append(torch.nn.Dropout(0.30)) + layers.append(self.activationFN) + for _ in range(n_layers - 2): + layers.append(torch.nn.Linear(hidden_dim, hidden_dim)) + layers.append(self.activationFN) + layers.append(torch.nn.Linear(hidden_dim, bottleneck)) + self.mlp = torch.nn.Sequential(*layers) + + self.apply(self._init_weights) + self.last_layer = torch.nn.utils.weight_norm( + torch.nn.Linear(bottleneck, out_dim, bias=False) + ) + self.last_layer.weight_g.data.fill_(1) + if norm_last_layer: + self.last_layer.weight_g.requires_grad = False + + def _init_weights(self, m): + if isinstance(m, torch.nn.Linear): + torch.nn.init.normal_(m.weight, std=0.02) + if m.bias is not None: + torch.nn.init.constant_(m.bias, 0) + + def forward(self, x): + x = self.mlp(x) + x = torch.nn.functional.normalize(x, dim=-1, p=2) + x = self.last_layer(x) + + return x + +class RARP_NVB_DINO_Wrapper(torch.nn.Module): + def __init__(self, backbone, new_head, *args, **kwargs) -> None: + super().__init__(*args, **kwargs) + self.backbone = backbone + self.head = new_head + + def forward(self, x): + if isinstance(x, list): + n_crops = len(x) + concatCrops = torch.cat(x, dim=0) + else: + concatCrops = x + n_crops = 1 + embedding = self.backbone(concatCrops) + logitis = self.head(embedding) + chunks = logitis.chunk(n_crops) + + return chunks + +class RARP_NVB_DINO_Loss(torch.nn.Module): + def __init__(self, out_dim:int, teacher_Thao:float = 0.04, student_Thao:float = 0.1, center_momentum:float = 0.9, *args, **kwargs) -> None: + super().__init__(*args, **kwargs) + self.S_Thao = student_Thao + self.T_Thao = teacher_Thao + self.C_Momentum = center_momentum + self.register_buffer("center", torch.zeros(1, out_dim)) + + def forward(self, s_Output, t_Output): + sTemp = [s / self.S_Thao for s in s_Output] + tTemp = [(t - self.center) / self.T_Thao for t in t_Output] + + studentSM = [torch.nn.functional.log_softmax(s, dim=-1) for s in sTemp] + teacherSM = [torch.nn.functional.softmax(t, dim=-1).detach() for t in tTemp] + + total_loss = 0 + n_loss_terms = 0 + + for t_ix, t in enumerate(teacherSM): + for s_ix, s in enumerate(studentSM): + if (t_ix == s_ix) and (len(teacherSM) > 1): + continue + + loss = torch.sum(-t * s, dim=-1) + total_loss += loss.mean() + n_loss_terms += 1 + + total_loss /= n_loss_terms + self.update_center(t_Output) + + return total_loss + + @torch.no_grad() + def update_center(self, t_output): + b = torch.cat(t_output).mean(dim=0, keepdim=True) + self.center = self.center * self.C_Momentum + b * (1 - self.C_Momentum) + +class RARP_NVB_DINO_RestNet50_Deep(L.LightningModule): + def __init__( + self, + PseudoEstimator: str = None, + threshold: float = 0.5, + TypeLoss=TypeLossFunction.CrossEntropy, + momentum_teacher:float = 0.9995, + lr:float = 1e-4, + L1:float = None, + L2:float = 0, + ) -> None: + super().__init__() + + self.lr = lr + self.Lambda_L1 = L1 + self.Lambda_L2 = L2 + self.threshold = threshold + self.momentum_teacher = momentum_teacher + self.out_dim = 512 + self.in_dim = 2048 + + self.train_acc = torchmetrics.Accuracy('binary') + self.val_acc = torchmetrics.Accuracy('binary') + self.test_acc = torchmetrics.Accuracy('binary') + self.f1ScoreTest = torchmetrics.F1Score('binary') + + self.teacher_Labels = RARP_NVB_ResNet50_Deep.load_from_checkpoint(PseudoEstimator, strict=False) if PseudoEstimator is not None else RARP_NVB_ResNet50_Deep() + self.student = torchvision.models.resnet50(weights=torchvision.models.ResNet50_Weights.DEFAULT) #torch.hub.load('facebookresearch/dino:main', 'dino_resnet50') + self.teacher_Features = torchvision.models.resnet50(weights=torchvision.models.ResNet50_Weights.DEFAULT) + + self.student.fc = torch.nn.Identity() + self.teacher_Features.fc = torch.nn.Identity() + + self.student = RARP_NVB_DINO_Wrapper( + self.student, + RARP_NVB_MLP(self.in_dim, self.out_dim, 1024) + ) + + self.teacher_Features = RARP_NVB_DINO_Wrapper( + self.teacher_Features, + RARP_NVB_MLP(self.in_dim, self.out_dim, 1024) + ) + + for parms in self.teacher_Labels.model.parameters(): + parms.requires_grad = False + + for parms in self.teacher_Features.parameters(): + parms.requires_grad = False + + self.lossFN_DINO = RARP_NVB_DINO_Loss(self.out_dim, 0.04, 0.1, momentum_teacher) + self.lossFN_KD = torch.nn.CrossEntropyLoss(label_smoothing=0.5) if TypeLoss == TypeLossFunction.CrossEntropy else torch.nn.BCEWithLogitsLoss() + + #self.lossFH_KLDiv = torch.nn.KLDivLoss(reduction="batchmean") + + self.clasiffier = torch.nn.Sequential( + torch.nn.Dropout(0.2), + torch.nn.Linear(self.out_dim, 128), + torch.nn.SiLU(True), + torch.nn.Linear(128, 8), + torch.nn.SiLU(True), + torch.nn.Linear(8, 1) + ) + + def forward(self, data, val_step:bool = True): + if val_step: + data = data.float() + dataClassificator, dataTeacher, dataStudent = data, data, data + else: + data = [d.float() for d in data] + dataClassificator, dataTeacher, dataStudent = data[0], data[1:3], data + + TeacherDino = self.teacher_Features(dataTeacher) + TeacherLabels = self.teacher_Labels(dataClassificator) + Student = self.student(dataStudent) + + # es se evaluan todas las salidas del estuidaitne + #if isinstance(dataStudent, list): + # #index = np.random.randint(0, len(dataStudent)) + # temp = self.student(dataStudent) + # CatS_Classifier = torch.cat(temp, dim=0) + # meanS_Classifier = torch.zeros(self.in_dim) + # for dataS in temp: + # meanS_Classifier += dataS + # #S_Classifier = self.student(dataStudent[index]) + # S_Classifier = meanS_Classifier / len(dataStudent) + #else: + # S_Classifier = Student + + Cont_Net = torch.cat(Student, dim=0) + + pred = self.clasiffier(Cont_Net) + + if not val_step: + TeacherLabels = [self.teacher_Labels(dataClassificator) for _ in range(len(dataStudent))] + TeacherLabels = torch.cat(TeacherLabels, dim=0) + + TeacherLabelsPred = torch.sigmoid(TeacherLabels.flatten()) + PseudoLabels = (TeacherLabelsPred > self.threshold) * 1.0 + + return (pred.flatten(), PseudoLabels, TeacherLabels.flatten()), (TeacherDino, Student) + + def _shared_step(self, batch, val_step:bool = False): + img, label = batch + + if not val_step: + label = torch.cat([label for _ in range(len(img))], dim=0) + + label = label.float() + KD_Prediction, DINO_Loss = self(img, val_step) + TeacherF, StudentF = DINO_Loss + prediction, PseudoLabels, teacherOutputs = KD_Prediction + + predicted_labels = torch.sigmoid(prediction) + + ##verstion 1 + W_Alpha, W_Beta = (1, 0.5)#(1, 0.5) + loss = W_Alpha * self.lossFN_KD(prediction, PseudoLabels) + W_Beta * self.lossFN_KD(prediction, label) + + #version 2 + #thao_KD = 1#5.0 + #W_Alpha, W_Beta = (0.6, 0.4) + + #softTeacher = torch.sigmoid(teacherOutputs/thao_KD) + #softStudent = torch.sigmoid(prediction/thao_KD) + + #loss_sl = torch.nn.functional.binary_cross_entropy(softStudent, softTeacher) + #loss_hl = self.lossFN_KD(prediction, label) + + #loss = W_Alpha * loss_hl + W_Beta * loss_sl + + #loss = W_Alpha * self.lossFN_KD(prediction, label) + W_Beta * (self.lossFH_KLDiv(softStudent, softTeacher) * (thao_KD ** 2)) + loss += (self.lossFN_DINO(StudentF, TeacherF) if not val_step else 0) + + if not val_step: + self.logger.experiment.add_histogram ("Teacher", TeacherF[0]) + self.logger.experiment.add_histogram ("Student", StudentF[1]) + + if self.Lambda_L1 is not None: + loss_l1 = 0 + for params in self.student.parameters(): # aqui + loss_l1 += torch.sum(torch.abs(params)) + loss += self.Lambda_L1 * loss_l1 + + #return loss, PseudoLabels, predicted_labels + return loss, label, predicted_labels + + def training_step(self, batch, batch_idx): + loss, true_labels, predicted_labels = self._shared_step(batch, False) + + self.log("train_loss", loss, on_epoch=True) + self.train_acc.update(predicted_labels, true_labels) + self.log("train_acc", self.train_acc, on_epoch=True, on_step=False) + + return loss + + def on_train_batch_end(self, outputs, batch, batch_idx): + with torch.no_grad(): + for student_ps, teacher_ps in zip(self.student.parameters(), self.teacher_Features.parameters()): + teacher_ps.data.mul_(self.momentum_teacher) + teacher_ps.data.add_((1-self.momentum_teacher) * student_ps.detach().data) + + self.logger.experiment.add_histogram ("Teacher_Center", self.lossFN_DINO.center) + + + def validation_step(self, batch, batch_idx): + loss, true_labels, predicted_labels = self._shared_step(batch, True) + + self.log("val_loss", loss, on_epoch=True, on_step=False, prog_bar=True) + self.val_acc.update(predicted_labels, true_labels) + self.log("val_acc", self.val_acc, on_epoch=True, on_step=False, prog_bar=True) + + def test_step(self, batch, batch_idx): + _, true_labels, predicted_labels = self._shared_step(batch, True) + + self.test_acc.update(predicted_labels, true_labels) + self.f1ScoreTest.update(predicted_labels, true_labels) + self.log("test_acc", self.test_acc, on_epoch=True, on_step=False) + self.log("test_f1", self.f1ScoreTest, on_epoch=True, on_step=False) + + def configure_optimizers(self): + optimizer = torch.optim.AdamW(self.student.parameters(), lr=self.lr, weight_decay=self.Lambda_L2) + + return [optimizer] + +class RARP_NVB_DINO_VAN(RARP_NVB_DINO_RestNet50_Deep): + def __init__( + self, + PseudoEstimator: str = None, + threshold: float = 0.5, + TypeLoss=TypeLossFunction.CrossEntropy, + momentum_teacher: float = 0.9995, + lr: float = 0.0001, + L1: float = None, + L2: float = 0 + ) -> None: + super().__init__(PseudoEstimator, threshold, TypeLoss, momentum_teacher, lr, L1, L2) + + self.in_dim = 512 + + self.student = van.van_b2(pretrained = True, num_classes = -1) + self.teacher_Features = van.van_b2(pretrained = True, num_classes = -1) + + self.student = RARP_NVB_DINO_Wrapper( + self.student, + RARP_NVB_MLP(self.in_dim, self.out_dim, 1024) + ) + + self.teacher_Features = RARP_NVB_DINO_Wrapper( + self.teacher_Features, + RARP_NVB_MLP(self.in_dim, self.out_dim, 1024) + ) + + for parms in self.teacher_Features.parameters(): + parms.requires_grad = False + +class RARP_NVB_DINO_ViT(RARP_NVB_DINO_RestNet50_Deep): + def __init__( + self, + PseudoEstimator: str = None, + threshold: float = 0.5, + TypeLoss=TypeLossFunction.CrossEntropy, + momentum_teacher: float = 0.9995, + lr: float = 0.0001, + L1: float = None, + L2: float = 0 + ) -> None: + super().__init__(PseudoEstimator, threshold, TypeLoss, momentum_teacher, lr, L1, L2) + + self.in_dim = 768 + + self.student = torchvision.models.vit_b_16(weights=torchvision.models.ViT_B_16_Weights.DEFAULT) + self.teacher_Features = torchvision.models.vit_b_16(weights=torchvision.models.ViT_B_16_Weights.DEFAULT) + + self.student.heads = torch.nn.Identity() + self.teacher_Features.heads = torch.nn.Identity() + + self.student = RARP_NVB_DINO_Wrapper( + self.student, + RARP_NVB_MLP(self.in_dim, self.out_dim, 1024) + ) + + self.teacher_Features = RARP_NVB_DINO_Wrapper( + self.teacher_Features, + RARP_NVB_MLP(self.in_dim, self.out_dim, 1024) + ) + + for parms in self.teacher_Features.parameters(): + parms.requires_grad = False + +class RARP_NVB_DINO_MultiTask(L.LightningModule): + # Define a hook function to capture the output + def _hook_fn_Student(self, module, input, output): + self.last_conv_output_S = output + + def _hook_fn_Teacher(self, module, input, output): + self.last_conv_output_T = output + + def __init__( + self, + TypeLoss=TypeLossFunction.CrossEntropy, + momentum_teacher:float = 0.9995, + lr:float = 1e-4, + L1:float = None, + L2:float = 0, + std: float = None, + mean: float = None, + ) -> None: + super().__init__() + + self.std_IMG = torch.tensor(std).view(3, 1, 1) if std is not None else None + self.mean_IMG = torch.tensor(mean).view(3, 1, 1) if mean is not None else None + + self.lr = lr + self.Lambda_L1 = L1 + self.Lambda_L2 = L2 + self.momentum_teacher = momentum_teacher + self.out_dim = 1024 + self.in_dim = 512 + + self.train_acc = torchmetrics.Accuracy('binary') + self.val_acc = torchmetrics.Accuracy('binary') + self.test_acc = torchmetrics.Accuracy('binary') + self.f1ScoreTest = torchmetrics.F1Score('binary') + + self.student = van.van_b2(pretrained = True, num_classes = 0) + self.teacher_Features = van.van_b2(pretrained = True, num_classes = 0) + + self.decoder = DynamicDecoder(input_channels=1024) #Decoder(input_channels=1024, hidden_channels=[512, 256, 128, 64]) + + self.student = RARP_NVB_DINO_Wrapper( + self.student, + RARP_NVB_MLP(self.in_dim, self.out_dim, n_layers=2) + ) + + self.teacher_Features = RARP_NVB_DINO_Wrapper( + self.teacher_Features, + RARP_NVB_MLP(self.in_dim, self.out_dim, n_layers=2) + ) + + self.teacher_Features.load_state_dict(self.student.state_dict()) + for parms in self.teacher_Features.parameters(): + parms.requires_grad = False + + self.lossFN_DINO = RARP_NVB_DINO_Loss(self.out_dim, 0.04, 0.1, momentum_teacher) + self.lossFN = torch.nn.CrossEntropyLoss(label_smoothing=0.5) if TypeLoss == TypeLossFunction.CrossEntropy else torch.nn.BCEWithLogitsLoss() + self.ReconstructionLoss = torch.nn.MSELoss() + + self.last_conv_output_T = None + self.last_conv_output_S = None + + self.teacher_Features.backbone.block4[-1].register_forward_hook(self._hook_fn_Teacher) + self.student.backbone.block4[-1].register_forward_hook(self._hook_fn_Student) + + self.clasiffier = torch.nn.Sequential( + torch.nn.Linear(self.out_dim, 128), + torch.nn.Dropout(0.4), + torch.nn.SiLU(True), + + torch.nn.Linear(128, 8), + torch.nn.Dropout(0.2), + torch.nn.SiLU(True), + + torch.nn.Linear(8, 1) + ) + + print(f"lr={self.lr}, L1={self.Lambda_L1}") + + def _denormalize(self, tensor:torch.Tensor): + # Move mean and std to the same device as the input tensor + mean = self.mean_IMG.to(tensor.device) + std = self.std_IMG.to(tensor.device) + return tensor * std + mean + + def forward(self, data, val_step:bool = True): + if val_step: + data = data.float() + dataTeacher, dataStudent = data, data + else: + data = [d.float() for d in data] + dataTeacher, dataStudent = data[1:3], data + + TeacherDino = self.teacher_Features(dataTeacher) + Student = self.student(dataStudent) + + if not val_step: + NumChunks = len(dataStudent) + S_GlogalViews = self.last_conv_output_S.chunk(NumChunks)[1:3] + self.last_conv_output_S = torch.cat(S_GlogalViews, dim=0) + + cat_features = torch.cat((self.last_conv_output_S, self.last_conv_output_T), dim=1) + + reconstructed_image = self.decoder(cat_features) + + Cont_Net = torch.nn.functional.adaptive_avg_pool2d(cat_features, (1,1)).flatten(1) + pred = self.clasiffier(Cont_Net) + + return pred, (Student, TeacherDino), reconstructed_image + + def _shared_step(self, batch, val_step:bool = False): + img, label = batch + + prediction, features, new_image = self(img, val_step) + StudentF, TeacherF = features + + prediction = prediction.flatten() + predicted_labels = torch.sigmoid(prediction) + + orignalImg = torch.cat([img[0].float() for _ in range(len(TeacherF))], dim=0) if not val_step else img.float() + label = torch.cat([label.float() for _ in range(len(TeacherF))], dim=0) if not val_step else label.float() + + #DINO Loss + loss_Dino = self.lossFN_DINO(StudentF, TeacherF) if not val_step else 0 + #Clasificator + loss_HL = self.lossFN(prediction, label) + #Reconstruction + loss_img = self.ReconstructionLoss(new_image, orignalImg) + loss_img = loss_img.float() + + if self.Lambda_L1 is not None: + loss_l1 = 0 + for params in self.clasiffier.parameters(): # aqui + loss_l1 += torch.sum(torch.abs(params)) + loss_HL += self.Lambda_L1 * loss_l1 + + if self.Lambda_L2 > 0: + l2_reg = 0.0 + for param in self.clasiffier.parameters(): + l2_reg += torch.norm(param, 2) ** 2 + loss_HL += self.Lambda_L2 * l2_reg + + loss = loss_Dino + loss_HL + loss_img + + return loss, label, predicted_labels, (loss_Dino, loss_HL, loss_img, new_image) + + def training_step(self, batch, batch_idx): + loss, true_labels, predicted_labels, losses = self._shared_step(batch, False) + + self.log("train_loss", loss, on_epoch=True) + self.train_acc.update(predicted_labels, true_labels) + self.log("train_acc", self.train_acc, on_epoch=True, on_step=False) + self.log("train_loss_img", losses[2], on_epoch=True, on_step=False) + self.log("train_loss_DINO", losses[0], on_epoch=True, on_step=False) + self.log("train_loss_GT", losses[1], on_epoch=True, on_step=False) + + if batch_idx % 50 == 0 and self.mean_IMG is not None and self.std_IMG is not None: + imgReconstruction = torch.clip(self._denormalize(losses[3]) / 255, 0, 1) + imgReconstruction = imgReconstruction[:, [2, 1, 0], :, :] + grid = torchvision.utils.make_grid(imgReconstruction) + self.logger.experiment.add_image('reconstructed_images', grid, self.global_step) + + return loss + + def on_train_batch_end(self, outputs, batch, batch_idx): + with torch.no_grad(): + for student_ps, teacher_ps in zip(self.student.parameters(), self.teacher_Features.parameters()): + teacher_ps.data.mul_(self.momentum_teacher) + teacher_ps.data.add_((1-self.momentum_teacher) * student_ps.detach().data) + + #self.logger.experiment.add_histogram ("Teacher_Center", self.lossFN_DINO.center) + + + def validation_step(self, batch, batch_idx): + loss, true_labels, predicted_labels, losses = self._shared_step(batch, True) + + self.log("val_loss", loss, on_epoch=True, on_step=False, prog_bar=True) + self.val_acc.update(predicted_labels, true_labels) + self.log("val_acc", self.val_acc, on_epoch=True, on_step=False, prog_bar=True) + + self.log("val_loss_img", losses[2], on_epoch=True, on_step=False) + self.log("val_loss_DINO", losses[0], on_epoch=True, on_step=False) + self.log("val_loss_GT", losses[1], on_epoch=True, on_step=False) + + def test_step(self, batch, batch_idx): + _, true_labels, predicted_labels, losses = self._shared_step(batch, True) + + self.test_acc.update(predicted_labels, true_labels) + self.f1ScoreTest.update(predicted_labels, true_labels) + self.log("test_acc", self.test_acc, on_epoch=True, on_step=False) + self.log("test_f1", self.f1ScoreTest, on_epoch=True, on_step=False) + + if self.mean_IMG is not None and self.std_IMG is not None: + imgReconstruction = torch.clip(self._denormalize(losses[3]) / 255, 0, 1) + imgReconstruction = imgReconstruction[:, [2, 1, 0], :, :] + grid = torchvision.utils.make_grid(imgReconstruction) + self.logger.experiment.add_image('reconstructed_images_test', grid, self.global_step) + + def configure_optimizers(self): + optimizer = torch.optim.AdamW(self.parameters(), lr=self.lr) #, weight_decay=self.Lambda_L2 + + return [optimizer] + +class RARP_NVB_DINO_MultiTask_MultOP(RARP_NVB_DINO_MultiTask): + def __init__(self, TypeLoss=TypeLossFunction.CrossEntropy, momentum_teacher = 0.9995, lr = 0.0001, L1 = None, L2 = 0, std = None, mean = None): + super().__init__(TypeLoss, momentum_teacher, lr, L1, L2, std, mean) + + self.automatic_optimization = False # Enable manual optimization + + def training_step(self, batch, batch_idx): + loss, true_labels, predicted_labels, losses = self._shared_step(batch, False) + + # Get optimizers + optimizer_task1, optimizer_task2 = self.optimizers() + + if batch_idx % 50 == 0 and self.mean_IMG is not None and self.std_IMG is not None: + imgReconstruction = torch.clip(self._denormalize(losses[3]) / 255, 0, 1) + imgReconstruction = imgReconstruction[:, [2, 1, 0], :, :] + grid = torchvision.utils.make_grid(imgReconstruction) + self.logger.experiment.add_image('reconstructed_images', grid, self.global_step) + + optimizer_task1.zero_grad() + loss1 = losses[0] + losses[2] + self.manual_backward(loss1, retain_graph=True) + optimizer_task1.step() + + optimizer_task2.zero_grad() + loss2 = losses[1] + self.manual_backward(loss2) + optimizer_task2.step() + + self.log("train_loss", loss, on_epoch=True) + self.log("train_loss_img", losses[2], on_epoch=True, on_step=False) + self.log("train_loss_DINO", losses[0], on_epoch=True, on_step=False) + + + self.train_acc.update(predicted_labels, true_labels) + self.log("train_acc", self.train_acc, on_epoch=True, on_step=False) + self.log("train_loss_GT", losses[1], on_epoch=True, on_step=False) + + def configure_optimizers(self): + optimizer_task1 = torch.optim.AdamW( + list(self.student.parameters()) + list(self.decoder.parameters()) + list(self.teacher_Features.parameters()), + lr=self.lr + ) + optimizer_task2 = torch.optim.Adam(self.clasiffier.parameters(), lr=1e-3) + return [optimizer_task1, optimizer_task2] + + +class RARP_NVB_RN50_VAN_V2 (RARP_NVB_Model): + # Define a hook function to capture the output + def _hook_fn(self, module, input, output): + self.last_conv_output = output + + def __init__( + self, + PseudoEstimator:str = None, + threshold:float = 0.5, + InitWeight=None, + TypeLoss=TypeLossFunction.CrossEntropy, + PseudoLables:bool=True, + HParameter = {}, + std: float = None, + mean: float = None, + **kwargs + ) -> None: + super().__init__(InitWeight, TypeLoss, **kwargs) + + self.std_IMG = torch.tensor(std).view(3, 1, 1) if std is not None else None + self.mean_IMG = torch.tensor(mean).view(3, 1, 1) if mean is not None else None + + #self.RARP_RestNet50 = torch.hub.load('facebookresearch/dino:main', 'dino_resnet50') + self.RARP_RestNet50 = RARP_NVB_ResNet50.load_from_checkpoint(PseudoEstimator) if PseudoEstimator is not None else RARP_NVB_ResNet50() + self.RARP_RestNet50.model.fc = torch.nn.Identity() + for parms in self.RARP_RestNet50.model.parameters(): + parms.requires_grad = False + + self.RARP_RestNet50 = torch.nn.Sequential(*list(self.RARP_RestNet50.model.children())[:-2]) + + self.decoder = Decoder() + + self.FeaturesLoss = FeatureAlignmentLoss() + self.ReconstructionLoss = torch.nn.MSELoss() + + match (TypeError): + case TypeLossFunction.ContrastiveLoss: + self.lossFN = ContrastiveLoss() + case _: + pass + + self.model = van.van_b2(pretrained = True, num_classes = 1) + + self.Lambda_L1 = getNVL(HParameter, "L1", 1.31E-04) + self.lr = getNVL(HParameter, "lr", 1.0E-4) + + print(f"lr={self.lr}, L1={self.Lambda_L1}") + + # Initialize a variable to store the output + self.last_conv_output = None + self.model.block4[-1].mlp.dwconv.register_forward_hook(self._hook_fn) + + + def forward(self, data): + dataTeacher, dataStudent, _ = data + dataStudent = dataStudent.float() + dataTeacher = dataTeacher.float() + + feature_Teacher = self.RARP_RestNet50 (dataTeacher) + #feature_Student = self.model.forward_features(dataStudent) + pred = self.model(dataStudent) + feature_Student = self.last_conv_output + + #feature_Teacher = torch.nn.functional.adaptive_avg_pool1d(feature_Teacher, feature_Student.size(-1)) #Re-size output vector to macth VAN + + cat_features = (feature_Student + feature_Teacher) / 2 + + reconstructed_image = self.decoder(cat_features) + + feature_Student = torch.nn.functional.adaptive_avg_pool2d(feature_Student, (1, 1)).flatten(1) + feature_Teacher = torch.nn.functional.adaptive_avg_pool2d(feature_Teacher, (1, 1)).flatten(1) + + return pred, (feature_Student, feature_Teacher), reconstructed_image + + def _shared_step(self, batch): + img, label = batch + label = label.float() + orignalImg = img[2].float() + + prediction, features, new_image = self(img) + + prediction = prediction.flatten() + predicted_labels = torch.sigmoid(prediction) + + #cosine similarity + loss_cosine = self.FeaturesLoss(features[0], features[1]) + #Clasificator + loss_hl = self.lossFN(prediction, label) + #Reconstruction + loss_img = self.ReconstructionLoss(new_image, orignalImg) + loss_img = loss_img.float() + + loss = loss_cosine + loss_hl + loss_img + + if self.Lambda_L1 is not None: + loss_l1 = 0 + for params in self.model.parameters(): + loss_l1 += torch.sum(torch.abs(params)) + loss += self.Lambda_L1 * loss_l1 + + return loss, label, predicted_labels, (loss_cosine, loss_hl, loss_img, new_image) + + def _denormalize(self, tensor:torch.Tensor): + # Move mean and std to the same device as the input tensor + mean = self.mean_IMG.to(tensor.device) + std = self.std_IMG.to(tensor.device) + return tensor * std + mean + + def training_step(self, batch, batch_idx): + loss, true_labels, predicted_labels, losses = self._shared_step(batch) + + self.log("train_loss", loss, on_epoch=True) + self.train_acc.update(predicted_labels, true_labels) + self.log("train_acc", self.train_acc, on_epoch=True, on_step=False) + self.log("train_loss_img", losses[2], on_epoch=True, on_step=False) + self.log("train_loss_cosSim", losses[0], on_epoch=True, on_step=False) + self.log("train_loss_GT", losses[1], on_epoch=True, on_step=False) + + if batch_idx % 50 == 0 and self.mean_IMG is not None and self.std_IMG is not None: + imgReconstruction = torch.clip(self._denormalize(losses[3]) / 255, 0, 1) + imgReconstruction = imgReconstruction[:, [2, 1, 0], :, :] + grid = torchvision.utils.make_grid(imgReconstruction) + self.logger.experiment.add_image('reconstructed_images', grid, self.global_step) + + return loss + + def validation_step(self, batch, batch_idx): + loss, true_labels, predicted_labels, losses = self._shared_step(batch) + self.log("val_loss", loss, on_epoch=True, on_step=False, prog_bar=True) + self.val_acc.update(predicted_labels, true_labels) + self.log("val_acc", self.val_acc, on_epoch=True, on_step=False, prog_bar=True) + self.log("val_loss_img", losses[2], on_epoch=True, on_step=False) + self.log("val_loss_cosSim", losses[0], on_epoch=True, on_step=False) + self.log("val_loss_GT", losses[1], on_epoch=True, on_step=False) + + def test_step(self, batch, batch_idx): + loss, true_labels, predicted_labels, losses = self._shared_step(batch) + self.test_acc.update(predicted_labels, true_labels) + self.f1ScoreTest.update(predicted_labels, true_labels) + self.log("test_acc", self.test_acc, on_epoch=True, on_step=False) + self.log("test_f1", self.f1ScoreTest, on_epoch=True, on_step=False) + + if self.mean_IMG is not None and self.std_IMG is not None: + imgReconstruction = torch.clip(self._denormalize(losses[3]) / 255, 0, 1) + imgReconstruction = imgReconstruction[:, [2, 1, 0], :, :] + grid = torchvision.utils.make_grid(imgReconstruction) + self.logger.experiment.add_image('reconstructed_images_test', grid, self.global_step) + + def configure_optimizers(self): + optimizer = torch.optim.Adam(self.parameters(), lr=self.lr, weight_decay=self.Lambda_L2) + + return optimizer + +class RARP_NVB_ResNet50_VAN(RARP_NVB_Model): + def __init__( + self, + PseudoEstimator:str = None, + threshold:float = 0.5, + InitWeight=None, + TypeLoss=TypeLossFunction.CrossEntropy, + PseudoLables:bool=True, + HParameter = {}, + **kwargs + ) -> None: + super().__init__(InitWeight, TypeLoss, **kwargs) + + self.RARP_RestNet50 = RARP_NVB_ResNet50.load_from_checkpoint(PseudoEstimator) if PseudoEstimator is not None else RARP_NVB_ResNet50() + self.threshold = threshold + self.PseudoLables = PseudoLables + + match (TypeError): + case TypeLossFunction.ContrastiveLoss: + self.lossFN = ContrastiveLoss() + case _: + pass + + for parms in self.RARP_RestNet50.model.parameters(): + parms.requires_grad = False + + self.model = van.van_b2(pretrained = True, num_classes = 1) + self.Lambda_L1 = getNVL(HParameter, "L1", 1.31E-04) + self.lr = getNVL(HParameter, "lr", 1.0E-4) + self.W_Apha = getNVL(HParameter, "Alpha", 0.60) + self.W_Beta = 1 - getNVL(HParameter, "Alpha", 0.60) + self.thao_KD = getNVL(HParameter, "Thao", 5) + + print(f"A={self.W_Apha}; B={self.W_Beta}, T={self.thao_KD}, lr={self.lr}, L1={self.Lambda_L1}") + + #self.Lambda_L1 = None + #self.scheduler = True + #self.lr = 1.74E-2 + + def forward(self, data): + #dataTeacher, dataStudent = data + if isinstance(data, tuple): + dataTeacher, dataStudent = data + elif isinstance(data, torch.Tensor): + dataTeacher, dataStudent = (data, data) + RN50Pred = torch.sigmoid(self.RARP_RestNet50(dataTeacher).flatten()) + PseudoLabels = (RN50Pred > self.threshold) * 1.0 + + dataStudent = dataStudent.float() + pred = self.model(dataStudent) + + return pred, PseudoLabels, RN50Pred + + def _shared_step(self, batch): + img, label = batch + if self.InitWeight is not None: + self.lossFN.weight = self.InitWeight[label] + + label = label.float() + prediction, PseudoLabels, predictionRN50 = self(img) #.flatten() + prediction = prediction.flatten() + predicted_labels = torch.sigmoid(prediction) + # + # L[B] => BCEWithLogits + # L[C] => ContrastiveLoss + #Loss L[1] = L[B_HL] + L[B_PL] + #Loss L[2] = L[C_HL] + #Loss L[3] = L[C_HL] + L[C_PL] + #Loss L[4] = L[C_y_hat] + #Loss L[5] = L[KLD_PL] + L[B_PL] + #Loss L[6] = L[MSE_PL] + L[B_PL] + #Loss L[7] = L[B_HL] + L[BCE_PL] + #Loss L[8] = FocalLoss*L[JSD] + #Nuveo + #thao_KD = 5.0 + #w_alpha, w_beta = (0.60, 0.40) + + #L[7]: + softTeacher = torch.sigmoid(predictionRN50/self.thao_KD) + softStudent = torch.sigmoid(prediction/self.thao_KD) + + loss_sl = torch.nn.functional.binary_cross_entropy(softStudent, softTeacher) + loss_hl = self.lossFN(prediction, label) + + loss = self.W_Apha * loss_hl + self.W_Beta * loss_sl #/ (self.thao_KD ** 2) + + #loss = w_alpha * self.lossFN(prediction, label) + w_beta * self.lossFN(prediction, PseudoLabels) #L[1] + #loss = w_alpha * (torch.nn.KLDivLoss()(softStudent, softTeacher) * (thao_KD ** 2)) + w_beta * self.lossFN(prediction, PseudoLabels) #L[5] + #loss = w_alpha * torch.nn.functional.mse_loss(softStudent, softTeacher) + w_beta * self.lossFN(prediction, PseudoLabels) #L[6] + #loss = self.lossFN(predictionRN50, predicted_labels, label) #L[2] + #loss = self.lossFN(predictionRN50, predicted_labels, label) + self.lossFN(predictionRN50, predicted_labels, PseudoLabels) #L[3] + #y_hat = (PseudoLabels != label) * 1 + #loss = self.lossFN(predictionRN50, predicted_labels, y_hat) #L[4] + + if self.Lambda_L1 is not None: + loss_l1 = 0 + for params in self.model.parameters(): + loss_l1 += torch.sum(torch.abs(params)) + loss += self.Lambda_L1 * loss_l1 + + return loss, (PseudoLabels if self.PseudoLables else label), predicted_labels, (loss_hl, loss_sl) + + def training_step(self, batch, batch_idx): + loss, true_labels, predicted_labels, losses = self._shared_step(batch) + + self.log("train_loss", loss, on_epoch=True) + self.train_acc.update(predicted_labels, true_labels) + + self.log("train_acc", self.train_acc, on_epoch=True, on_step=False) + self.log("train_lh", losses[0], on_step=False, on_epoch=True) + self.log("train_ld", losses[1], on_step=False, on_epoch=True) + + return loss + + def validation_step(self, batch, batch_idx): + loss, true_labels, predicted_labels, losses = self._shared_step(batch) + self.log("val_loss", loss, on_epoch=True, on_step=False, prog_bar=True) + self.val_acc.update(predicted_labels, true_labels) + + self.log("val_acc", self.val_acc, on_epoch=True, on_step=False, prog_bar=True) + self.log("val_lh", losses[0], on_step=False, on_epoch=True) + self.log("val_ld", losses[1], on_step=False, on_epoch=True) + + def test_step(self, batch, batch_idx): + _, true_labels, predicted_labels, _ = self._shared_step(batch) + self.test_acc.update(predicted_labels, true_labels) + self.f1ScoreTest.update(predicted_labels, true_labels) + self.log("test_acc", self.test_acc, on_epoch=True, on_step=False) + self.log("test_f1", self.f1ScoreTest, on_epoch=True, on_step=False) + + def configure_optimizers(self): + optimizer = torch.optim.Adam(self.model.parameters(), lr=self.lr, weight_decay=self.Lambda_L2) + if self.scheduler: + scheduler = CosineAnnealingLR( + optimizer, + max_epochs=150, + warmup_epochs=8, + warmup_start_lr=0.001, + eta_min=0.0001 + ) + return { + "optimizer": optimizer, + "lr_scheduler": { + "scheduler": scheduler, + #"monitor": "val_loss", + } + } + return optimizer + +class RARP_NVB_SSL_RestNet50_Deep(RARP_NVB_ResNet50_VAN): + def __init__( + self, + PseudoEstimator: str = None, + threshold: float = 0.5, + InitWeight=None, + TypeLoss=TypeLossFunction.CrossEntropy, + PseudoLables: bool = True, + **kwargs + ) -> None: + super().__init__(None, threshold, InitWeight, TypeLoss, PseudoLables, **kwargs) + + self.RARP_RestNet50 = RARP_NVB_ResNet50_Deep.load_from_checkpoint(PseudoEstimator, strict=False) if PseudoEstimator is not None else RARP_NVB_ResNet50_Deep() + self.model = torchvision.models.resnet50(weights=torchvision.models.ResNet50_Weights.DEFAULT) + #self.model = torch.hub.load('facebookresearch/dino:main', 'dino_resnet50') + tempFC_ft = 2048 + self.model.fc = torch.nn.Sequential( + torch.nn.Dropout(0.2), + torch.nn.Linear(in_features=tempFC_ft, out_features=128), + torch.nn.SiLU(True), + torch.nn.Linear(128, 8), + torch.nn.SiLU(True), + torch.nn.Linear(8, 1) + ) + + for parms in self.RARP_RestNet50.model.parameters(): + parms.requires_grad = False + +class RARP_NVB_MobileNetV2(RARP_NVB_Model):#class RARP_NVB_MobileNetV2(RARP_NVB_Model_BCEWithLogitsLoss): + def __init__(self, InitWeight=None, TypeLoss=TypeLossFunction.CrossEntropy, **kwargs) -> None: + super().__init__(InitWeight, TypeLoss, **kwargs) + + self.model = torchvision.models.mobilenet_v2(weights=torchvision.models.MobileNet_V2_Weights.DEFAULT) + tempFC_ft = self.model.classifier[1].in_features + self.model.classifier[1] = torch.nn.Linear(in_features=tempFC_ft, out_features=1) + +class RARP_NVB_EfficientNetV2(RARP_NVB_Model): + def __init__(self, InitWeight=None, TypeLoss=TypeLossFunction.CrossEntropy, **kwargs) -> None: + super().__init__(InitWeight, TypeLoss, **kwargs) + + self.model = torchvision.models.efficientnet_v2_s(weights=torchvision.models.EfficientNet_V2_S_Weights.DEFAULT) + tempFC_ft = self.model.classifier[1].in_features + self.model.classifier[1] = torch.nn.Linear(in_features=tempFC_ft, out_features=1) + +class RARP_NVB_Vit_b_16(RARP_NVB_Model): + def __init__(self, InitWeight=None, TypeLoss=TypeLossFunction.CrossEntropy) -> None: + super().__init__(InitWeight, TypeLoss) + + self.model = torchvision.models.vit_b_16(weights=torchvision.models.ViT_B_16_Weights.DEFAULT) + tempFC_ft = self.model.heads[0].in_features + self.model.heads[0] = torch.nn.Linear(in_features=tempFC_ft, out_features=1) + +class RARP_NVB_DenseNet169(RARP_NVB_Model): + def __init__(self, InitWeight=None, TypeLoss=TypeLossFunction.CrossEntropy) -> None: + super().__init__(InitWeight, TypeLoss) + + self.model = torchvision.models.densenet169(weights=torchvision.models.DenseNet169_Weights.DEFAULT) + inFeatures = self.model.classifier.in_features + self.model.classifier = torch.nn.Linear(in_features=inFeatures, out_features=1) + +class RARP_NVB_RestNet50_old(L.LightningModule): + def __init__(self, InitialWeigth = 1) -> None: + super().__init__() + + self.model = torchvision.models.resnet50(weights=torchvision.models.ResNet50_Weights.IMAGENET1K_V1) + tempFC_ft = self.model.fc.in_features + self.model.fc = torch.nn.Linear(in_features=tempFC_ft, out_features=1) + + self.optimizer = torch.optim.Adam(self.model.parameters(), lr=1e-4) + self.lossFN = torch.nn.BCEWithLogitsLoss(pos_weight=torch.tensor([InitialWeigth])) + + self.train_acc = torchmetrics.Accuracy('binary') + self.val_acc = torchmetrics.Accuracy('binary') + + def forward(self, data): + data = data.float() + pred = self.model(data) + return pred + + def training_step(self, batch, batch_idx): + img, label = batch + label = label.float() + prediction = self(img)[:,0] + loss = self.lossFN(prediction, label) + + self.log("Train Loss", loss) + self.log("Step Train Acc", self.train_acc(torch.sigmoid(prediction), label.int())) + + return loss + + def on_train_epoch_end(self): + self.log("Train Acc", self.train_acc.compute()) + + def validation_step(self, batch, batch_idx): + img, label = batch + label = label.float() + prediction = self(img)[:,0] + loss = self.lossFN(prediction, label) + + self.log("Val Loss", loss) + self.log("Step Val Acc", self.val_acc(torch.sigmoid(prediction), label.int())) #train_acc + + return loss + + def on_validation_epoch_end(self): + self.log("Val Acc", self.val_acc.compute()) + + def configure_optimizers(self): + return [self.optimizer] + + diff --git a/MultiClass.ipynb b/MultiClass.ipynb new file mode 100644 index 0000000..d504613 --- /dev/null +++ b/MultiClass.ipynb @@ -0,0 +1,591 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torch.utils.data import DataLoader\n", + "import torchvision\n", + "from torchvision import transforms\n", + "import torchmetrics\n", + "import lightning as L\n", + "import lightning.pytorch.callbacks as callbk\n", + "from lightning.pytorch.loggers import TensorBoardLogger\n", + "from tqdm.notebook import tqdm\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from pathlib import Path\n", + "import Loaders\n", + "import defs\n", + "import Models as M\n", + "import pandas as pd\n", + "import van\n", + "\n", + "def setup_seed(seed):\n", + " torch.manual_seed(seed)\n", + " torch.cuda.manual_seed_all(seed)\n", + " np.random.seed(seed)\n", + " torch.backends.cudnn.deterministic = True\n", + "\n", + "batchSize = 8\n", + "numWorkers = 0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Dataset = Loaders.RARP_DatasetCreator(\n", + " \"./DataSet_AndoCrop\",\n", + " FoldSeed=505,\n", + " createFile=True,\n", + " SavePath=\"./DataSet_SB_Ando_Crop\",\n", + " Fold=5,\n", + ")\n", + "\n", + "Dataset.CreateFolds()\n", + "\n", + "Fold = 0\n", + " \n", + "Dataset.mean, Dataset.std = ([30.38144216, 42.03988769, 97.8896116], [40.63141752, 44.26910074, 50.29294373])\n", + "\n", + "setup_seed(2023)\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "InitResize = (256,256)\n", + "ImgResize = (224, 224)\n", + "checkPtCallback = callbk.ModelCheckpoint(monitor='val_acc', filename=\"RARP-{epoch}\", save_top_k=10, mode='max')\n", + "ckpLossBest = callbk.ModelCheckpoint(monitor=\"val_loss\", filename=\"RARP-{epoch}-{val_loss:.2f}\", save_top_k=2, mode='min')\n", + "\n", + "traintransform = torch.nn.Sequential(\n", + " transforms.Resize(InitResize, antialias=True),\n", + " transforms.CenterCrop(224), #AQUI se cambio 2024/05/10\n", + " #transforms.RandomCrop(ImgResize),\n", + " transforms.RandomAffine(\n", + " degrees=(-5, 5), scale=(0.9, 1.1), \n", + " fill=5\n", + " ),\n", + " transforms.RandomHorizontalFlip(1.0),\n", + " transforms.Normalize(Dataset.mean, Dataset.std),\n", + ").to(device)\n", + "\n", + "valtransform = torch.nn.Sequential(\n", + " transforms.Resize(256, antialias=True),\n", + " transforms.CenterCrop(224),\n", + " transforms.Normalize(Dataset.mean, Dataset.std)\n", + ").to(device)\n", + "\n", + "testtransform = torch.nn.Sequential(\n", + " transforms.Resize(256, antialias=True),\n", + " transforms.CenterCrop(224),\n", + " transforms.Normalize(Dataset.mean, Dataset.std)\n", + ").to(device)\n", + "\n", + "rootFile = Dataset.CVS_File.parent.parent/f\"fold_{Fold}\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "trainDataset = torchvision.datasets.DatasetFolder(\n", + " str (rootFile/\"train\"),\n", + " loader=defs.load_file_tensor,\n", + " extensions=\"npy\",\n", + " transform=traintransform\n", + ")\n", + "\n", + "valDataset = torchvision.datasets.DatasetFolder(\n", + " str (rootFile/\"val\"),\n", + " loader=defs.load_file_tensor,\n", + " extensions=\"npy\",\n", + " transform=valtransform\n", + " #transform=testtransform2\n", + ")\n", + "\n", + "testDataset = torchvision.datasets.DatasetFolder(\n", + " str (rootFile/\"test\"),\n", + " loader=defs.load_file_tensor,\n", + " extensions=\"npy\",\n", + " transform=testtransform\n", + " #transform=testtransform2\n", + ") " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Train_DataLoader = DataLoader(\n", + " trainDataset, \n", + " batch_size=batchSize, \n", + " num_workers=numWorkers, \n", + " shuffle=True, \n", + " pin_memory=True\n", + ")\n", + "Val_DataLoader = DataLoader(\n", + " valDataset, \n", + " batch_size=batchSize, \n", + " num_workers=numWorkers, \n", + " shuffle=False, \n", + " pin_memory=True\n", + ")\n", + "Test_DataLoader = DataLoader(\n", + " testDataset, \n", + " batch_size=batchSize, \n", + " num_workers=numWorkers, \n", + " shuffle=False, \n", + " pin_memory=True\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "TestModel = torchvision.models.resnet50(weights=torchvision.models.ResNet50_Weights.DEFAULT)\n", + "tempFC_ft = TestModel.fc.in_features\n", + "TestModel.fc = torch.nn.Linear(in_features=tempFC_ft, out_features=2)\n", + "Model = M.RARP_NVB_MultiClassModel(None, Model=TestModel)\n", + "\n", + "NameModel = type(Model).__name__\n", + "print(f\"Model Used: {NameModel}\")\n", + "MaxEpochs = 150" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Model = M.RARP_NVB_ResNet50.load_from_checkpoint(\"log_ResNet50_X10/lightning_logs/version_0/checkpoints/RARP-epoch=10.ckpt\")\n", + "Model =M.RARP_NVB_VAN.load_from_checkpoint(\"log_VAN_X10/lightning_logs/version_0/checkpoints/RARP-epoch=0.ckpt\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from pytorch_grad_cam import GradCAM\n", + "from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget\n", + "from pytorch_grad_cam.utils.image import show_cam_on_image\n", + "\n", + "targetL = [Model.model.block4[-1]]\n", + "\n", + "CAM = GradCAM(model=Model, target_layers=targetL)\n", + "tar = [ClassifierOutputTarget(0)]\n", + "\n", + "\n", + "\n", + "for data, label in tqdm(iter(Test_DataLoader)):\n", + " gi = CAM(data, targets=tar)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "mean, std = ([30.38144216, 42.03988769, 97.8896116], [40.63141752, 44.26910074, 50.29294373])\n", + "\n", + "b = 0\n", + "\n", + "rgb_img = data[b, :].numpy().transpose((1, 2, 0))\n", + "rgb_img = np.clip((std * rgb_img + mean) / 255, 0, 1)\n", + "rgb_img = rgb_img[...,::-1].copy()\n", + "\n", + "grayscale_cam = gi[b, :]\n", + "\n", + "visualization = show_cam_on_image(rgb_img, grayscale_cam, use_rgb=True)\n", + "\n", + "plt.imshow(visualization)\n", + "label" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "LogFileName = \"log_MultiClass\"\n", + "trainer = L.Trainer(\n", + " accelerator='gpu', \n", + " devices=1, \n", + " logger=TensorBoardLogger(save_dir=f\"./{LogFileName}\"),\n", + " log_every_n_steps=5, \n", + " #callbacks=[checkPtCallback, StepDropout(5, base_drop_rate=0.2, gamma=0.05, ascending=True)],#if args.Model == 4 else checkPtCallback, \n", + " callbacks=[checkPtCallback, ckpLossBest, callbk.EarlyStopping(monitor=\"val_loss\", mode=\"min\", patience=5)],\n", + " max_epochs=MaxEpochs,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\"Train Phase\")\n", + "trainer.fit(Model, train_dataloaders=Train_DataLoader, val_dataloaders=Val_DataLoader)\n", + "trainer.test(Model, dataloaders=Test_DataLoader, ckpt_path=\"best\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def Calc_EvalMulticlass_table(TrainModel:M.RARP_NVB_Model,TestDataLoadre:DataLoader, Youden=False, modelName=\"\"):\n", + " TrainModel.to(device)\n", + " TrainModel.eval()\n", + "\n", + " Predictions = []\n", + " Labels = []\n", + "\n", + " with torch.no_grad():\n", + " for data, label in tqdm(iter(TestDataLoadre)):\n", + " data = data.float().to(device)\n", + " label = label.to(device)\n", + " \n", + " pred = TrainModel(data)\n", + " Predictions.append(torch.softmax(pred, dim=1))\n", + " Labels.append(label)\n", + "\n", + " Predictions = torch.cat(Predictions)\n", + " Labels = torch.cat(Labels)\n", + "\n", + " print(Predictions, Labels)\n", + "\n", + " acc = torchmetrics.Accuracy(\"multiclass\", num_classes=2).to(device)(Predictions, Labels)\n", + " precision = torchmetrics.Precision(\"multiclass\", num_classes=2).to(device)(Predictions, Labels)\n", + " recall = torchmetrics.Recall(\"multiclass\", num_classes=2).to(device)(Predictions, Labels)\n", + " auc = torchmetrics.AUROC(\"multiclass\", num_classes=2).to(device)(Predictions, Labels)\n", + " f1Score = torchmetrics.F1Score(\"multiclass\", num_classes=2).to(device)(Predictions, Labels)\n", + " specificty = torchmetrics.Specificity(\"multiclass\", num_classes=2).to(device)(Predictions, Labels)\n", + " \n", + " table = [\n", + " [\"0.5000\", f\"{acc}\", f\"{precision}\", f\"{recall}\", f\"{f1Score}\", f\"{auc}\", f\"{specificty}\", f\"*{modelName}*\"] #.item():.4f\n", + " ]\n", + " \n", + " cm2 = torchmetrics.ConfusionMatrix(\"multiclass\", num_classes=2).to(device)\n", + " cm2.update(Predictions, Labels)\n", + " _, ax = cm2.plot()\n", + " ax.set_title(f\"NVB Classifier\")\n", + "\n", + " if Youden:\n", + " for i in range(2):\n", + " aucCurve = torchmetrics.ROC(\"multiclass\", num_classes=2).to(device)\n", + " fpr, tpr, thhols = aucCurve(Predictions, Labels)\n", + " index = torch.argmax(tpr - fpr)\n", + " th2 = (recall + specificty - 1).item()\n", + " th2 = 0.5 if th2 <= 0 else th2\n", + " th1 = thhols[index].item() if i == 0 else th2\n", + " accY = torchmetrics.Accuracy(\"multiclass\", num_classes=2, threshold=th1).to(device)(Predictions, Labels)\n", + " precisionY = torchmetrics.Precision(\"multiclass\", num_classes=2, threshold=th1).to(device)(Predictions, Labels)\n", + " recallY = torchmetrics.Recall(\"multiclass\", num_classes=2, threshold=th1).to(device)(Predictions, Labels)\n", + " specifictyY = torchmetrics.Specificity(\"binary\", threshold=th1).to(device)(Predictions, Labels)\n", + " f1ScoreY = torchmetrics.F1Score(\"multiclass\", num_classes=2, threshold=th1).to(device)(Predictions, Labels)\n", + " #cm2 = torchmetrics.ConfusionMatrix(\"multiclass\", num_classes=2, threshold=th1).to(device)\n", + " #cm2.update(Predictions, Labels)\n", + " #_, ax = cm2.plot()\n", + " #ax.set_title(f\"NVB Classifier (th={th1:.4f})\")\n", + " table.append([f\"{th1:.4f}\", f\"{accY.item():.4f}\", f\"{precisionY.item():.4f}\", f\"{recallY.item():.4f}\", f\"{f1ScoreY.item():.4f}\", f\"{auc.item():.4f}\", f\"{specifictyY.item():.4f}\", modelName])\n", + " \n", + "\n", + " return table" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\"Evaluation Phase\")\n", + "Log_version = 0\n", + "rows = []\n", + "pathCkptFile = Path(f\"./{LogFileName}/lightning_logs/version_{Log_version}/checkpoints/\")\n", + "for ckpFile in pathCkptFile.glob(\"*.ckpt\"):\n", + " print(ckpFile.name)\n", + " temp = Calc_EvalMulticlass_table(Model, Test_DataLoader, modelName=ckpFile.name)\n", + " rows += temp\n", + "df = pd.DataFrame(rows, columns=[\"Youden\", \"Acc\",\"Precision\",\"Recall\",\"F1\",\"AUROC\",\"Specificity\",\"CheckPoint\"])\n", + "print(df)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "import torchvision.transforms\n", + "\n", + "t = torch.rand(3, 256, 256)*255\n", + "\n", + "invT = torch.ones(3, 256, 256)*255\n", + "\n", + "t.shape\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "t" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "255 - t " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "t2 = t[[2,1,0]]\n", + "t2.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torchvision\n", + "\n", + "model = torchvision.models.resnet50(weights=torchvision.models.ResNet50_Weights.DEFAULT)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len([*model.conv1.children()])\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "with torch.no_grad():\n", + " w = model.conv1.weight\n", + " print(w)\n", + " print (w.shape)\n", + " print (w.sum(2).shape)\n", + " print (w.unsqueeze(2).shape)\n", + " print (model.layer1[0].conv2.bias)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import decord\n", + "from pathlib import Path\n", + "import torch\n", + "import cv2\n", + "import numpy as np\n", + "\n", + "def _removeBlackBorder(image):\n", + " image = np.array(image)\n", + " \n", + " copyImg = cv2.cvtColor(image.copy(), cv2.COLOR_BGR2HSV)\n", + " h = copyImg[:,:,0]\n", + " mask = np.ones(h.shape, dtype=np.uint8) * 255\n", + " th = (25, 175)\n", + " mask[(h > th[0]) & (h < th[1])] = 0\n", + " copyImg = cv2.cvtColor(copyImg, cv2.COLOR_HSV2BGR)\n", + " resROI = cv2.bitwise_and(copyImg, copyImg, mask=mask)\n", + " \n", + " image_gray = cv2.cvtColor(resROI, cv2.COLOR_BGR2GRAY)\n", + " _, thresh = cv2.threshold(image_gray, 0, 255, cv2.THRESH_BINARY)\n", + " kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 15))\n", + " morph = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel)\n", + " contours = cv2.findContours(morph, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n", + " contours = contours[0] if len(contours) == 2 else contours[1]\n", + " bigCont = max(contours, key=cv2.contourArea)\n", + " x, y, w, h = cv2.boundingRect(bigCont)\n", + " crop = image[y : y + h, x : x + w]\n", + " return crop\n", + "\n", + "def VideoPrePros_BackBars(VideoIN_Path:str, VideoOUT_Path:str):\n", + " size = (1269, 1007)\n", + " fourcc = cv2.VideoWriter_fourcc(*'mp4v')\n", + " video = cv2.VideoWriter(VideoOUT_Path, fourcc, 30, size)\n", + "\n", + " cap = cv2.VideoCapture(VideoIN_Path)\n", + " while (True):\n", + " ret, frame = cap.read()\n", + " if not ret:\n", + " break\n", + " \n", + " img = _removeBlackBorder(frame)\n", + " img = cv2.resize(img, size, interpolation=cv2.INTER_CUBIC)\n", + " video.write(img)\n", + " \n", + " video.release()\n", + " cap.release()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "videoPath = Path(\"./Video3D/dataset/NOT_NVB/181.mp4\")\n", + "\n", + "VideoPrePros_BackBars(str(videoPath.absolute()), \"outVideo.mp4\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FPS:30.0\n", + "Video Length: 15.0 seg.\n" + ] + } + ], + "source": [ + "\n", + "vr = decord.VideoReader(\"outVideo.mp4\", decord.cpu(0))\n", + "print (f\"FPS:{vr.get_avg_fps()}\")\n", + "print (f\"Video Length: {len(vr)/vr.get_avg_fps()} seg.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(90, 1006, 1268, 3)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "frames = vr.get_batch(list(range(0, 450, 5))).asnumpy()\n", + "#frames = torch.Tensor(frames)\n", + "frames.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "frames[5].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cv2.imwrite(\"salida.jpg\", cv2.cvtColor(frames[5], cv2.COLOR_RGB2BGR))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "TestRARP", + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Oprimizer.py b/Oprimizer.py new file mode 100644 index 0000000..b6b6ba8 --- /dev/null +++ b/Oprimizer.py @@ -0,0 +1,180 @@ +import Models as M +import Loaders +import defs +import numpy as np +import lightning.pytorch as pl +import optuna +from optuna.integration import PyTorchLightningPruningCallback +from packaging import version +import torch +from torch.utils.data import DataLoader +import torchvision +from torchvision import transforms + +if version.parse(pl.__version__) < version.parse("1.6.0"): + raise RuntimeError("PyTorch Lightning>=1.6.0 is required for this example.") +else: + print("OK") + + +def setup_seed(seed): + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + np.random.seed(seed) + torch.backends.cudnn.deterministic = True + +Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_Ando_All_Crop", + FoldSeed=505, + createFile=True, + SavePath="./DataSet_Ando_Crop", + Fold=5, + removeBlackBar=False, +) + +Dataset.CreateFolds() + +Fold = 0 + + +Dataset.mean, Dataset.std = ([30.38144216, 42.03988769, 97.8896116], [40.63141752, 44.26910074, 50.29294373]) + +setup_seed(2023) +device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + +InitResize = (256,256) +ImgResize = (224, 224) + +rootFile = (Dataset.CVS_File.parent.parent/f"fold_{Fold}") +print (rootFile) + +traintransform = torch.nn.Sequential( + transforms.Resize(InitResize, antialias=True), + transforms.RandomCrop(ImgResize), + transforms.RandomAffine( + degrees=(-5, 5), scale=(0.9, 1.1), + fill=5 + ), + transforms.RandomHorizontalFlip(0.9), + transforms.Normalize(Dataset.mean, Dataset.std), +).to(device) + +valtransform = torch.nn.Sequential( + transforms.Resize(ImgResize, antialias=True), + transforms.Normalize(Dataset.mean, Dataset.std) +).to(device) + +testtransform = torch.nn.Sequential( + transforms.Resize(ImgResize, antialias=True), + transforms.Normalize(Dataset.mean, Dataset.std) +).to(device) + +trainDataset = torchvision.datasets.DatasetFolder( + str (rootFile/"train"), + loader=defs.load_file_tensor, + extensions="npy", + transform=traintransform +) + +valDataset = torchvision.datasets.DatasetFolder( + str (rootFile/"val"), + loader=defs.load_file_tensor, + extensions="npy", + transform=valtransform +) + +testDataset = torchvision.datasets.DatasetFolder( + str (rootFile/"test"), + loader=defs.load_file_tensor, + extensions="npy", + transform=testtransform +) + + +PERCENT_VALID_EXAMPLES = 0.1 +EPOCHS = 50 + +def objective(trail: optuna.trial.Trial) -> float: + lr = trail.suggest_loguniform("lr", 1e-6, 1e-3) + l1 = trail.suggest_loguniform("L1", 1e-5, 1e-3) + n_layers = trail.suggest_int("n_layers", 1, 4) + dropout = trail.suggest_float("dropout", 0.2, 0.5) + output_Dims = [ + trail.suggest_int("n_layers_l{}".format(i), 8, 512, log=True) for i in range(n_layers) + ] + + batchSize = trail.suggest_categorical("batch_size", [8, 16, 32]) + numWorkers = 8 + + model = M.RARP_NVB_ResNet50_Deep_OPTuna(None, M.TypeLossFunction.BCEWithLogits, output_Dims, dropout, config={"lr": lr, "L1": l1}) + + Train_DataLoader = DataLoader( + trainDataset, + batch_size=batchSize, + num_workers=numWorkers, + shuffle=True, + pin_memory=True, + persistent_workers=True, + ) + + Val_DataLoader = DataLoader( + valDataset, + batch_size=batchSize, + num_workers=numWorkers, + shuffle=False, + pin_memory=True, + persistent_workers=True, + ) + + Test_DataLoader = DataLoader( + testDataset, + batch_size=batchSize, + num_workers=numWorkers, + shuffle=False, + pin_memory=True, + persistent_workers=True + ) + + trainer = pl.Trainer( + logger=True, + enable_checkpointing=False, + max_epochs=EPOCHS, + accelerator="auto", + devices=1, + callbacks=[PyTorchLightningPruningCallback(trail, monitor="val_acc")], + ) + + hyperparameters = dict( + lr = lr, + l1 = l1, + n_layers = n_layers, + dropout = dropout, + output_dims = output_Dims, + batch_size = batchSize, + ) + + trainer.logger.log_hyperparams(hyperparameters) + + trainer.fit(model, train_dataloaders=Train_DataLoader, val_dataloaders=Val_DataLoader) + + return trainer.callback_metrics["val_acc"].item() + + +if __name__ == "__main__": + pruning = True + + pruner = optuna.pruners.MedianPruner() if pruning else optuna.pruners.NopPruner() + + study = optuna.create_study(direction="maximize", pruner=pruner) + study.optimize(objective, n_trials=100, timeout=600) + + print("Number of finished trials: {}".format(len(study.trials))) + + print("Best trial:") + trial = study.best_trial + + print(" Value: {}".format(trial.value)) + + print(" Params: ") + for key, value in trial.params.items(): + print(" {}: {}".format(key, value)) \ No newline at end of file diff --git a/RARP_NVB-norm.py b/RARP_NVB-norm.py new file mode 100644 index 0000000..4c95f8d --- /dev/null +++ b/RARP_NVB-norm.py @@ -0,0 +1,642 @@ +import torch +from torch.utils.data import DataLoader +import torchvision +from torchvision import transforms +import torchmetrics +import lightning as L +import lightning.pytorch.callbacks as callbk +from lightning.pytorch.loggers import TensorBoardLogger +from tqdm.notebook import tqdm +import numpy as np +import matplotlib.pyplot as plt +from pathlib import Path +from CustomCallback import StepDropout +import Loaders +import defs +import argparse +import seaborn as sn +import Models as M +import pandas as pd +import warnings +from ultralytics import YOLO + +torch.set_float32_matmul_precision('high') +torch.backends.cudnn.deterministic = True + +def Calc_Eval_table_New(TrainModel:M.RARP_NVB_Model): + TrainModel.to(device) + TrainModel.eval() + + Predictions = [] + Labels = [] + + if isinstance(TrainModel, M.RARP_NVB_Model_test2): + with torch.no_grad(): + for img, label in tqdm(iter(Test_DataLoader)): + img = img.float().to(device) + label = label.to(device) + + pred = TrainModel(img) + Predictions.append(torch.softmax(pred, dim=1)) + Labels.append(label) + + Predictions = torch.cat(Predictions) + Labels = torch.cat(Labels) + + print(Predictions, Labels) + + acc = torchmetrics.Accuracy("multiclass", num_classes=2).to(device)(Predictions, Labels) + precision = torchmetrics.Precision("multiclass", num_classes=2).to(device)(Predictions, Labels) + recall = torchmetrics.Recall("multiclass", num_classes=2).to(device)(Predictions, Labels) + auc = torchmetrics.AUROC("multiclass", num_classes=2).to(device)(Predictions, Labels) + f1Score = torchmetrics.F1Score("multiclass", num_classes=2).to(device)(Predictions, Labels) + + return [acc.item(), precision.item(), recall.item(), f1Score.item(), auc.item()] + + with torch.no_grad(): + for img, label in tqdm(iter(Test_DataLoader)): + img = img.float().to(device) + label = label.float().to(device) + + pred = TrainModel(img) + Predictions.append(torch.sigmoid(pred.squeeze(1))) + Labels.append(label) + + Predictions = torch.cat(Predictions) + Labels = torch.cat(Labels) + + print(Predictions, Labels) + + acc = torchmetrics.Accuracy('binary').to(device)(Predictions, Labels) + precision = torchmetrics.Precision('binary').to(device)(Predictions, Labels) + recall = torchmetrics.Recall('binary').to(device)(Predictions, Labels) + #cm = torchmetrics.ConfusionMatrix('binary')(Predictions, Labels) + auc = torchmetrics.AUROC('binary').to(device)(Predictions, Labels) + f1Score = torchmetrics.F1Score('binary').to(device)(Predictions, Labels) + + return [acc.item(), precision.item(), recall.item(), f1Score.item(), auc.item()] + +def Calc_Eval_table(TrainModel:M.RARP_NVB_Model,TestDataLoadre:DataLoader, Youden=False, modelName="", Add_TestDataset:DataLoader=None ): + TrainModel.to(device) + TrainModel.eval() + + Predictions = [] + Labels = [] + + with torch.no_grad(): + for data, label in tqdm(iter(TestDataLoadre)): + data = data.float().to(device) + label = label.to(device) + pred = TrainModel(data).flatten() + Predictions.append(torch.sigmoid(pred)) + Labels.append(label) + + if Add_TestDataset is not None: + with torch.no_grad(): + for data, label in tqdm(iter(Add_TestDataset)): + data = data.float().to(device) + label = label.to(device) + pred = TrainModel(data).flatten() + Predictions.append(torch.sigmoid(pred)) + Labels.append(label) + + Predictions = torch.cat(Predictions) + Labels = torch.cat(Labels) + + print(Predictions, Labels) + + acc = torchmetrics.Accuracy('binary').to(device)(Predictions, Labels) + precision = torchmetrics.Precision('binary').to(device)(Predictions, Labels) + recall = torchmetrics.Recall('binary').to(device)(Predictions, Labels) + auc = torchmetrics.AUROC('binary').to(device)(Predictions, Labels) + f1Score = torchmetrics.F1Score('binary').to(device)(Predictions, Labels) + specificty = torchmetrics.Specificity("binary").to(device)(Predictions, Labels) + + table = [ + ["0.5000", f"{acc.item():.4f}", f"{precision.item():.4f}", f"{recall.item():.4f}", f"{f1Score.item():.4f}", f"{auc.item():.4f}", f"{specificty.item():.4f}", ""] + ] + + if Youden: + for i in range(2): + aucCurve = torchmetrics.ROC("binary").to(device) + fpr, tpr, thhols = aucCurve(Predictions, Labels) + index = torch.argmax(tpr - fpr) + th2 = (recall + specificty - 1).item() + th2 = 0.5 if th2 <= 0 else th2 + th1 = thhols[index].item() if i == 0 else th2 + accY = torchmetrics.Accuracy('binary', threshold=th1).to(device)(Predictions, Labels) + precisionY = torchmetrics.Precision('binary', threshold=th1).to(device)(Predictions, Labels) + recallY = torchmetrics.Recall('binary', threshold=th1).to(device)(Predictions, Labels) + specifictyY = torchmetrics.Specificity("binary", threshold=th1).to(device)(Predictions, Labels) + f1ScoreY = torchmetrics.F1Score('binary', threshold=th1).to(device)(Predictions, Labels) + #cm2 = torchmetrics.ConfusionMatrix('binary', threshold=th1).to(device) + #cm2.update(Predictions, Labels) + #_, ax = cm2.plot() + #ax.set_title(f"NVB Classifier (th={th1:.4f})") + table.append([f"{th1:.4f}", f"{accY.item():.4f}", f"{precisionY.item():.4f}", f"{recallY.item():.4f}", f"{f1ScoreY.item():.4f}", f"{auc.item():.4f}", f"{specifictyY.item():.4f}", modelName]) + + + return table + +def setup_seed(seed): + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + np.random.seed(seed) + torch.backends.cudnn.deterministic = True + +def CAM(model:M.RARP_NVB_Model, img:torch.Tensor, device): + with torch.no_grad(): + img = img.to(device).float().unsqueeze(0) + pred, feature = model(img) + + _, c, h, w = feature.shape + feature = feature.reshape((c, h*w)) + if isinstance(model, (M.RARP_NVB_ResNet18_CAM, M.RARP_NVB_ResNet50_CAM)): + wParams = list(model.model.fc.parameters()) + elif isinstance(model, M.RARP_NVB_MobileNetV2_CAM): + wParams = list(model.model.classifier.parameters()) + pesos = wParams[0].detach() + cam = torch.matmul(pesos, feature) + + cam = cam - torch.min(cam) + cam_img = cam / torch.max(cam) + cam_img = cam_img.reshape(h, w).cpu() + + return cam_img, torch.sigmoid(pred) + +def CAMVisualizer(img, heatmap, pred, label, mean, std, ax, row): + img = img.numpy().transpose((1, 2, 0)) + heatmap = transforms.functional.resize(heatmap.unsqueeze(0), (img.shape[0], img.shape[1]), antialias=True)[0] + + img = np.clip((std * img + mean) / 255, 0, 1) + img = img[...,::-1].copy() + col = 0 + if row > 3: + col = 2 + + if row > 7: + col = 4 + + ax[row % 4][col + 0].imshow(img) + ax[row % 4][col + 0].axis('off') + + ax[row % 4][col + 1].imshow(img) + ax[row % 4][col + 1].imshow(heatmap, alpha=0.5, cmap="jet") + ax[row % 4][col + 1].axis('off') + ax[row % 4][col + 1].set_title(f"Pred.: {pred.item():.4f}; Label: {label}") + + #plt.title() + +def ShowCAM(TrainedModel:M.RARP_NVB_Model, DataSet, mean, std, title=""): + TrainedModel.to(device) + TrainedModel.eval() + i = 0 + params = { + "left":0, + "bottom":0.01, + "right":1, + "top":0.914, + "wspace":0, + "hspace":0.164 + } + fig, axis = plt.subplots(4, 6, gridspec_kw=params) + with torch.no_grad(): + if len(DataSet) > 12: + ix = np.unique(DataSet.targets, return_counts=True)[1] + NOTNVB_Indexs = np.asarray(range(ix[0])) + NVB_Indexs = np.asarray(range(ix[0], ix[0] + ix[1])) + np.random.shuffle(NOTNVB_Indexs) + np.random.shuffle(NVB_Indexs) + + for j, index in enumerate(NOTNVB_Indexs): + if j == 6: + break + img, label = DataSet[index] + cam, pred = CAM(TrainedModel, img, device) + CAMVisualizer(img, cam, pred, label, mean, std, axis, i) + i += 1 + + for j, index in enumerate(NVB_Indexs): + if j == 6: + break + img, label = DataSet[index] + cam, pred = CAM(TrainedModel, img, device) + CAMVisualizer(img, cam, pred, label, mean, std, axis, i) + i += 1 + else: + for img, label in tqdm(DataSet): + cam, pred = CAM(TrainedModel, img, device) + CAMVisualizer(img, cam, pred, label, mean, std, axis, i) + i += 1 + + fig.suptitle(title) + +def Calc_Eval(TrainModel:M.RARP_NVB_Model): + TrainModel.to(device) + TrainModel.eval() + + Predictions = [] + Labels = [] + + with torch.no_grad(): + for data, label in tqdm(testDataset): + data = data.to(device).float().unsqueeze(0) + pred = torch.sigmoid(TrainModel(data)[0].cpu()) + Predictions.append(pred) + Labels.append(label) + + Predictions = torch.cat(Predictions) + Labels = torch.tensor(Labels).int() + + print(Predictions, Labels) + + acc = torchmetrics.Accuracy('binary')(Predictions, Labels) + precision = torchmetrics.Precision('binary')(Predictions, Labels) + recall = torchmetrics.Recall('binary')(Predictions, Labels) + cm = torchmetrics.ConfusionMatrix('binary')(Predictions, Labels) + auc = torchmetrics.AUROC('binary')(Predictions, Labels) + f1Score = torchmetrics.F1Score('binary')(Predictions, Labels) + + print(f"Val Accuracy: {acc:.4f}") + print(f"Val Precision: {precision:.4f}") + print(f"Val Recall: {recall:.4f}") + print(f"F1 Score: {f1Score:.4f}") + print(f"AUROC: {auc:.4f}") + print(testDataset.classes) + + ax = sn.heatmap(cm, cmap="Greens", cbar=False, annot=True, annot_kws={"size": 18}, fmt='g', xticklabels=testDataset.classes, yticklabels=testDataset.classes) + ax.set_title(f"NVB Classifier Split #{args.Fold+1}") + ax.set_xlabel('Predict') + ax.set_ylabel('True') + plt.show() + + +if __name__ == "__main__": + + parser = argparse.ArgumentParser() + parser.add_argument("--Phase", default="train", type=str, help="'train' or 'eval'") + parser.add_argument("--Fold", type=int, default=0) + parser.add_argument("--Workers", type=int, default=0) + parser.add_argument("--Log_Name", type=str, default="logs_debug", help="the name of the directory of the log chkp") + parser.add_argument("--Model", type=int, default=0, help="0 = ResNet18, 1 = ResNet50") + parser.add_argument("-lv", "--Log_version", type=int) + parser.add_argument("-le", "--Log_epoch", type=int) + parser.add_argument("-ls", "--Log_step", type=int) + parser.add_argument("--Remove_Blackbar", type=bool, default=True) + parser.add_argument("--BGR2RGB", type=bool, default=False) + parser.add_argument("--CAM", type=bool, default=False) + parser.add_argument("-roi", "--Use_ROI_Dataset", type=int, default=0) + parser.add_argument("-s", "--imgSlice_pct", type=float, default=None) + parser.add_argument("-ns", "--Num_Slices", type=int, default=4) + parser.add_argument("-wl", "--Wloss",type=bool, default=False) + parser.add_argument("--sClass",type=int, default=None) + parser.add_argument("-tl", "--TypeLoss", type=int, default=0) + parser.add_argument("-cs", "--ColorSpace", type=int, default=None) + parser.add_argument("--JIndex", type=bool, default=False) + parser.add_argument("-me", "--maxEpochs", type=int, default=None) + parser.add_argument("-lc", "--LoadChkpt", type=str, default=None) + parser.add_argument("--AddTestSet", type=str, default=None) + + args = parser.parse_args() + + if args.CAM and args.Phase == "train": + raise Exception("Clases Activation Clases only in eval o eval_all") + + match args.Use_ROI_Dataset: + case 0: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_main", + FoldSeed=505, + createFile=True, + SavePath="./DataSet", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 720 + case 1: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_Crop", + FoldSeed=505, + createFile=True, + SavePath="./DataSetCrop", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 256 + case 2: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_Crop1", + FoldSeed=505, + createFile=True, + SavePath="./DataSetCrop1", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 256 + case 3: + YoloModel = YOLO(model="RARP_YoloV8_ROI.pt") + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_main", + FoldSeed=505, + createFile=True, + SavePath="./DataSet_YOLO", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace, + ROI_Yolo=YoloModel + ) + cropSize = 256 + case 4: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_big", + FoldSeed=505, + createFile=True, + SavePath="./DatasetBig", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 720 + Dataset.mean, Dataset.std = ([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) + case 6: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_full", + FoldSeed=505, + createFile=True, + SavePath="./DatasetFull", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 720 + Dataset.mean, Dataset.std = ([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) + case 7: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_smallBalaced", + FoldSeed=505, + createFile=True, + SavePath="./DatasetSmallBalanced", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 720 + Dataset.mean, Dataset.std = ([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) + case 5: + YoloModel = YOLO(model="RARP_YoloV8_ROI.pt") + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_big", + FoldSeed=505, + createFile=True, + SavePath="./DatasetBig_YOLO", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace, + ROI_Yolo=YoloModel + ) + cropSize = 256 + Dataset.mean, Dataset.std = ([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) + + Dataset.CreateFolds() + + setup_seed(2023) + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + batchSize = 17 #17 #8, 32 + numWorkers = args.Workers + InitResize = (256,256) + checkPtCallback = callbk.ModelCheckpoint(monitor='val_acc', filename="RARP-{epoch}", save_top_k=10, mode='max') + ckpLossBest = callbk.ModelCheckpoint(monitor="val_loss", filename="RARP-{epoch}-{val_loss:.2f}", save_top_k=2, mode='min') + traintransform = torch.nn.Sequential( + transforms.Resize(InitResize, antialias=True), + transforms.CenterCrop(224), #test w/ Centrecrop + transforms.RandomAffine( + degrees=(-5, 5), scale=(0.9, 1.1), #translate=(0, 0.05), + fill=5 + ), + #transforms.RandomResizedCrop(224, scale=(0.35, 1), antialias=True), + transforms.RandomHorizontalFlip(1.0), + transforms.Normalize(Dataset.mean, Dataset.std), + ).to(device) + + valtransform = torch.nn.Sequential( + transforms.Resize(256, antialias=True), + transforms.CenterCrop(224), + transforms.Normalize(Dataset.mean, Dataset.std) + ).to(device) + + testtransform = torch.nn.Sequential( + transforms.Resize(256, antialias=True), + transforms.CenterCrop(224), + transforms.Normalize(Dataset.mean, Dataset.std) + ).to(device) + + rootFile = Dataset.CVS_File.parent.parent/f"fold_{args.Fold}" + + Add_Test_DataLoader = None + + if args.AddTestSet is not None: + Add_TestDataset = torchvision.datasets.DatasetFolder( + str (Path(args.AddTestSet)/f"fold_{args.Fold}"/"test"), + loader=defs.load_file_tensor_norm, + extensions="npy", + transform=testtransform + ) + Add_Test_DataLoader = DataLoader( + Add_TestDataset, + batch_size=batchSize, + num_workers=numWorkers, + shuffle=False, + pin_memory=True + ) + + trainDataset = torchvision.datasets.DatasetFolder( + str (rootFile/"train"), + loader=defs.load_file_tensor_norm, + extensions="npy", + transform=traintransform + ) + + valDataset = torchvision.datasets.DatasetFolder( + str (rootFile/"val"), + loader=defs.load_file_tensor_norm, + extensions="npy", + transform=valtransform + ) + + testDataset = torchvision.datasets.DatasetFolder( + str (rootFile/"test"), + loader=defs.load_file_tensor_norm, + extensions="npy", + transform=testtransform + ) + + Train_DataLoader = DataLoader( + trainDataset, + batch_size=batchSize, + num_workers=numWorkers, + shuffle=True, + pin_memory=True + ) + Val_DataLoader = DataLoader( + valDataset, + batch_size=batchSize, + num_workers=numWorkers, + shuffle=False, + pin_memory=True + ) + Test_DataLoader = DataLoader( + testDataset, + batch_size=batchSize, + num_workers=numWorkers, + shuffle=False, + pin_memory=True + ) + + if args.CAM: + testCAMDataset = torchvision.datasets.DatasetFolder( + str (rootFile/"test"), + loader=defs.load_file_tensor_norm, + extensions="npy", + transform=torch.nn.Sequential( + transforms.Resize((224, 224), antialias=True), + transforms.Normalize(Dataset.mean, Dataset.std) + ).to(device) + ) + + TestCAM_DataLoader = DataLoader( + testCAMDataset, + batch_size=batchSize, + num_workers=numWorkers, + shuffle=False, + pin_memory=True + ) + + print(f"Currtent Fold Splits {Dataset.Splits[args.Fold]}") + print(f"Unique Values in sets") + info = np.unique(trainDataset.targets, return_counts=True), np.unique(valDataset.targets, return_counts=True), np.unique(testDataset.targets, return_counts=True) + print(info) + + neg = 0 + pos = 0 + for i in info: + neg += i[1][0] + pos += i[1][1] + + total = neg + pos + factor = 2 if args.TypeLoss == 1 else 1 + InitWeight = torch.tensor([total/(neg * factor), total/(pos * factor)]).to(device) if args.Wloss else None + if InitWeight is not None: + print(f"Weights {InitWeight}") + TypeLoss = M.TypeLossFunction(args.TypeLoss) + match args.Model: + case 0: + Model = M.RARP_NVB_ResNet50(InitWeight, TypeLoss) + ModelCAM = M.RARP_NVB_ResNet50_CAM() + case 1: + Model = M.RARP_NVB_ResNet18(InitWeight, TypeLoss) + ModelCAM = M.RARP_NVB_ResNet18_CAM() + case 2: + Model = M.RARP_NVB_MobileNetV2(InitWeight, TypeLoss) + ModelCAM = M.RARP_NVB_MobileNetV2_CAM() + case 3: + Model = M.RARP_NVB_EfficientNetV2(InitWeight, TypeLoss) + ModelCAM = M.RARP_NVB_EfficientNetV2_CAM() + case 4: + Model = M.RARP_NVB_Vit_b_16(InitWeight, TypeLoss) + ModelCAM = None + case 5: + Model = M.RARP_NVB_DenseNet169(InitWeight, TypeLoss) + ModelCAM = None + case _: + raise Exception("Model Not yet Implemented") + + NameModel = type(Model).__name__ + print(f"Model Used: {NameModel}") + LogFileName = f"{args.Log_Name}" #-{NameModel} + + MaxEpochs = 50 + if args.Model == 4: + MaxEpochs = 150 + + if args.maxEpochs is not None: + MaxEpochs = args.maxEpochs + + warnings.simplefilter("ignore") + trainer = L.Trainer( + accelerator='gpu', + devices=1, + logger=TensorBoardLogger(save_dir=f"./{LogFileName}"), + log_every_n_steps=5, + #callbacks=[checkPtCallback, StepDropout(5, base_drop_rate=0.2, gamma=0.05, ascending=True)],#if args.Model == 4 else checkPtCallback, + callbacks=[checkPtCallback, ckpLossBest, callbk.EarlyStopping(monitor="val_loss", mode="min", patience=5, verbose=True)], + max_epochs=MaxEpochs, + ) + + if args.Phase == "train": + print("Train Phase") + trainer.fit(Model, train_dataloaders=Train_DataLoader, val_dataloaders=Val_DataLoader, ckpt_path=args.LoadChkpt) + #trainer.callbacks + trainer.test(Model, dataloaders=Test_DataLoader, ckpt_path="best") + elif args.Phase == "eval_all": + print("Evaluation Phase") + rows = [] + pathCkptFile = Path(f"./{LogFileName}/lightning_logs/version_{args.Log_version}/checkpoints/") + for ckpFile in pathCkptFile.glob("*.ckpt"): + print(ckpFile.name) + temp = Calc_Eval_table(Model.load_from_checkpoint(ckpFile, strict=False), Test_DataLoader, args.JIndex, ckpFile.name, Add_TestDataset=Add_Test_DataLoader) + rows += temp + if args.CAM: + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + print("CAM") + ShowCAM(ModelCAM.load_from_checkpoint(ckpFile, strict=False), testCAMDataset, Dataset.mean, Dataset.std, ckpFile.name) + + df = pd.DataFrame(rows, columns=["Youden", "Acc","Precision","Recall","F1","AUROC","Specificity","CheckPoint"]) + df.style.highlight_max(color="red", axis=0) + print(df) + plt.show() + else: + print("Evaluation Phase") + trainLog = [args.Log_version, args.Log_epoch, args.Log_step] + pathCkptFile = Path(f"./{LogFileName}/lightning_logs/version_{trainLog[0]}/checkpoints/epoch={trainLog[1]}-step={trainLog[2]}.ckpt") + Calc_Eval(Model.load_from_checkpoint(pathCkptFile)) + if args.CAM: + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + ShowCAM(ModelCAM.load_from_checkpoint(pathCkptFile, strict=False), testCAMDataset, Dataset.mean, Dataset.std, pathCkptFile.name) + plt.show() \ No newline at end of file diff --git a/RARP_NVB.py b/RARP_NVB.py new file mode 100644 index 0000000..11e9fab --- /dev/null +++ b/RARP_NVB.py @@ -0,0 +1,1259 @@ +import torch +from torch.utils.data import DataLoader +import torchvision +from torchvision import transforms +import torchmetrics +import lightning as L +from lightning.pytorch import seed_everything +from lightning.pytorch.tuner import Tuner +import lightning.pytorch.callbacks as callbk +from lightning.pytorch.loggers import TensorBoardLogger, CSVLogger +from tqdm.notebook import tqdm +import numpy as np +import matplotlib.pyplot as plt +from pathlib import Path +import Loaders +import defs +import argparse +import seaborn as sn +import Models as M +import pandas as pd +import warnings +from ultralytics import YOLO +import yaml +import optuna +from optuna.integration import PyTorchLightningPruningCallback + +torch.set_float32_matmul_precision('high') +torch.backends.cudnn.deterministic = True + +def objective(trail: optuna.trial.Trial) -> float: + lr = trail.suggest_float("lr", 1e-4, 1e-3, log=True) + l1 = trail.suggest_float("L1", 1e-6, 1e-3, log=True) + Alpha = trail.suggest_float("W_Apha", 0, 1, step=0.05) + Thao = trail.suggest_float("Thao_KD", 1, 7, step=0.25) + + Trainer_OP = L.Trainer( + logger=TensorBoardLogger(save_dir=f"./{LogFileName}", name="Tune"), + #enable_checkpointing=False, + max_epochs=MaxEpochs, + accelerator="auto", + log_every_n_steps=5, + devices=1, + callbacks=[PyTorchLightningPruningCallback(trail, monitor="val_acc"), callbk.ModelCheckpoint(monitor='val_acc', filename="RARP-{epoch}", save_top_k=2, mode='max')], + ) + + hyperparameters = dict( + lr = lr, + L1 = l1, + Alpha = Alpha, + Beta = 1 - Alpha, + Thao = Thao + ) + + ModelOP, _ = getModel( + args.Model, + InitWeight, + TypeLoss, + OptConfig=hyperparameters + ) + + Trainer_OP.logger.log_hyperparams(hyperparameters) + + Trainer_OP.fit(ModelOP, train_dataloaders=Train_DataLoader, val_dataloaders=Val_DataLoader) + Trainer_OP.test(ModelOP, dataloaders=Test_DataLoader, ckpt_path="best") + + return Trainer_OP.callback_metrics["test_acc"].item() + +def Calc_Eval_table_New(TrainModel:M.RARP_NVB_Model): + TrainModel.to(device) + TrainModel.eval() + + Predictions = [] + Labels = [] + + if isinstance(TrainModel, M.RARP_NVB_Model_test2): + with torch.no_grad(): + for img, label in tqdm(iter(Test_DataLoader)): + img = img.float().to(device) + label = label.to(device) + + pred = TrainModel(img) + Predictions.append(torch.softmax(pred, dim=1)) + Labels.append(label) + + Predictions = torch.cat(Predictions) + Labels = torch.cat(Labels) + + print(Predictions, Labels) + + acc = torchmetrics.Accuracy("multiclass", num_classes=2).to(device)(Predictions, Labels) + precision = torchmetrics.Precision("multiclass", num_classes=2).to(device)(Predictions, Labels) + recall = torchmetrics.Recall("multiclass", num_classes=2).to(device)(Predictions, Labels) + auc = torchmetrics.AUROC("multiclass", num_classes=2).to(device)(Predictions, Labels) + f1Score = torchmetrics.F1Score("multiclass", num_classes=2).to(device)(Predictions, Labels) + + return [acc.item(), precision.item(), recall.item(), f1Score.item(), auc.item()] + + with torch.no_grad(): + for img, label in tqdm(iter(Test_DataLoader)): + img = img.float().to(device) + label = label.float().to(device) + + pred = TrainModel(img) + Predictions.append(torch.sigmoid(pred.squeeze(1))) + Labels.append(label) + + Predictions = torch.cat(Predictions) + Labels = torch.cat(Labels) + + print(Predictions, Labels) + + acc = torchmetrics.Accuracy('binary').to(device)(Predictions, Labels) + precision = torchmetrics.Precision('binary').to(device)(Predictions, Labels) + recall = torchmetrics.Recall('binary').to(device)(Predictions, Labels) + #cm = torchmetrics.ConfusionMatrix('binary')(Predictions, Labels) + auc = torchmetrics.AUROC('binary').to(device)(Predictions, Labels) + f1Score = torchmetrics.F1Score('binary').to(device)(Predictions, Labels) + + return [acc.item(), precision.item(), recall.item(), f1Score.item(), auc.item()] + +def Calc_EvalMulticlass_table(TrainModel:M.RARP_NVB_Model,TestDataLoadre:DataLoader, Youden=False, modelName=""): + TrainModel.to(device) + TrainModel.eval() + + Predictions = [] + Labels = [] + + with torch.no_grad(): + for data, label in tqdm(iter(TestDataLoadre)): + data = data.float().to(device) + label = label.to(device) + + pred = TrainModel(data) + Predictions.append(torch.softmax(pred, dim=1)) + Labels.append(label) + + Predictions = torch.cat(Predictions) + Labels = torch.cat(Labels) + + print(Predictions, Labels) + + acc = torchmetrics.Accuracy("multiclass", num_classes=2).to(device)(Predictions, Labels) + precision = torchmetrics.Precision("multiclass", num_classes=2).to(device)(Predictions, Labels) + recall = torchmetrics.Recall("multiclass", num_classes=2).to(device)(Predictions, Labels) + auc = torchmetrics.AUROC("multiclass", num_classes=2).to(device)(Predictions, Labels) + f1Score = torchmetrics.F1Score("multiclass", num_classes=2).to(device)(Predictions, Labels) + specificty = torchmetrics.Specificity("multiclass", num_classes=2).to(device)(Predictions, Labels) + + table = [ + ["0.5000", f"{acc.item():.4f}", f"{precision.item():.4f}", f"{recall.item():.4f}", f"{f1Score.item():.4f}", f"{auc.item():.4f}", f"{specificty.item():.4f}", f"*{modelName}*"] #.item():.4f + ] + + #cm2 = torchmetrics.ConfusionMatrix("multiclass", num_classes=2).to(device) + #cm2.update(Predictions, Labels) + #_, ax = cm2.plot() + #ax.set_title(f"NVB Classifier") + + if Youden: + for i in range(2): + aucCurve = torchmetrics.ROC("multiclass", num_classes=2).to(device) + fpr, tpr, thhols = aucCurve(Predictions, Labels) + index = torch.argmax(tpr - fpr) + th2 = (recall + specificty - 1).item() + th2 = 0.5 if th2 <= 0 else th2 + th1 = thhols[index].item() if i == 0 else th2 + accY = torchmetrics.Accuracy("multiclass", num_classes=2, threshold=th1).to(device)(Predictions, Labels) + precisionY = torchmetrics.Precision("multiclass", num_classes=2, threshold=th1).to(device)(Predictions, Labels) + recallY = torchmetrics.Recall("multiclass", num_classes=2, threshold=th1).to(device)(Predictions, Labels) + specifictyY = torchmetrics.Specificity("binary", threshold=th1).to(device)(Predictions, Labels) + f1ScoreY = torchmetrics.F1Score("multiclass", num_classes=2, threshold=th1).to(device)(Predictions, Labels) + #cm2 = torchmetrics.ConfusionMatrix("multiclass", num_classes=2, threshold=th1).to(device) + #cm2.update(Predictions, Labels) + #_, ax = cm2.plot() + #ax.set_title(f"NVB Classifier (th={th1:.4f})") + table.append([f"{th1:.4f}", f"{accY.item():.4f}", f"{precisionY.item():.4f}", f"{recallY.item():.4f}", f"{f1ScoreY.item():.4f}", f"{auc.item():.4f}", f"{specifictyY.item():.4f}", modelName]) + + + return table + +def Calc_Eval_table( + TrainModel:M.RARP_NVB_Model, + TestDataLoadre:DataLoader, + Youden=False, modelName="", + Add_TestDataset:DataLoader=None, + extraData:bool=False, + PseudoLabel:bool=True, + dataSetInfo:Loaders.RARP_DatasetCreator = None +): + TrainModel.to(device) + TrainModel.eval() + + Predictions = [] + Labels = [] + PseudoLabelTest = None + ban_ExtraImage = isinstance(testDataset, Loaders.RARP_DatasetFolder_DobleTransform) + + with torch.no_grad(): + for data, label in tqdm(iter(TestDataLoadre)): + if extraData: + img, extra = data + img = img.float().to(device) + extra = extra.float().to(device) + data = (img, extra) + elif ban_ExtraImage: + if len(data) == 3: + TData, Sdata, OData = data + data = (TData.float().to(device), Sdata.float().to(device), OData.float().to(device)) + else: + TData, Sdata = data + data = (TData.float().to(device), Sdata.float().to(device)) + else: + data = data.float().to(device) + + label = label.to(device) + + if isinstance(TrainModel, M.RARP_NVB_ResNet50_VAN): + pred, Plabel, _ = TrainModel(data) + pred = pred.flatten() + label = Plabel.int() if PseudoLabel else label + elif isinstance(TrainModel, (M.RARP_NVB_RN50_VAN_V2, M.RARP_NVB_DINO_MultiTask)): + pred, features, new_img = TrainModel(data) + pred = pred.flatten() + #_, axis = plt.subplots(2, 2, figsize=(9, 9)) + #for i in range(2): + # for j in range(2): + # random_index = np.random.randint(0, len(new_img)) + # img = new_img[random_index].cpu() + # img = img.numpy().transpose((1, 2, 0)) + # img = np.clip((dataSetInfo.std * img + dataSetInfo.mean) / 255, 0, 1) + # img = img[...,::-1].copy() + + # axis[i][j].imshow(img) + + elif isinstance(TrainModel, M.RARP_NVB_DINO_RestNet50_Deep): + DK_PredLabels, _ = TrainModel(data) + pred, Plabel, _ = DK_PredLabels + label = Plabel.int() if PseudoLabel else label + else: + pred = TrainModel(data).flatten() + + Predictions.append(torch.sigmoid(pred)) + Labels.append(label) + + if Add_TestDataset is not None: + with torch.no_grad(): + for data, label in tqdm(iter(Add_TestDataset)): + data = data.float().to(device) + label = label.to(device) + pred = TrainModel(data).flatten() + Predictions.append(torch.sigmoid(pred)) + Labels.append(label) + + Predictions = torch.cat(Predictions) + Labels = torch.cat(Labels) + + print(Predictions, Labels) + + acc = torchmetrics.Accuracy('binary').to(device)(Predictions, Labels) + precision = torchmetrics.Precision('binary').to(device)(Predictions, Labels) + recall = torchmetrics.Recall('binary').to(device)(Predictions, Labels) + auc = torchmetrics.AUROC('binary').to(device)(Predictions, Labels) + f1Score = torchmetrics.F1Score('binary').to(device)(Predictions, Labels) + specificty = torchmetrics.Specificity("binary").to(device)(Predictions, Labels) + + table = [ + ["0.5000", f"{acc.item():.4f}", f"{precision.item():.4f}", f"{recall.item():.4f}", f"{f1Score.item():.4f}", f"{auc.item():.4f}", f"{specificty.item():.4f}", ""] + ] + + if Youden: + for i in range(2): + aucCurve = torchmetrics.ROC("binary").to(device) + fpr, tpr, thhols = aucCurve(Predictions, Labels) + index = torch.argmax(tpr - fpr) + th2 = (recall + specificty - 1).item() + th2 = 0.5 if th2 <= 0 else th2 + th1 = thhols[index].item() if i == 0 else th2 + accY = torchmetrics.Accuracy('binary', threshold=th1).to(device)(Predictions, Labels) + precisionY = torchmetrics.Precision('binary', threshold=th1).to(device)(Predictions, Labels) + recallY = torchmetrics.Recall('binary', threshold=th1).to(device)(Predictions, Labels) + specifictyY = torchmetrics.Specificity("binary", threshold=th1).to(device)(Predictions, Labels) + f1ScoreY = torchmetrics.F1Score('binary', threshold=th1).to(device)(Predictions, Labels) + #cm2 = torchmetrics.ConfusionMatrix('binary', threshold=th1).to(device) + #cm2.update(Predictions, Labels) + #_, ax = cm2.plot() + #ax.set_title(f"NVB Classifier (th={th1:.4f})") + table.append([f"{th1:.4f}", f"{accY.item():.4f}", f"{precisionY.item():.4f}", f"{recallY.item():.4f}", f"{f1ScoreY.item():.4f}", f"{auc.item():.4f}", f"{specifictyY.item():.4f}", modelName]) + + + return table + +def setup_seed(seed): + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + np.random.seed(seed) + seed_everything(seed, workers=True) + torch.backends.cudnn.deterministic = True + +def CAM(model:M.RARP_NVB_Model, img:torch.Tensor, device): + with torch.no_grad(): + img = img.to(device).float().unsqueeze(0) + if isinstance(model, M.RARP_NVB_VAN_CAM): + pred, feature = model(img, torch.tensor([0.0]).to(device)) + else: + pred, feature = model(img) + + _, c, h, w = feature.shape + feature = feature.reshape((c, h*w)) + if isinstance(model, (M.RARP_NVB_ResNet18_CAM, M.RARP_NVB_ResNet50_CAM)): + wParams = list(model.model.fc.parameters()) + elif isinstance(model, (M.RARP_NVB_MobileNetV2_CAM, M.RARP_NVB_EfficientNetV2_CAM)): + wParams = list(model.model.classifier.parameters()) + elif isinstance(model, M.RARP_NVB_VAN_CAM): + wParams = list(model.model.head.parameters()) + else: + raise "Cam Not Implemented" + pesos = wParams[0].detach() + cam = torch.matmul(pesos, feature) + + cam = cam - torch.min(cam) + cam_img = cam / torch.max(cam) + cam_img = cam_img.reshape(h, w).cpu() + + return cam_img, torch.sigmoid(pred) + +def CAMVisualizer(img, heatmap, pred, label, mean, std, ax, row): + img = img.numpy().transpose((1, 2, 0)) + heatmap = transforms.functional.resize(heatmap.unsqueeze(0), (img.shape[0], img.shape[1]), antialias=True)[0] + + img = np.clip((std * img + mean) / 255, 0, 1) + img = img[...,::-1].copy() + col = 0 + if row > 3: + col = 2 + + if row > 7: + col = 4 + + ax[row % 4][col + 0].imshow(img) + ax[row % 4][col + 0].axis('off') + + ax[row % 4][col + 1].imshow(img) + ax[row % 4][col + 1].imshow(heatmap, alpha=0.5, cmap="jet") + ax[row % 4][col + 1].axis('off') + ax[row % 4][col + 1].set_title(f"Pred.: {pred.item():.4f}; Label: {label}") + + #plt.title() + +def ShowCAM(TrainedModel:M.RARP_NVB_Model, DataSet, mean, std, title=""): + TrainedModel.to(device) + TrainedModel.eval() + i = 0 + params = { + "left":0, + "bottom":0.01, + "right":1, + "top":0.914, + "wspace":0, + "hspace":0.164 + } + fig, axis = plt.subplots(4, 6, gridspec_kw=params) + with torch.no_grad(): + if len(DataSet) > 12: + ix = np.unique(DataSet.targets, return_counts=True)[1] + NOTNVB_Indexs = np.asarray(range(ix[0])) + NVB_Indexs = np.asarray(range(ix[0], ix[0] + ix[1])) + #np.random.shuffle(NOTNVB_Indexs) + #np.random.shuffle(NVB_Indexs) + + for j, index in enumerate(NOTNVB_Indexs): + if j == 6: + break + img, label = DataSet[index] + cam, pred = CAM(TrainedModel, img, device) + CAMVisualizer(img, cam, pred, label, mean, std, axis, i) + i += 1 + + for j, index in enumerate(NVB_Indexs): + if j == 6: + break + img, label = DataSet[index] + cam, pred = CAM(TrainedModel, img, device) + CAMVisualizer(img, cam, pred, label, mean, std, axis, i) + i += 1 + else: + for img, label in tqdm(DataSet): + cam, pred = CAM(TrainedModel, img, device) + CAMVisualizer(img, cam, pred, label, mean, std, axis, i) + i += 1 + + fig.suptitle(title) + +def Calc_Eval(TrainModel:M.RARP_NVB_Model): + TrainModel.to(device) + TrainModel.eval() + + Predictions = [] + Labels = [] + + with torch.no_grad(): + for data, label in tqdm(testDataset): + data = data.to(device).float().unsqueeze(0) + pred = torch.sigmoid(TrainModel(data)[0].cpu()) + Predictions.append(pred) + Labels.append(label) + + Predictions = torch.cat(Predictions) + Labels = torch.tensor(Labels).int() + + print(Predictions, Labels) + + acc = torchmetrics.Accuracy('binary')(Predictions, Labels) + precision = torchmetrics.Precision('binary')(Predictions, Labels) + recall = torchmetrics.Recall('binary')(Predictions, Labels) + cm = torchmetrics.ConfusionMatrix('binary')(Predictions, Labels) + auc = torchmetrics.AUROC('binary')(Predictions, Labels) + f1Score = torchmetrics.F1Score('binary')(Predictions, Labels) + + print(f"Val Accuracy: {acc:.4f}") + print(f"Val Precision: {precision:.4f}") + print(f"Val Recall: {recall:.4f}") + print(f"F1 Score: {f1Score:.4f}") + print(f"AUROC: {auc:.4f}") + print(testDataset.classes) + + ax = sn.heatmap(cm, cmap="Greens", cbar=False, annot=True, annot_kws={"size": 18}, fmt='g', xticklabels=testDataset.classes, yticklabels=testDataset.classes) + ax.set_title(f"NVB Classifier Split #{args.Fold+1}") + ax.set_xlabel('Predict') + ax.set_ylabel('True') + plt.show() + +def getModel ( + Model_ID:int = 0, + InitWeight=torch.tensor([1,1]), + TypeLoss:M.TypeLossFunction = M.TypeLossFunction.CrossEntropy, + Ckpt_File:Path = None, + OptConfig:dict = {}, + inputNeurons:int = 4, + mean:float = None, + std:float = None +): + Model = None + ModelCAM = None + match Model_ID: + case 0: + Model = M.RARP_NVB_ResNet50(InitWeight, TypeLoss, schedulerLR=args.DyLr) if Ckpt_File is None else M.RARP_NVB_ResNet50.load_from_checkpoint(ckpFile) + ModelCAM = None if Ckpt_File is None else M.RARP_NVB_ResNet50_CAM.load_from_checkpoint(ckpFile, strict=False) + case 1: + Model = M.RARP_NVB_ResNet18(InitWeight, TypeLoss, schedulerLR=args.DyLr) if Ckpt_File is None else M.RARP_NVB_ResNet18.load_from_checkpoint(ckpFile) + ModelCAM = None if Ckpt_File is None else M.RARP_NVB_ResNet18_CAM.load_from_checkpoint(ckpFile, strict=False) + case 2: + Model = M.RARP_NVB_MobileNetV2(InitWeight, TypeLoss, schedulerLR=args.DyLr) if Ckpt_File is None else M.RARP_NVB_MobileNetV2.load_from_checkpoint(ckpFile) + ModelCAM = None if Ckpt_File is None else M.RARP_NVB_MobileNetV2_CAM.load_from_checkpoint(ckpFile, strict=False) + case 3: + Model = M.RARP_NVB_EfficientNetV2(InitWeight, TypeLoss, schedulerLR=args.DyLr) if Ckpt_File is None else M.RARP_NVB_EfficientNetV2.load_from_checkpoint(ckpFile) + ModelCAM = None + case 4: + Model = M.RARP_NVB_Vit_b_16(InitWeight, TypeLoss) if Ckpt_File is None else M.RARP_NVB_Vit_b_16.load_from_checkpoint(ckpFile) + ModelCAM = None + case 5: + Model = M.RARP_NVB_DenseNet169(InitWeight, TypeLoss) if Ckpt_File is None else M.RARP_NVB_DenseNet169.load_from_checkpoint(ckpFile) + ModelCAM = None + case 6: + Model = M.RARP_NVB_ResNet50_V1(InitWeight, TypeLoss, schedulerLR=args.DyLr, InputNeurons=inputNeurons) if Ckpt_File is None else M.RARP_NVB_ResNet50_V1.load_from_checkpoint(ckpFile) + ModelCAM = None + case 7: + with open(f"train-EFold{args.Fold}.yaml") as file: + configFile = yaml.load(file, Loader=yaml.FullLoader) + + Models = [] + + for models in configFile["models"]: + match models: + case "ResNet50": + if configFile["models"][models] is not None: + for pathckpt in configFile["models"][models]: + #Models.append(M.RARP_NVB_ResNet50.load_from_checkpoint(Path(pathckpt), strict=False)) + Models.append(M.RARP_NVB_ResNet50(InitWeight, TypeLoss)) + case "ResNet18": + if configFile["models"][models] is not None: + for pathckpt in configFile["models"][models]: + #Models.append(M.RARP_NVB_ResNet18.load_from_checkpoint(Path(pathckpt), strict=False)) + Models.append(M.RARP_NVB_ResNet18(InitWeight, TypeLoss)) + case "MobileNetV2": + if configFile["models"][models] is not None: + for pathckpt in configFile["models"][models]: + #Models.append(M.RARP_NVB_MobileNetV2.load_from_checkpoint(Path(pathckpt), strict=False)) + Models.append(M.RARP_NVB_MobileNetV2(InitWeight, TypeLoss)) + case "EfficientNetV2": + if configFile["models"][models] is not None: + for pathckpt in configFile["models"][models]: + #Models.append(M.RARP_NVB_EfficientNetV2.load_from_checkpoint(Path(pathckpt), strict=False)) + Models.append(M.RARP_NVB_EfficientNetV2(InitWeight, TypeLoss)) + case "DenseNet169": + if configFile["models"][models] is not None: + for pathckpt in configFile["models"][models]: + #Models.append(M.RARP_NVB_DenseNet169.load_from_checkpoint(Path(pathckpt), strict=False)) + Models.append(M.RARP_NVB_DenseNet169(InitWeight, TypeLoss)) + case _: + pass + + print (f"{len(Models)} models Loaded") + + Model = M.RARP_Ensemble(Models, InitWeight, TypeLoss, lr=1e-3) + ModelCAM = None + case 8: + Model = M.RARP_NVB_DaVit(InitWeight, TypeLoss) if Ckpt_File is None else M.RARP_NVB_DaVit.load_from_checkpoint(ckpFile) + ModelCAM = None + case 9: + Model = M.RARP_NVB_ResNet50_Deep(InitWeight, TypeLoss, schedulerLR=args.DyLr) if Ckpt_File is None else M.RARP_NVB_ResNet50_Deep.load_from_checkpoint(ckpFile) + ModelCAM = None + case 10: + Model = M.RARP_NVB_EfficientNetV2_Deep(InitWeight, TypeLoss, schedulerLR=args.DyLr) if Ckpt_File is None else M.RARP_NVB_EfficientNetV2_Deep.load_from_checkpoint(ckpFile) + ModelCAM = None + case 11: + Model = M.RARP_NVB_ResNet50_V2(InitWeight, TypeLoss, schedulerLR=args.DyLr, InputNeurons=inputNeurons) if Ckpt_File is None else M.RARP_NVB_ResNet50_V2.load_from_checkpoint(ckpFile) + ModelCAM = None + case 12: + Model = M.RARP_NVB_ResNet50_V3(InitWeight, TypeLoss, schedulerLR=args.DyLr, InputNeurons=inputNeurons) if Ckpt_File is None else M.RARP_NVB_ResNet50_V3.load_from_checkpoint(ckpFile) + ModelCAM = None + case 13: + Model = M.RARP_NVB_VAN(InitWeight, TypeLoss, schedulerLR=args.DyLr) if Ckpt_File is None else M.RARP_NVB_VAN.load_from_checkpoint(ckpFile) + ModelCAM = None if Ckpt_File is None else M.RARP_NVB_VAN_CAM.load_from_checkpoint(ckpFile, strict=False) + case 14: + TestModel = torchvision.models.resnet50(weights=torchvision.models.ResNet50_Weights.DEFAULT) + tempFC_ft = TestModel.fc.in_features + TestModel.fc = torch.nn.Linear(in_features=tempFC_ft, out_features=2) + Model = M.RARP_NVB_MultiClassModel(None, Model=TestModel) if Ckpt_File is None else M.RARP_NVB_MultiClassModel.load_from_checkpoint(ckpFile,Model=TestModel) + ModelCAM = None + case 15: + #if OptConfig.get("lr") is None: + # OptConfig = dict( + # lr = None, #0.00015278, #1.53E-4, + # L1 = None, #0.0000020505, #2.05E-6, + # Alpha = 0.45, + # Gamma = 0.5, + # Thao = 5#2 + # ) + Model = M.RARP_NVB_ResNet50_VAN( + "./log_ResNet50_X10/lightning_logs/version_8/checkpoints/RARP-epoch=5.ckpt", + #"./log_X10/lightning_logs/version_0/checkpoints/RARP-epoch=39.ckpt", + 0.5, + InitWeight, + TypeLoss, + schedulerLR=args.DyLr, + PseudoLables=False, + HParameter=OptConfig + ) if Ckpt_File is None else M.RARP_NVB_ResNet50_VAN.load_from_checkpoint(ckpFile) + ModelCAM = None + case 16: + Model = M.RARP_NVB_SSL_RestNet50_Deep("./log_ResNet50_Deep_X10/lightning_logs/version_3/checkpoints/RARP-epoch=9.ckpt", 0.5, InitWeight, TypeLoss, schedulerLR=args.DyLr) if Ckpt_File is None else M.RARP_NVB_SSL_RestNet50_Deep.load_from_checkpoint(ckpFile) + #Model = M.RARP_NVB_SSL_RestNet50_Deep("./log_ResNet50DeepSSL_X10/lightning_logs/version_8/checkpoints/RARP-epoch=42.ckpt", 0.5, InitWeight, TypeLoss, schedulerLR=args.DyLr) if Ckpt_File is None else M.RARP_NVB_SSL_RestNet50_Deep.load_from_checkpoint(ckpFile) + ModelCAM = None + case 17: + Model = M.RARP_NVB_DINO_RestNet50_Deep( + "./log_ResNet50_Deep_X10/lightning_logs/version_3/checkpoints/RARP-epoch=9.ckpt", + threshold=0.5, + TypeLoss=TypeLoss, + L1=1.31E-04, + ) if Ckpt_File is None else M.RARP_NVB_DINO_RestNet50_Deep.load_from_checkpoint(ckpFile) + ModelCAM = None + case 18: + Model = M.RARP_NVB_DINO_VAN( + "./log_ResNet50_Deep_X10/lightning_logs/version_3/checkpoints/RARP-epoch=9.ckpt", + threshold=0.5, + TypeLoss=TypeLoss, + #L1=1.31E-04 + ) if Ckpt_File is None else M.RARP_NVB_DINO_VAN.load_from_checkpoint(ckpFile) + ModelCAM = None + case 19: + Model = M.RARP_NVB_RN50_VAN_V2( + #"./log_X10/lightning_logs/version_0/checkpoints/RARP-epoch=39.ckpt", + "./log_ResNet50_X10/lightning_logs/version_8/checkpoints/RARP-epoch=5.ckpt", + 0.5, + InitWeight, + TypeLoss, + schedulerLR=args.DyLr, + PseudoLables=False, + HParameter=OptConfig, std=std, mean=mean + ) if Ckpt_File is None else M.RARP_NVB_RN50_VAN_V2.load_from_checkpoint(ckpFile) + ModelCAM = None + case 20: + Model = M.RARP_NVB_DINO_MultiTask( + TypeLoss, + std=std, + mean=mean, + L1= 1.31E-04, + L2= 0 + ) if Ckpt_File is None else M.RARP_NVB_DINO_MultiTask.load_from_checkpoint(ckpFile) + ModelCAM = None + + case _: + raise Exception("Model Not yet Implemented") + + return (Model, ModelCAM) + +def ViewImg(dataset, std, mean): + _, axis = plt.subplots(2, 2, figsize=(9, 9)) + for i in range(2): + for j in range(2): + random_index = np.random.randint(0, 44) + img, label = dataset[random_index] + img, _ = img + img = img.numpy().transpose((1, 2, 0)) + img = np.clip((std * img + mean) / 255, 0, 1) + img = img[...,::-1].copy() + + axis[i][j].imshow(img) + axis[i][j].set_title(f"Label:{label}") + +def ViewImgDINO(dataset, std, mean): + _, axis = plt.subplots(4, 7, figsize=(25, 25)) + for i in range(4): + random_index = np.random.randint(0, len(dataset.targets)) + imgCrops, label = dataset[random_index] + for j, img in enumerate(imgCrops): + img = img.numpy().transpose((1, 2, 0)) + img = np.clip((std * img + mean) / 255, 0, 1) + img = img[...,::-1].copy() + + axis[i][j].imshow(img) + axis[i][j].set_title(f"Label:{label}") + axis[i][j].set_axis_off() + + +if __name__ == "__main__": + + parser = argparse.ArgumentParser() + parser.add_argument("--Phase", default="train", type=str, help="'train' or 'eval'") + parser.add_argument("--Fold", type=int, default=0) + parser.add_argument("--Workers", type=int, default=0) + parser.add_argument("--Log_Name", type=str, default="logs_debug", help="the name of the directory of the log chkp") + parser.add_argument("--Model", type=int, default=0, help="0 = ResNet18, 1 = ResNet50") + parser.add_argument("-lv", "--Log_version", type=int) + parser.add_argument("-le", "--Log_epoch", type=int) + parser.add_argument("-ls", "--Log_step", type=int) + parser.add_argument("--Remove_Blackbar", type=bool, default=True) + parser.add_argument("--BGR2RGB", type=bool, default=False) + parser.add_argument("--CAM", type=bool, default=False) + parser.add_argument("-roi", "--Use_ROI_Dataset", type=int, default=0) + parser.add_argument("-s", "--imgSlice_pct", type=float, default=None) + parser.add_argument("-ns", "--Num_Slices", type=int, default=4) + parser.add_argument("-wl", "--Wloss",type=bool, default=False) + parser.add_argument("--sClass",type=int, default=None) + parser.add_argument("-tl", "--TypeLoss", type=int, default=0) + parser.add_argument("-cs", "--ColorSpace", type=int, default=None) + parser.add_argument("--JIndex", type=bool, default=False) + parser.add_argument("-me", "--maxEpochs", type=int, default=None) + parser.add_argument("-lc", "--LoadChkpt", type=str, default=None) + parser.add_argument("--AddTestSet", type=str, default=None) + parser.add_argument("--Metadata", type=str, default=None) + parser.add_argument("--DyLr", type=bool, default=False) + parser.add_argument("-lr", type=float, default=1e-4) + parser.add_argument("--ExtraNeurons", type=int, default=4) + + + args = parser.parse_args() + + if args.CAM and args.Phase == "train": + raise Exception("Clases Activation Clases only in eval o eval_all") + + match args.Use_ROI_Dataset: + case 0: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_main", + FoldSeed=505, + createFile=True, + SavePath="./DataSet", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 720 + case 1: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_Crop", + FoldSeed=505, + createFile=True, + SavePath="./DataSetCrop", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 256 + case 2: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_Crop1", + FoldSeed=505, + createFile=True, + SavePath="./DataSetCrop1", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 256 + case 3: + YoloModel = YOLO(model="RARP_YoloV8_ROI.pt") + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_main", + FoldSeed=505, + createFile=True, + SavePath="./DataSet_YOLO", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace, + ROI_Yolo=YoloModel + ) + cropSize = 256 + case 4: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_big", + FoldSeed=505, + createFile=True, + SavePath="./DatasetBig", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 720 + case 6: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_Full", + FoldSeed=505, + createFile=True, + SavePath="./DatasetFull", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 720 + case 7: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_smallBalaced", + FoldSeed=505, + createFile=True, + SavePath="./DatasetSmallBalanced", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 720 + case 8: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_big_2", + FoldSeed=505, + createFile=True, + SavePath="./DatasetBig2", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 720 + case 9: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_Ando", + FoldSeed=505, + createFile=True, + SavePath="./DataSetAndo", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 720 + case 10: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_smallBalacedCrop", + FoldSeed=505, + createFile=True, + SavePath="./DataSet_SB_Crop", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 256 + case 11: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_AndoCrop", + FoldSeed=505, + createFile=True, + SavePath="./DataSet_SB_Ando_Crop", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 256 + case 12: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_Ando_All_Crop", + FoldSeed=505, + createFile=True, + SavePath="./DataSet_Ando_Crop", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 256 + case 13: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_Ando_All", + FoldSeed=505, + createFile=True, + SavePath="./DataSet_Ando_All", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 720 + case 14: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_Ando_AllNewLabels", + FoldSeed=505, + createFile=True, + SavePath="./DataSet_New_labels", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 720 + case 15: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_Ando_ChageLabels", + FoldSeed=505, + createFile=True, + SavePath="./DataSet_C_L", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 720 + case 16: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_Ando_ChageLabels_crop", + FoldSeed=505, + createFile=True, + SavePath="./DataSet_Ando_Crop", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 256 + case 17: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_Ando_All_no20", + FoldSeed=505, + createFile=True, + SavePath="./DataSet_Ando_All_20", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 720 + case 5: + YoloModel = YOLO(model="RARP_YoloV8_ROI.pt") + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_big", + FoldSeed=505, + createFile=True, + SavePath="./DatasetBig_YOLO", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace, + ROI_Yolo=YoloModel + ) + cropSize = 256 + + Dataset.CreateFolds() + + Dataset.mean, Dataset.std = ([30.38144216, 42.03988769, 97.8896116], [40.63141752, 44.26910074, 50.29294373]) + + setup_seed(2023) + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + batchSize = 8 #17 #8, 32 + numWorkers = args.Workers + InitResize = (256,256) + ImgResize = (224, 224) + checkPtCallback = callbk.ModelCheckpoint(monitor='val_acc', filename="RARP-{epoch}", save_top_k=10, mode='max') + ckpLossBest = callbk.ModelCheckpoint(monitor="val_loss", filename="RARP-{epoch}-{val_loss:.2f}", save_top_k=2, mode='min') + + + + traintransform = torch.nn.Sequential( + transforms.Resize(InitResize, antialias=True, interpolation=transforms.InterpolationMode.BICUBIC), + transforms.CenterCrop(224), #AQUI se cambio 2024/05/10 + #transforms.RandomCrop(ImgResize), + transforms.RandomAffine( + degrees=(-5, 5), scale=(0.9, 1.1), + fill=5 + ), + transforms.RandomHorizontalFlip(1.0), + transforms.Normalize(Dataset.mean, Dataset.std), + ).to(device) + + traintransformT2 = torch.nn.Sequential( + transforms.Resize(InitResize, antialias=True, interpolation=transforms.InterpolationMode.BICUBIC), + transforms.RandomCrop(224), + transforms.RandomErasing(0.8, value="random"), + transforms.RandomAffine(degrees=(-45, 45), scale=(0.8, 1.2), fill=5), + transforms.GaussianBlur(5), + transforms.Normalize(Dataset.mean, Dataset.std) + ).to(device) + + valtransform = torch.nn.Sequential( + transforms.Resize(256, antialias=True, interpolation=transforms.InterpolationMode.BICUBIC), + transforms.CenterCrop(224), + transforms.Normalize(Dataset.mean, Dataset.std) + ).to(device) + + testtransform = torch.nn.Sequential( + transforms.Resize(256, antialias=True, interpolation=transforms.InterpolationMode.BICUBIC), + transforms.CenterCrop(224), + transforms.Normalize(Dataset.mean, Dataset.std) + ).to(device) + + TrainDINOTransforms = Loaders.RARP_DINO_Augmentation( + GloblaCropsScale = (0.4, 1), + LocalCropsScale = (0.05, 0.4), + NumLocalCrops = 4, + Size = 224, + device = device, + mean = Dataset.mean, + std = Dataset.std, + Tranform_0 = testtransform if args.Model == 20 else None + ) + + rootFile = Dataset.CVS_File.parent.parent/f"fold_{args.Fold}" + + Add_Test_DataLoader = None + + traintransform = TrainDINOTransforms if args.Model in (17, 18, 20) else traintransform + + if args.AddTestSet is not None and args.Metadata is None: + Add_TestDataset = torchvision.datasets.DatasetFolder( + str (Path(args.AddTestSet)/f"fold_{args.Fold}"/"test"), + loader=defs.load_file_tensor, + extensions="npy", + transform=testtransform + ) + Add_Test_DataLoader = DataLoader( + Add_TestDataset, + batch_size=batchSize, + num_workers=numWorkers, + shuffle=False, + pin_memory=True + ) + + if args.Metadata is None: + if args.Model in (15, 16, 19): + trainDataset = Loaders.RARP_DatasetFolder_DobleTransform( + str (rootFile/"train"), + loader=defs.load_file_tensor, + extensions="npy", + transformT1=traintransform, + transformT2=traintransformT2, + passOriginal= testtransform if args.Model == 19 else None + ) + + valDataset = Loaders.RARP_DatasetFolder_DobleTransform( + str (rootFile/"val"), + loader=defs.load_file_tensor, + extensions="npy", + transformT1=valtransform, + passOriginal= testtransform if args.Model == 19 else None + ) + + testDataset = Loaders.RARP_DatasetFolder_DobleTransform( + str (rootFile/"test"), + loader=defs.load_file_tensor, + extensions="npy", + transformT1=testtransform, + passOriginal= testtransform if args.Model == 19 else None + ) + else: + trainDataset = torchvision.datasets.DatasetFolder( + str (rootFile/"train"), + loader=defs.load_file_tensor, + extensions="npy", + transform=traintransform + ) + + valDataset = torchvision.datasets.DatasetFolder( + str (rootFile/"val"), + loader=defs.load_file_tensor, + extensions="npy", + transform=valtransform + ) + + testDataset = torchvision.datasets.DatasetFolder( + str (rootFile/"test"), + loader=defs.load_file_tensor, + extensions="npy", + transform=testtransform + ) + else: + DumpCSV = pd.read_csv(Dataset.CVS_File) + Extradata = pd.read_excel(Path(args.Metadata)) + + Extradata["name"] = Extradata["列1"].astype(str) + ".tiff" + Extradata = Extradata.drop(columns=["列1"]) + + DumpCSV["raw_name"] = "Img0-" + DumpCSV["id"].astype(str) + ".npy" + DumpCSV = DumpCSV.drop(columns=["id", "path", "mean_1", "mean_2", "mean_3", "std_1", "std_2", "std_3"]) + + NewData = pd.merge(Extradata, DumpCSV, on="name") + + trainDataset = Loaders.RARP_DatasetFolder_ExtraData( + str (rootFile/"train"), + loader=defs.load_file_tensor, + Extra_Data=NewData, + Extra_Data_leg = args.ExtraNeurons, + extensions="npy", + transform=traintransform + ) + + valDataset = Loaders.RARP_DatasetFolder_ExtraData( + str (rootFile/"val"), + loader=defs.load_file_tensor, + Extra_Data=NewData, + Extra_Data_leg = args.ExtraNeurons, + extensions="npy", + transform=valtransform + ) + + testDataset = Loaders.RARP_DatasetFolder_ExtraData( + str (rootFile/"test"), + loader=defs.load_file_tensor, + Extra_Data=NewData, + Extra_Data_leg = args.ExtraNeurons, + extensions="npy", + transform=testtransform + ) + + Train_DataLoader = DataLoader( + trainDataset, + batch_size=batchSize, + num_workers=numWorkers, + shuffle=True, + drop_last=True, + pin_memory=True, + persistent_workers=numWorkers>0 + ) + Val_DataLoader = DataLoader( + valDataset, + batch_size=batchSize, + num_workers=numWorkers, + shuffle=False, + pin_memory=True, + persistent_workers=numWorkers>0 + ) + Test_DataLoader = DataLoader( + testDataset, + batch_size=batchSize, + num_workers=numWorkers, + shuffle=False, + pin_memory=True, + persistent_workers=numWorkers>0 + ) + + if args.CAM: + testCAMDataset = torchvision.datasets.DatasetFolder( + str (rootFile/"test"), + loader=defs.load_file_tensor, + extensions="npy", + transform=torch.nn.Sequential( + transforms.Resize((224, 224), antialias=True), + transforms.Normalize(Dataset.mean, Dataset.std) + ).to(device) + ) + + TestCAM_DataLoader = DataLoader( + testCAMDataset, + batch_size=batchSize, + num_workers=numWorkers, + shuffle=False, + pin_memory=True + ) + + print(f"Currtent Fold Splits {Dataset.Splits[args.Fold]}") + print(f"Unique Values in sets") + info = np.unique(trainDataset.targets, return_counts=True), np.unique(valDataset.targets, return_counts=True), np.unique(testDataset.targets, return_counts=True) + print(info) + + neg = 0 + pos = 0 + for i in info: + neg += i[1][0] + pos += i[1][1] + + total = neg + pos + factor = 2 if args.TypeLoss == 1 else 1 + InitWeight = torch.tensor([total/(neg * factor), total/(pos * factor)]).to(device) if args.Wloss else None + if InitWeight is not None: + print(f"Weights {InitWeight}") + TypeLoss = M.TypeLossFunction(args.TypeLoss) + Model, ModelCAM = getModel( + args.Model, + InitWeight, + TypeLoss, + mean=Dataset.mean, + std=Dataset.std + ) + NameModel = type(Model).__name__ + print(f"Model Used: {NameModel}") + LogFileName = f"{args.Log_Name}" + + MaxEpochs = 150 + if args.Model == 4: + MaxEpochs = 150 + + if args.maxEpochs is not None: + MaxEpochs = args.maxEpochs + + #warnings.simplefilter("ignore") + + match(args.Phase): + case "train": + trainer = L.Trainer( + deterministic=True, + #gradient_clip_val=2.0, + accelerator='gpu', + devices=1, + logger=CSVLogger(save_dir=f"./{LogFileName}", name="Tune") if args.Phase == "tune" else TensorBoardLogger(save_dir=f"./{LogFileName}"), + log_every_n_steps=5, + #callbacks=[checkPtCallback, StepDropout(5, base_drop_rate=0.2, gamma=0.05, ascending=True)],#if args.Model == 4 else checkPtCallback, + callbacks=[checkPtCallback, callbk.EarlyStopping(monitor="val_loss", mode="min", patience=5)], #ckpLossBest, ], + max_epochs=MaxEpochs, + ) + print("Train Phase") + trainer.fit(Model, train_dataloaders=Train_DataLoader, val_dataloaders=Val_DataLoader, ckpt_path=args.LoadChkpt) + trainer.test(Model, dataloaders=Test_DataLoader, ckpt_path="best") + case "tune": + print("Tuning") + + pruner = optuna.pruners.SuccessiveHalvingPruner()#MedianPruner() + sampler = optuna.samplers.GPSampler(seed=2023) if args.Log_step == 1 else optuna.samplers.TPESampler(seed=2023) + study = optuna.create_study(direction="maximize", pruner=pruner, sampler=sampler) + study.optimize(objective, n_trials=100) + + print("Number of finished trials: {}".format(len(study.trials))) + print("Best trial:") + trial = study.best_trial + print(f" Value: {trial.value}") + print(f" Paramas: ") + for key, val in trial.params.items(): + print(f" {key}: {val}") + case "eval_all": + print("Evaluation Phase") + rows = [] + pathCkptFile = Path(f"./{LogFileName}/lightning_logs/version_{args.Log_version}/checkpoints/") + for ckpFile in pathCkptFile.glob("*.ckpt"): + print(ckpFile.name) + Model, ModelCAM = getModel(args.Model, InitWeight, TypeLoss, ckpFile) + + #ViewImgDINO(trainDataset, Dataset.std, Dataset.mean) + + if isinstance(Model, M.RARP_NVB_MultiClassModel): + temp = Calc_EvalMulticlass_table(Model, Test_DataLoader, False, ckpFile.name) + else: + temp = Calc_Eval_table( + Model, + Test_DataLoader, + args.JIndex, + ckpFile.name, + Add_TestDataset=Add_Test_DataLoader, + extraData=(args.Metadata is not None), + PseudoLabel=False, + dataSetInfo=Dataset + ) + rows += temp + if args.CAM and ModelCAM is not None: + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + print("CAM") + ShowCAM(ModelCAM, testCAMDataset, Dataset.mean, Dataset.std, ckpFile.name) + + df = pd.DataFrame(rows, columns=["Youden", "Acc","Precision","Recall","F1","AUROC","Specificity","CheckPoint"]) + df.style.highlight_max(color="red", axis=0) + print(df) + plt.show() + case _: + print("Evaluation Phase") + trainLog = [args.Log_version, args.Log_epoch, args.Log_step] + pathCkptFile = Path(f"./{LogFileName}/lightning_logs/version_{trainLog[0]}/checkpoints/epoch={trainLog[1]}-step={trainLog[2]}.ckpt") + Calc_Eval(Model.load_from_checkpoint(pathCkptFile)) + if args.CAM: + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + ShowCAM(ModelCAM.load_from_checkpoint(pathCkptFile, strict=False), testCAMDataset, Dataset.mean, Dataset.std, pathCkptFile.name) + plt.show() \ No newline at end of file diff --git a/RARP_NVB2.py b/RARP_NVB2.py new file mode 100644 index 0000000..802de07 --- /dev/null +++ b/RARP_NVB2.py @@ -0,0 +1,515 @@ +import torch +from torch.utils.data import DataLoader +import torchvision +from torchvision import transforms +import torchmetrics +import lightning as L +from lightning.pytorch.callbacks import ModelCheckpoint +from lightning.pytorch.loggers import TensorBoardLogger +from tqdm.notebook import tqdm +import numpy as np +import matplotlib.pyplot as plt +from pathlib import Path +from CustomCallback import StepDropout +import Loaders +import defs +import argparse +import seaborn as sn +import Models as M +import pandas as pd +import warnings +from ultralytics import YOLO + +torch.set_float32_matmul_precision('high') +torch.backends.cudnn.deterministic = True + +def Calc_Eval_table_New(TrainModel:M.RARP_NVB_Model): + TrainModel.to(device) + TrainModel.eval() + + Predictions = [] + Labels = [] + + if isinstance(TrainModel, M.RARP_NVB_Model_test2): + with torch.no_grad(): + for img, label in tqdm(iter(Test_DataLoader)): + img = img.float().to(device) + label = label.to(device) + + pred = TrainModel(img) + Predictions.append(torch.softmax(pred, dim=1)) + Labels.append(label) + + Predictions = torch.cat(Predictions) + Labels = torch.cat(Labels) + + print(Predictions, Labels) + + acc = torchmetrics.Accuracy("multiclass", num_classes=2).to(device)(Predictions, Labels) + precision = torchmetrics.Precision("multiclass", num_classes=2).to(device)(Predictions, Labels) + recall = torchmetrics.Recall("multiclass", num_classes=2).to(device)(Predictions, Labels) + auc = torchmetrics.AUROC("multiclass", num_classes=2).to(device)(Predictions, Labels) + f1Score = torchmetrics.F1Score("multiclass", num_classes=2).to(device)(Predictions, Labels) + + return [acc.item(), precision.item(), recall.item(), f1Score.item(), auc.item()] + + with torch.no_grad(): + for img, label in tqdm(iter(Test_DataLoader)): + img = img.float().to(device) + label = label.float().to(device) + + pred = TrainModel(img) + Predictions.append(torch.sigmoid(pred.squeeze(1))) + Labels.append(label) + + Predictions = torch.cat(Predictions) + Labels = torch.cat(Labels) + + print(Predictions, Labels) + + acc = torchmetrics.Accuracy('binary').to(device)(Predictions, Labels) + precision = torchmetrics.Precision('binary').to(device)(Predictions, Labels) + recall = torchmetrics.Recall('binary').to(device)(Predictions, Labels) + #cm = torchmetrics.ConfusionMatrix('binary')(Predictions, Labels) + auc = torchmetrics.AUROC('binary').to(device)(Predictions, Labels) + f1Score = torchmetrics.F1Score('binary').to(device)(Predictions, Labels) + + return [acc.item(), precision.item(), recall.item(), f1Score.item(), auc.item()] + +def Calc_Eval_table(TrainModel:M.RARP_NVB_Model): + TrainModel.to(device) + TrainModel.eval() + + Predictions = [] + Labels = [] + + with torch.no_grad(): + for data, label in tqdm(iter(Test_DataLoader)): + data = data.float().to(device) + label = label.to(device) + pred = TrainModel(data).flatten() + Predictions.append(torch.sigmoid(pred)) + Labels.append(label) + + + Predictions = torch.cat(Predictions) + Labels = torch.cat(Labels) + + print(Predictions, Labels) + + acc = torchmetrics.Accuracy('binary').to(device)(Predictions, Labels) + precision = torchmetrics.Precision('binary').to(device)(Predictions, Labels) + recall = torchmetrics.Recall('binary').to(device)(Predictions, Labels) + auc = torchmetrics.AUROC('binary').to(device)(Predictions, Labels) + f1Score = torchmetrics.F1Score('binary').to(device)(Predictions, Labels) + + return [f"{acc.item():.4f}", f"{precision.item():.4f}", f"{recall.item():.4f}", f"{f1Score.item():.4f}", f"{auc.item():.4f}"] + +def setup_seed(seed): + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + np.random.seed(seed) + torch.backends.cudnn.deterministic = True + +def CAM(model:M.RARP_NVB_Model, img:torch.Tensor, device): + with torch.no_grad(): + img = img.to(device).float().unsqueeze(0) + pred, feature = model(img) + + _, c, h, w = feature.shape + feature = feature.reshape((c, h*w)) + if isinstance(model, (M.RARP_NVB_ResNet18_CAM, M.RARP_NVB_ResNet50_CAM)): + wParams = list(model.model.fc.parameters()) + elif isinstance(model, M.RARP_NVB_MobileNetV2_CAM): + wParams = list(model.model.classifier.parameters()) + pesos = wParams[0].detach() + cam = torch.matmul(pesos, feature) + + cam = cam - torch.min(cam) + cam_img = cam / torch.max(cam) + cam_img = cam_img.reshape(h, w).cpu() + + return cam_img, torch.sigmoid(pred) + +def CAMVisualizer(img, heatmap, pred, label, mean, std, ax, row): + img = img.numpy().transpose((1, 2, 0)) + heatmap = transforms.functional.resize(heatmap.unsqueeze(0), (img.shape[0], img.shape[1]), antialias=True)[0] + + img = np.clip((std * img + mean) / 255, 0, 1) + img = img[...,::-1].copy() + col = 0 + if row > 3: + col = 2 + + if row > 7: + col = 4 + + ax[row % 4][col + 0].imshow(img) + ax[row % 4][col + 0].axis('off') + + ax[row % 4][col + 1].imshow(img) + ax[row % 4][col + 1].imshow(heatmap, alpha=0.5, cmap="jet") + ax[row % 4][col + 1].axis('off') + ax[row % 4][col + 1].set_title(f"Pred.: {pred.item():.4f}; Label: {label}") + + #plt.title() + +def ShowCAM(TrainedModel:M.RARP_NVB_Model, mean, std, title=""): + TrainedModel.to(device) + TrainedModel.eval() + i = 0 + params = { + "left":0, + "bottom":0.01, + "right":1, + "top":0.914, + "wspace":0, + "hspace":0.164 + } + fig, axis = plt.subplots(4, 6, gridspec_kw=params) + with torch.no_grad(): + if len(testDataset) > 12: + ix = np.unique(testDataset.targets, return_counts=True)[1] + NOTNVB_Indexs = np.asarray(range(ix[0])) + NVB_Indexs = np.asarray(range(ix[0], ix[0] + ix[1])) + np.random.shuffle(NOTNVB_Indexs) + np.random.shuffle(NVB_Indexs) + + for j, index in enumerate(NOTNVB_Indexs): + if j == 6: + break + img, label = testDataset[index] + cam, pred = CAM(TrainedModel, img, device) + CAMVisualizer(img, cam, pred, label, mean, std, axis, i) + i += 1 + + for j, index in enumerate(NVB_Indexs): + if j == 5: + break + img, label = testDataset[index] + cam, pred = CAM(TrainedModel, img, device) + CAMVisualizer(img, cam, pred, label, mean, std, axis, i) + i += 1 + else: + for img, label in tqdm(testDataset): + cam, pred = CAM(TrainedModel, img, device) + CAMVisualizer(img, cam, pred, label, mean, std, axis, i) + i += 1 + + fig.suptitle(title) + +def Calc_Eval(TrainModel:M.RARP_NVB_Model): + TrainModel.to(device) + TrainModel.eval() + + Predictions = [] + Labels = [] + + with torch.no_grad(): + for data, label in tqdm(testDataset): + data = data.to(device).float().unsqueeze(0) + pred = torch.sigmoid(TrainModel(data)[0].cpu()) + Predictions.append(pred) + Labels.append(label) + + Predictions = torch.cat(Predictions) + Labels = torch.tensor(Labels).int() + + print(Predictions, Labels) + + acc = torchmetrics.Accuracy('binary')(Predictions, Labels) + precision = torchmetrics.Precision('binary')(Predictions, Labels) + recall = torchmetrics.Recall('binary')(Predictions, Labels) + cm = torchmetrics.ConfusionMatrix('binary')(Predictions, Labels) + auc = torchmetrics.AUROC('binary')(Predictions, Labels) + f1Score = torchmetrics.F1Score('binary')(Predictions, Labels) + + print(f"Val Accuracy: {acc:.4f}") + print(f"Val Precision: {precision:.4f}") + print(f"Val Recall: {recall:.4f}") + print(f"F1 Score: {f1Score:.4f}") + print(f"AUROC: {auc:.4f}") + print(testDataset.classes) + + ax = sn.heatmap(cm, cmap="Greens", cbar=False, annot=True, annot_kws={"size": 18}, fmt='g', xticklabels=testDataset.classes, yticklabels=testDataset.classes) + ax.set_title(f"NVB Classifier Split #{args.Fold+1}") + ax.set_xlabel('Predict') + ax.set_ylabel('True') + plt.show() + + +if __name__ == "__main__": + + parser = argparse.ArgumentParser() + parser.add_argument("--Phase", default="train", type=str, help="'train' or 'eval'") + parser.add_argument("--Fold", type=int, default=0) + parser.add_argument("--Workers", type=int, default=0) + parser.add_argument("--Log_Name", type=str, default="logs_debug", help="the name of the directory of the log chkp") + parser.add_argument("--Model", type=int, default=0, help="0 = ResNet18, 1 = ResNet50") + parser.add_argument("-lv", "--Log_version", type=int) + parser.add_argument("-le", "--Log_epoch", type=int) + parser.add_argument("-ls", "--Log_step", type=int) + parser.add_argument("--Remove_Blackbar", type=bool, default=True) + parser.add_argument("--BGR2RGB", type=bool, default=False) + parser.add_argument("--CAM", type=bool, default=False) + parser.add_argument("-roi", "--Use_ROI_Dataset", type=int, default=0) + parser.add_argument("-s", "--imgSlice_pct", type=float, default=None) + parser.add_argument("-ns", "--Num_Slices", type=int, default=4) + parser.add_argument("-wl", "--Wloss",type=bool, default=False) + parser.add_argument("--sClass",type=int, default=None) + parser.add_argument("-tl", "--TypeLoss", type=int, default=0) + parser.add_argument("-cs", "--ColorSpace", type=int, default=None) + + args = parser.parse_args() + + if args.CAM and args.Phase == "train": + raise Exception("Clases Activation Clases only in eval o eval_all") + + match args.Use_ROI_Dataset: + case 1: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_Crop", + FoldSeed=505, + createFile=True, + SavePath="./DataSetCrop", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 256 + case 0: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_main", + FoldSeed=505, + createFile=True, + SavePath="./DataSet", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 720 + case 3: + YoloModel = YOLO(model="RARP_YoloV8_ROI.pt") + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_main", + FoldSeed=505, + createFile=True, + SavePath="./DataSet_YOLO", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace, + ROI_Yolo=YoloModel + ) + cropSize = 256 + case 2: + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_Crop1", + FoldSeed=505, + createFile=True, + SavePath="./DataSetCrop1", + Fold=5, + removeBlackBar=args.Remove_Blackbar, + RGBGama=args.BGR2RGB, + SegImage=args.imgSlice_pct, + Num_Img_Slices=args.Num_Slices, + SegmentClass=args.sClass, + colorSpace=args.ColorSpace + ) + cropSize = 256 + + Dataset.CreateFolds() + + setup_seed(2023) + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + batchSize = 17 #17 #8, 32 + numWorkers = args.Workers + checkPtCallback = ModelCheckpoint(monitor='val_acc', save_top_k=10, mode='max') + + traintransform = torch.nn.Sequential( + transforms.Normalize(Dataset.mean, Dataset.std), + transforms.Resize(cropSize, antialias=True), + transforms.RandomHorizontalFlip(0.6), + transforms.RandomAffine( + degrees=(-5, 5), translate=(0, 0.05), scale=(0.9, 1.1), + fill=5 + ), + transforms.RandomResizedCrop((224, 224), scale=(0.35, 1), antialias=True), + ).to(device) + + valtransform = torch.nn.Sequential( + transforms.Resize(256, antialias=True), + transforms.CenterCrop(224), + transforms.Normalize(Dataset.mean, Dataset.std) + ).to(device) + + testtransform = torch.nn.Sequential( + transforms.Resize(256, antialias=True), + transforms.CenterCrop(224), + transforms.Normalize(Dataset.mean, Dataset.std) + ).to(device) + + rootFile = Dataset.CVS_File.parent.parent/f"fold_{args.Fold}" + + trainDataset = torchvision.datasets.DatasetFolder( + str (rootFile/"train"), + loader=defs.load_file_tensor, + extensions="npy", + transform=traintransform + ) + + valDataset = torchvision.datasets.DatasetFolder( + str (rootFile/"val"), + loader=defs.load_file_tensor, + extensions="npy", + transform=valtransform + ) + + testDataset = torchvision.datasets.DatasetFolder( + str (rootFile/"test"), + loader=defs.load_file_tensor, + extensions="npy", + transform=testtransform + ) + + Train_DataLoader = DataLoader( + trainDataset, + batch_size=batchSize, + num_workers=numWorkers, + shuffle=True, + pin_memory=True + ) + Val_DataLoader = DataLoader( + valDataset, + batch_size=batchSize, + num_workers=numWorkers, + shuffle=False, + pin_memory=True + ) + Test_DataLoader = DataLoader( + testDataset, + batch_size=batchSize, + num_workers=numWorkers, + shuffle=False, + pin_memory=True + ) + + if args.CAM: + testCAMDataset = torchvision.datasets.DatasetFolder( + str (rootFile/"test"), + loader=defs.load_file_tensor, + extensions="npy", + transform=torch.nn.Sequential( + transforms.Resize(256, antialias=True), + transforms.Normalize(Dataset.mean, Dataset.std) + ).to(device) + ) + + TestCAM_DataLoader = DataLoader( + testCAMDataset, + batch_size=batchSize, + num_workers=numWorkers, + shuffle=False, + pin_memory=True + ) + + print(f"Currtent Fold Splits {Dataset.Splits[args.Fold]}") + print(f"Unique Values in sets") + info = np.unique(trainDataset.targets, return_counts=True), np.unique(valDataset.targets, return_counts=True), np.unique(testDataset.targets, return_counts=True) + print(info) + + neg = 0 + pos = 0 + for i in info: + neg += i[1][0] + pos += i[1][1] + + total = neg + pos + + InitWeight = torch.tensor([total/(neg), total/(pos)]).to(device) if args.Wloss else None + TypeLoss = M.TypeLossFunction(args.TypeLoss) + match args.Model: + case 0: + Model = M.RARP_NVB_ResNet50(InitWeight, TypeLoss) + ModelCAM = M.RARP_NVB_ResNet50_CAM() + case 1: + Model = M.RARP_NVB_ResNet18(InitWeight, TypeLoss) + ModelCAM = M.RARP_NVB_ResNet18_CAM() + case 2: + Model = M.RARP_NVB_MobileNetV2(InitWeight, TypeLoss) + ModelCAM = M.RARP_NVB_MobileNetV2_CAM() + case 3: + Model = M.RARP_NVB_EfficientNetV2(InitWeight, TypeLoss) + ModelCAM = M.RARP_NVB_EfficientNetV2_CAM() + case 4: + models = [ + M.RARP_NVB_ResNet50.load_from_checkpoint(Path("./log_ResNet50_X6/lightning_logs/version_14/checkpoints/epoch=23-step=96.ckpt"), strict=False), + M.RARP_NVB_ResNet18.load_from_checkpoint(Path("./log_restnet18_X6/lightning_logs/version_14/checkpoints/epoch=22-step=92.ckpt"), strict=False), + M.RARP_NVB_ResNet50.load_from_checkpoint(Path("./log_ResNet50_X6/lightning_logs/version_9/checkpoints/epoch=44-step=180.ckpt"), strict=False), + M.RARP_NVB_ResNet18.load_from_checkpoint(Path("./log_restnet18_X6/lightning_logs/version_9/checkpoints/epoch=25-step=104.ckpt"), strict=False), + ] + Model = M.RARP_Ensemble(models, InitWeight, TypeLoss) + case _: + raise Exception("Model Not yet Implemented") + + NameModel = type(Model).__name__ + print(f"Model Used: {NameModel}") + LogFileName = f"{args.Log_Name}" #-{NameModel} + + warnings.simplefilter("ignore") + trainer = L.Trainer( + accelerator='gpu', + devices=1, + logger=TensorBoardLogger(save_dir=f"./{LogFileName}"), + log_every_n_steps=1, + #callbacks=checkPtCallback, + callbacks=[checkPtCallback, StepDropout(5, base_drop_rate=0.2, gamma=0.05)], + max_epochs=50, + ) + + if args.Phase == "train": + print("Train Phase") + trainer.fit(Model, train_dataloaders=Train_DataLoader, val_dataloaders=Val_DataLoader) + #trainer.callbacks + trainer.test(Model, dataloaders=Test_DataLoader, ckpt_path="best") + elif args.Phase == "eval_all": + print("Evaluation Phase") + rows = [] + pathCkptFile = Path(f"./{LogFileName}/lightning_logs/version_{args.Log_version}/checkpoints/") + for ckpFile in pathCkptFile.glob("*.ckpt"): + print(ckpFile.name) + temp = Calc_Eval_table(Model.load_from_checkpoint(ckpFile, strict=False)) + #temp = Calc_Eval_table_New(Model.load_from_checkpoint(ckpFile, strict=False)) + temp.append(ckpFile.name) + rows.append(temp) + if args.CAM: + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + print("CAM") + ShowCAM(ModelCAM.load_from_checkpoint(ckpFile, strict=False), Dataset.mean, Dataset.std, ckpFile.name) + + df = pd.DataFrame(rows, columns=["Acc","Precision","Recall","F1","AUROC","CheckPoint"]) + df.style.highlight_max(color="red", axis=0) + print(df) + plt.show() + else: + print("Evaluation Phase") + trainLog = [args.Log_version, args.Log_epoch, args.Log_step] + pathCkptFile = Path(f"./{LogFileName}/lightning_logs/version_{trainLog[0]}/checkpoints/epoch={trainLog[1]}-step={trainLog[2]}.ckpt") + Calc_Eval(Model.load_from_checkpoint(pathCkptFile)) + if args.CAM: + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + ShowCAM(ModelCAM.load_from_checkpoint(pathCkptFile, strict=False), Dataset.mean, Dataset.std, pathCkptFile.name) + plt.show() \ No newline at end of file diff --git a/RARP_NVB_eval.py b/RARP_NVB_eval.py new file mode 100644 index 0000000..7c9a3db --- /dev/null +++ b/RARP_NVB_eval.py @@ -0,0 +1,284 @@ +import torch +import torchvision +from torchvision import transforms +from torch.utils.data import DataLoader +import torchmetrics +import torchmetrics.classification +import numpy as np +import yaml +import Models as M +from pathlib import Path +import Loaders +import defs +import matplotlib.pyplot as plt +import seaborn as sn +from ultralytics import YOLO +import argparse + +def setup_seed(seed): + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + np.random.seed(seed) + torch.backends.cudnn.deterministic = True + +def CalcAgreement(x:torch): + deltas = torch.sum(torch.abs(x.unsqueeze(1) - x), 1) + deltasMean = deltas.mean() + + factor = (deltas <= deltasMean).float() + factor = factor / factor.count_nonzero() + + return torch.dot(factor, x) + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("-f", "--Fold", type=int, default=0) + parser.add_argument("-m", "--Mode", type=int, default=0) + + args = parser.parse_args() + + Models = [] + + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + print (f"Fold {args.Fold}") + with open(f"eval-EFold{args.Fold}.yaml") as file: + + configFile = yaml.load(file, Loader=yaml.FullLoader) + + for models in configFile["models"]: + match models: + case "ResNet50_ckpt": + if configFile["models"][models] is not None: + for i, pathckpt in enumerate(configFile["models"][models]): + if configFile["Fold_Ensamble"] or configFile['Fold_Num'] is None or configFile['Fold_Num'] == i: + Models.append(M.RARP_NVB_ResNet50.load_from_checkpoint(Path(pathckpt), strict=False).to(device).eval()) + case "ResNet18_ckpt": + if configFile["models"][models] is not None: + for i, pathckpt in enumerate(configFile["models"][models]): + if configFile["Fold_Ensamble"] or configFile['Fold_Num'] is None or configFile['Fold_Num'] == i: + Models.append(M.RARP_NVB_ResNet18.load_from_checkpoint(Path(pathckpt), strict=False).to(device).eval()) + case "MovilNetV2_ckpt": + if configFile["models"][models] is not None: + for i, pathckpt in enumerate(configFile["models"][models]): + if configFile["Fold_Ensamble"] or configFile['Fold_Num'] is None or configFile['Fold_Num'] == i: + Models.append(M.RARP_NVB_MobileNetV2.load_from_checkpoint(Path(pathckpt), strict=False).to(device).eval()) + case "EfficientNetV2_ckpt": + if configFile["models"][models] is not None: + for i, pathckpt in enumerate(configFile["models"][models]): + if configFile["Fold_Ensamble"] or configFile['Fold_Num'] is None or configFile['Fold_Num'] == i: + Models.append(M.RARP_NVB_EfficientNetV2.load_from_checkpoint(Path(pathckpt), strict=False).to(device).eval()) + case _: + raise Exception("Model Not yet Implemented") + + match configFile["dataset_type"]: + case "full_size": + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_main", + FoldSeed=505, + createFile=True, + Fold=5, + SavePath="./DataSet_Eval", + removeBlackBar=True + ) + case "Manual_ROI": + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_Crop1", + FoldSeed=505, + createFile=True, + Fold=5, + SavePath="./DataSet_Crop1_Eval", + removeBlackBar=False + ) + case "Manual_ROIwD": + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_Crop", + FoldSeed=505, + createFile=True, + Fold=5, + SavePath="./DataSet_Crop_Eval", + removeBlackBar=False + ) + case "YOLO_ROI": + YoloModel = YOLO(model="RARP_YoloV8_ROI.pt") + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_main", + FoldSeed=505, + createFile=True, + Fold=5, + SavePath="./DataSet_YOLO_Eval", + removeBlackBar=True, + SegmentClass=1, + SegImage=0.75, + Num_Img_Slices=2 + ) + case "YOLO_ROI_BIGDataset": + YoloModel = YOLO(model="RARP_YoloV8_ROI.pt") + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_big", + FoldSeed=505, + createFile=True, + Fold=5, + SavePath="./DataSet_YOLO_Eval_BD", + removeBlackBar=True, + SegmentClass=0, + SegImage=0.75, + Num_Img_Slices=1 + ) + case "small_balaced": + YoloModel = YOLO(model="RARP_YoloV8_ROI.pt") + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_smallBalaced", + FoldSeed=505, + createFile=True, + Fold=5, + SavePath="./DataSet_YOLO_SB_Eval", + removeBlackBar=True + ) + case "small_Ando": + YoloModel = YOLO(model="RARP_YoloV8_ROI.pt") + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_Ando", + FoldSeed=505, + createFile=True, + Fold=5, + SavePath="./DataSet_YOLO_Ando_Eval", + removeBlackBar=True + ) + case "small_balaced_full_size": + Dataset = Loaders.RARP_DatasetCreator( + "./DataSet_smallBalaced", + FoldSeed=505, + createFile=True, + Fold=5, + SavePath="./DataSet_YOLO_SBFS_Eval", + removeBlackBar=True + ) + + print("Evaluation Phase") + if configFile['Fold_Num'] is not None: + Dataset.CreateFolds() + rootFile = Dataset.CVS_File.parent.parent/f"fold_{configFile['Fold_Num']}" + if (configFile["dataset_type"] in ["YOLO_ROI", "small_balaced", "YOLO_ROI_BIGDataset", "small_Ando"]): + Dataset.ExtractROI_YOLO(YoloModel, configFile["YOLO_Accuracy_min_ROI"]) + else: + Dataset.CreateClases() + rootFile = Dataset.CVS_File.parent.parent/"dataset" + + Dataset.mean, Dataset.std = ([30.38144216, 42.03988769, 97.8896116], [40.63141752, 44.26910074, 50.29294373]) + + setup_seed(2023) + + + + valtransform = torch.nn.Sequential( + transforms.Resize((224, 224), antialias=True), + #transforms.Resize(256, antialias=True), + #transforms.CenterCrop(224), + #transforms.RandomHorizontalFlip(0.7), + transforms.Normalize(Dataset.mean, Dataset.std) + ).to(device) + + valDataset = torchvision.datasets.DatasetFolder( + str (rootFile/("test" if configFile['Fold_Num'] is not None else "")), + loader=defs.load_file_tensor, + extensions="npy", + transform=valtransform + ) + + Val_DataLoader = DataLoader( + valDataset, + batch_size=16, + num_workers=0, + shuffle=True, + pin_memory=True + ) + + + Predictions = [] + Labels = [] + res = [] + + with torch.no_grad(): + for data, label in iter(Val_DataLoader): + data = data.float().to(device) + label = label.to(device) + prob = [torch.sigmoid(m(data)) for m in Models] + prob = torch.cat(prob, dim=1) + print (prob, label) + prob = torch.tensor([CalcAgreement(d.squeeze()) for d in prob.split(1, 0)]).to(device) if args.Mode == 1 else prob.mean(dim=1) + #prob = + Predictions.append(prob) + Labels.append(label) + + Predictions = torch.cat(Predictions) + Labels = torch.cat(Labels) + + print(Predictions, Labels) + + acc = torchmetrics.Accuracy('binary').to(device)(Predictions, Labels) + precision = torchmetrics.Precision('binary').to(device)(Predictions, Labels) + recall = torchmetrics.Recall('binary').to(device)(Predictions, Labels) + specificty = torchmetrics.Specificity("binary").to(device)(Predictions, Labels) + auc = torchmetrics.AUROC('binary').to(device)(Predictions, Labels) + f1Score = torchmetrics.F1Score('binary').to(device)(Predictions, Labels) + cm = torchmetrics.ConfusionMatrix('binary').to(device) + cm.update(Predictions, Labels) + _, ax = cm.plot() + ax.set_title(f"NVB Classifier (th=0.5)") + ax.set_xticklabels(valDataset.classes) + ax.set_yticklabels(valDataset.classes) + ax.set_xlabel('Ground Truth') + + + + print(f"Val Accuracy: {acc:.4f}") + print(f"Val Precision: {precision:.4f}") + print(f"Val Recall: {recall:.4f}") + print(f"F1 Score: {f1Score:.4f}") + print(f"AUROC: {auc:.4f}") + print(f"Val Specificity: {specificty:.4f}") + print(valDataset.classes) + + #ax = sn.heatmap(cm.cpu(), cmap="Greens", cbar=False, annot=True, annot_kws={"size": 18}, fmt='g', xticklabels=valDataset.classes, yticklabels=valDataset.classes) + #ax.set_title(f"NVB Classifier") + #ax.set_xlabel('Predict') + #ax.set_ylabel('True') + + aucCurve = torchmetrics.ROC("binary").to(device) + fpr, tpr, thhols = aucCurve(Predictions, Labels) + index = torch.argmax(tpr - fpr) + print(f"False-Positive Rate: {fpr}") + print(f"True-Positive Rate: {tpr}") + print(tpr-fpr) + print(index) + print(thhols) + th1 = thhols[index].item() if configFile['Youden-Index'] == "ROC" else (recall + specificty - 1).item() + _, ax = aucCurve.plot() + ax.plot([0,1], linestyle='--') + #ax.plot(torch.max(tpr - fpr).cpu(), torch.max(tpr - fpr).cpu(), "bo", markersize=5) + #ax.plot(th1, th1, "ro", markersize=5) + ax.set_title(f"ROC (AUROC={auc:.4f})") + + print(f"Metris ajusted new threshold {th1:.4f}") + acc = torchmetrics.Accuracy('binary', threshold=th1).to(device)(Predictions, Labels) + precision = torchmetrics.Precision('binary', threshold=th1).to(device)(Predictions, Labels) + recall = torchmetrics.Recall('binary', threshold=th1).to(device)(Predictions, Labels) + specificty = torchmetrics.Specificity("binary", threshold=th1).to(device)(Predictions, Labels) + f1Score = torchmetrics.F1Score('binary', threshold=th1).to(device)(Predictions, Labels) + cm2 = torchmetrics.ConfusionMatrix('binary', threshold=th1).to(device) + cm2.update(Predictions, Labels) + _, ax = cm2.plot() + ax.set_title(f"NVB Classifier (th={th1:.4f})") + ax.set_xticklabels(valDataset.classes) + ax.set_yticklabels(valDataset.classes) + ax.set_xlabel('Ground Truth') + + print(f"Val Accuracy: {acc:.4f}") + print(f"Val Precision: {precision:.4f}") + print(f"Val Recall: {recall:.4f}") + print(f"F1 Score: {f1Score:.4f}") + print(f"AUROC: {auc:.4f}") + print(f"Val Specificity: {specificty:.4f}") + + + plt.show() \ No newline at end of file diff --git a/RARP_YoloV8_ROI.pt b/RARP_YoloV8_ROI.pt new file mode 100644 index 0000000..7688540 --- /dev/null +++ b/RARP_YoloV8_ROI.pt Binary files differ diff --git a/TrainKFolds_RARP.bat b/TrainKFolds_RARP.bat new file mode 100644 index 0000000..ac14db3 --- /dev/null +++ b/TrainKFolds_RARP.bat @@ -0,0 +1,83 @@ +@echo "Start Train K-Folds ROI-No-distractors" + +@echo "Train ResNet50" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 0 --Model 0 --Log_Name "log_ResNet50_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 0 --Model 0 --Log_Name "log_ResNet50_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 0 --Model 0 --Log_Name "log_ResNet50_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 0 --Model 0 --Log_Name "log_ResNet50_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 0 --Model 0 --Log_Name "log_ResNet50_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +@echo "Train ResNet18" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 0 --Model 1 --Log_Name "log_restnet18_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 0 --Model 1 --Log_Name "log_restnet18_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 0 --Model 1 --Log_Name "log_restnet18_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 0 --Model 1 --Log_Name "log_restnet18_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 0 --Model 1 --Log_Name "log_restnet18_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +@echo "Train MobileNetV2" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 0 --Model 2 --Log_Name "log_MobileNetV2_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 0 --Model 2 --Log_Name "log_MobileNetV2_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 0 --Model 2 --Log_Name "log_MobileNetV2_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 0 --Model 2 --Log_Name "log_MobileNetV2_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 0 --Model 2 --Log_Name "log_MobileNetV2_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +@echo "Train EfficientNetV2" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 0 --Model 3 --Log_Name "log_EfficientNetV2_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 0 --Model 3 --Log_Name "log_EfficientNetV2_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 0 --Model 3 --Log_Name "log_EfficientNetV2_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 0 --Model 3 --Log_Name "log_EfficientNetV2_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 0 --Model 3 --Log_Name "log_EfficientNetV2_X7" -roi 1 -s 0.75 -ns 2 --sClass 1 -tl 1 +@echo "Finish Training" + +@echo "Start Train K-Folds ROI-Fix" + +@echo "Train ResNet50" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 0 --Model 0 --Log_Name "log_ResNet50_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 0 --Model 0 --Log_Name "log_ResNet50_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 0 --Model 0 --Log_Name "log_ResNet50_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 0 --Model 0 --Log_Name "log_ResNet50_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 0 --Model 0 --Log_Name "log_ResNet50_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +@echo "Train ResNet18" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 0 --Model 1 --Log_Name "log_restnet18_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 0 --Model 1 --Log_Name "log_restnet18_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 0 --Model 1 --Log_Name "log_restnet18_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 0 --Model 1 --Log_Name "log_restnet18_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 0 --Model 1 --Log_Name "log_restnet18_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +@echo "Train MobileNetV2" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 0 --Model 2 --Log_Name "log_MobileNetV2_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 0 --Model 2 --Log_Name "log_MobileNetV2_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 0 --Model 2 --Log_Name "log_MobileNetV2_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 0 --Model 2 --Log_Name "log_MobileNetV2_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 0 --Model 2 --Log_Name "log_MobileNetV2_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +@echo "Train EfficientNetV2" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 0 --Model 3 --Log_Name "log_EfficientNetV2_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 0 --Model 3 --Log_Name "log_EfficientNetV2_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 0 --Model 3 --Log_Name "log_EfficientNetV2_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 0 --Model 3 --Log_Name "log_EfficientNetV2_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 0 --Model 3 --Log_Name "log_EfficientNetV2_X7" -roi 2 -s 0.75 -ns 2 --sClass 1 -tl 1 +@echo "Finish Training" + +@echo "Start Train K-Folds Full-size" + +@echo "Train ResNet50" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +@echo "Train ResNet18" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +@echo "Train MobileNetV2" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +@echo "Train EfficientNetV2" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X7" -s 0.75 -ns 2 --sClass 1 -tl 1 +@echo "Finish Training" diff --git a/TrainKFolds_RARP2.bat b/TrainKFolds_RARP2.bat new file mode 100644 index 0000000..2f60996 --- /dev/null +++ b/TrainKFolds_RARP2.bat @@ -0,0 +1,182 @@ +@echo "Start Train K-Folds Full-size" + +goto phace2 + +@echo "Train ResNet50_V1" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 6 --Log_Name "log_ResNet50_X8_mas8_V1" -roi 7 -tl 1 --Metadata "./DataSet_smallBalaced/data.xlsx" --ExtraNeurons 8 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 6 --Log_Name "log_ResNet50_X8_mas8_V1" -roi 7 -tl 1 --Metadata "./DataSet_smallBalaced/data.xlsx" --ExtraNeurons 8 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 6 --Log_Name "log_ResNet50_X8_mas8_V1" -roi 7 -tl 1 --Metadata "./DataSet_smallBalaced/data.xlsx" --ExtraNeurons 8 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 6 --Log_Name "log_ResNet50_X8_mas8_V1" -roi 7 -tl 1 --Metadata "./DataSet_smallBalaced/data.xlsx" --ExtraNeurons 8 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 6 --Log_Name "log_ResNet50_X8_mas8_V1" -roi 7 -tl 1 --Metadata "./DataSet_smallBalaced/data.xlsx" --ExtraNeurons 8 + +@echo "Train ResNet50_V2" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 11 --Log_Name "log_ResNet50_X8_mas8_V2" -roi 7 -tl 1 --Metadata "./DataSet_smallBalaced/data.xlsx" --ExtraNeurons 8 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 11 --Log_Name "log_ResNet50_X8_mas8_V2" -roi 7 -tl 1 --Metadata "./DataSet_smallBalaced/data.xlsx" --ExtraNeurons 8 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 11 --Log_Name "log_ResNet50_X8_mas8_V2" -roi 7 -tl 1 --Metadata "./DataSet_smallBalaced/data.xlsx" --ExtraNeurons 8 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 11 --Log_Name "log_ResNet50_X8_mas8_V2" -roi 7 -tl 1 --Metadata "./DataSet_smallBalaced/data.xlsx" --ExtraNeurons 8 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 11 --Log_Name "log_ResNet50_X8_mas8_V2" -roi 7 -tl 1 --Metadata "./DataSet_smallBalaced/data.xlsx" --ExtraNeurons 8 + +@echo "Train ResNet50_V3" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 12 --Log_Name "log_ResNet50_X8_mas8_V3" -roi 7 -tl 1 --Metadata "./DataSet_smallBalaced/data.xlsx" --ExtraNeurons 8 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 12 --Log_Name "log_ResNet50_X8_mas8_V3" -roi 7 -tl 1 --Metadata "./DataSet_smallBalaced/data.xlsx" --ExtraNeurons 8 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 12 --Log_Name "log_ResNet50_X8_mas8_V3" -roi 7 -tl 1 --Metadata "./DataSet_smallBalaced/data.xlsx" --ExtraNeurons 8 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 12 --Log_Name "log_ResNet50_X8_mas8_V3" -roi 7 -tl 1 --Metadata "./DataSet_smallBalaced/data.xlsx" --ExtraNeurons 8 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 12 --Log_Name "log_ResNet50_X8_mas8_V3" -roi 7 -tl 1 --Metadata "./DataSet_smallBalaced/data.xlsx" --ExtraNeurons 8 +goto fin +@echo "Train ResNet50" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 9 --Log_Name "log_ResNet50_Deep_X8" -roi 7 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 9 --Log_Name "log_ResNet50_Deep_X8" -roi 7 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 9 --Log_Name "log_ResNet50_Deep_X8" -roi 7 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 9 --Log_Name "log_ResNet50_Deep_X8" -roi 7 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 9 --Log_Name "log_ResNet50_Deep_X8" -roi 7 -tl 1 + +@echo "Train EfficientNetV2" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 10 --Log_Name "log_EfficientNetV2_Deep_X9" -roi 9 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 10 --Log_Name "log_EfficientNetV2_Deep_X9" -roi 9 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 10 --Log_Name "log_EfficientNetV2_Deep_X9" -roi 9 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 10 --Log_Name "log_EfficientNetV2_Deep_X9" -roi 9 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 10 --Log_Name "log_EfficientNetV2_Deep_X9" -roi 9 -tl 1 + +@echo "Train ResNet50" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X10_Review" -roi 13 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X10_Review" -roi 13 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X10_Review" -roi 13 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X10_Review" -roi 13 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X10_Review" -roi 13 -tl 1 +goto fin + +@echo "Train ResNet50_Deep" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 9 --Log_Name "log_ResNet50_Deep_X10_R" -roi 14 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 9 --Log_Name "log_ResNet50_Deep_X10_R" -roi 14 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 9 --Log_Name "log_ResNet50_Deep_X10_R" -roi 14 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 9 --Log_Name "log_ResNet50_Deep_X10_R" -roi 14 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 9 --Log_Name "log_ResNet50_Deep_X10_R" -roi 14 -tl 1 + +@echo "Train ResNet18" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X10_1" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X10_1" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X10_1" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X10_1" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X10_1" -roi 12 -tl 1 +@echo "Train MobileNetV2" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X10_1" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X10_1" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X10_1" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X10_1" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X10_1" -roi 12 -tl 1 +@echo "Train EfficientNetV2" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X10_1" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X10_1" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X10_1" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X10_1" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X10_1" -roi 12 -tl 1 + +@echo "Train VAN" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 13 --Log_Name "log_VAN_X10" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 13 --Log_Name "log_VAN_X10" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 13 --Log_Name "log_VAN_X10" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 13 --Log_Name "log_VAN_X10" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 13 --Log_Name "log_VAN_X10" -roi 12 -tl 1 +goto fin +@echo "Train DenseNet169" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_X9" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_X9" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_X9" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_X9" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_X9" -roi 12 -tl 1 + +@echo "Train ResNet50+VAN" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 15 --Log_Name "log_ResNet50+VAN_X10" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 15 --Log_Name "log_ResNet50+VAN_X10" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 15 --Log_Name "log_ResNet50+VAN_X10" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 15 --Log_Name "log_ResNet50+VAN_X10" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 15 --Log_Name "log_ResNet50+VAN_X10" -roi 12 -tl 1 + + +@echo "Train SSL ResNet50Deep (T-S)" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 16 --Log_Name "log_ResNet50DeepSSL_X10" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 16 --Log_Name "log_ResNet50DeepSSL_X10" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 16 --Log_Name "log_ResNet50DeepSSL_X10" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 16 --Log_Name "log_ResNet50DeepSSL_X10" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 16 --Log_Name "log_ResNet50DeepSSL_X10" -roi 12 -tl 1 + +@echo "Train SSL ResNet50Deep DINO ROI" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 17 --Log_Name "log_DINO_X11_label" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 17 --Log_Name "log_DINO_X11_label" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 17 --Log_Name "log_DINO_X11_label" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 17 --Log_Name "log_DINO_X11_label" -roi 12 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 17 --Log_Name "log_DINO_X11_label" -roi 12 -tl 1 + + + + +@echo "Train SSL VAN DINO Full-Size" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 19 --Log_Name "log_X13_van" -roi 17 -tl 1 -me 100 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 19 --Log_Name "log_X13_van" -roi 17 -tl 1 -me 100 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 19 --Log_Name "log_X13_van" -roi 17 -tl 1 -me 100 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 19 --Log_Name "log_X13_van" -roi 17 -tl 1 -me 100 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 19 --Log_Name "log_X13_van" -roi 17 -tl 1 -me 100 --Workers 5 +:phace2 +@echo "Train SSL VAN DINO Full-Size" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 20 --Log_Name "log_X13_van_DINO" -roi 17 -tl 1 -me 100 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 20 --Log_Name "log_X13_van_DINO" -roi 17 -tl 1 -me 100 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 20 --Log_Name "log_X13_van_DINO" -roi 17 -tl 1 -me 100 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 20 --Log_Name "log_X13_van_DINO" -roi 17 -tl 1 -me 100 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 20 --Log_Name "log_X13_van_DINO" -roi 17 -tl 1 -me 100 --Workers 5 +goto fin +@echo "Train SSL VAN DINO Full-Size" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_Review" -roi 17 -tl 1 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_Review" -roi 17 -tl 1 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_Review" -roi 17 -tl 1 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_Review" -roi 17 -tl 1 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_Review" -roi 17 -tl 1 --Workers 5 + +@echo "Train SSL VAN DINO Full-Size" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_Review" -roi 17 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_Review" -roi 17 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_Review" -roi 17 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_Review" -roi 17 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_Review" -roi 17 -tl 1 + +@echo "Train SSL VAN DINO Full-Size" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_R2" -roi 14 -tl 1 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_R2" -roi 14 -tl 1 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_R2" -roi 14 -tl 1 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_R2" -roi 14 -tl 1 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_R2" -roi 14 -tl 1 --Workers 5 + +@echo "Train SSL VAN DINO Full-Size Full dataset" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 18 --Log_Name "log_DINO_X11_VAN_2" -roi 6 -tl 1 -me 200 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 18 --Log_Name "log_DINO_X11_VAN_2" -roi 6 -tl 1 -me 200 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 18 --Log_Name "log_DINO_X11_VAN_2" -roi 6 -tl 1 -me 200 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 18 --Log_Name "log_DINO_X11_VAN_2" -roi 6 -tl 1 -me 200 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 18 --Log_Name "log_DINO_X11_VAN_2" -roi 6 -tl 1 -me 200 + + + +@echo "Train RN50+VAN T-S 0 Workers" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_ChangeLabels" -roi 15 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_ChangeLabels" -roi 15 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_ChangeLabels" -roi 15 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_ChangeLabels" -roi 15 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_ChangeLabels" -roi 15 -tl 1 + +@echo "Train RN50+VAN T-S 5 Workers" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_ChangeLabels" -roi 15 -tl 1 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_ChangeLabels" -roi 15 -tl 1 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_ChangeLabels" -roi 15 -tl 1 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_ChangeLabels" -roi 15 -tl 1 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_VAN_ChangeLabels" -roi 15 -tl 1 --Workers 5 + +@echo "Train RN50 5 Workers" +python RARP_NVB.py --Phase "train" --Fold 0 --Model 0 --Log_Name "log_X10" -roi 16 -tl 1 -me 50 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 1 --Model 0 --Log_Name "log_X10" -roi 16 -tl 1 -me 50 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 2 --Model 0 --Log_Name "log_X10" -roi 16 -tl 1 -me 50 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 3 --Model 0 --Log_Name "log_X10" -roi 16 -tl 1 -me 50 --Workers 5 +python RARP_NVB.py --Phase "train" --Fold 4 --Model 0 --Log_Name "log_X10" -roi 16 -tl 1 -me 50 --Workers 5 + +:phase3 +python RARP_NVB.py --Phase "tune" -ls 0 --Fold 0 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_T_VAN" -roi 13 -tl 1 +python RARP_NVB.py --Phase "tune" -ls 1 --Fold 0 --Remove_Blackbar 1 --Model 15 --Log_Name "log_X12_T_VAN" -roi 13 -tl 1 +:fin +@echo "Finish Training" \ No newline at end of file diff --git a/TrainKFolds_RARP2_Norm.bat b/TrainKFolds_RARP2_Norm.bat new file mode 100644 index 0000000..acc4459 --- /dev/null +++ b/TrainKFolds_RARP2_Norm.bat @@ -0,0 +1,34 @@ +@echo "Start Train K-Folds Full-size" + + +@echo "Train ResNet50" +python RARP_NVB-norm.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X8" -roi 7 -tl 1 +@echo "Train ResNet18" +python RARP_NVB-norm.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X8" -roi 7 -tl 1 +@echo "Train MobileNetV2" +python RARP_NVB-norm.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X8" -roi 7 -tl 1 +@echo "Train EfficientNetV2" +python RARP_NVB-norm.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X8" -roi 7 -tl 1 +@echo "Train DenseNet169" +python RARP_NVB-norm.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_X8" -roi 7 -tl 1 +python RARP_NVB-norm.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_X8" -roi 7 -tl 1 +@echo "Finish Training" diff --git a/TrainKFolds_RARP_BD.bat b/TrainKFolds_RARP_BD.bat new file mode 100644 index 0000000..8f6e429 --- /dev/null +++ b/TrainKFolds_RARP_BD.bat @@ -0,0 +1,34 @@ +@echo "Start Train K-Folds Full-Size" + +@echo "Train ResNet50" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +@echo "Train ResNet18" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +@echo "Train MobileNetV2" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +@echo "Train EfficientNetV2" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +@echo "Train DenseNet169" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_BDX1.5" -s 0.75 -ns 1 --sClass 0 -tl 1 -roi 4 +@echo "Finish Training" + diff --git a/TrainKFolds_RARP_BD2.bat b/TrainKFolds_RARP_BD2.bat new file mode 100644 index 0000000..358116e --- /dev/null +++ b/TrainKFolds_RARP_BD2.bat @@ -0,0 +1,35 @@ +@echo "Start Train K-Folds Full-Size" + +@echo "Train ResNet50" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_ResNet50_X8/lightning_logs/version_0/checkpoints/RARP-epoch=11.ckpt" +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_ResNet50_X8/lightning_logs/version_1/checkpoints/RARP-epoch=5.ckpt" +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_ResNet50_X8/lightning_logs/version_2/checkpoints/RARP-epoch=14.ckpt" +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_ResNet50_X8/lightning_logs/version_3/checkpoints/RARP-epoch=9.ckpt" +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_ResNet50_X8/lightning_logs/version_4/checkpoints/RARP-epoch=17.ckpt" +@echo "Train ResNet18" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_restnet18_X8/lightning_logs/version_0/checkpoints/RARP-epoch=9.ckpt" +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_restnet18_X8/lightning_logs/version_1/checkpoints/RARP-epoch=23.ckpt" +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_restnet18_X8/lightning_logs/version_2/checkpoints/RARP-epoch=9.ckpt" +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_restnet18_X8/lightning_logs/version_3/checkpoints/RARP-epoch=5.ckpt" +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_restnet18_X8/lightning_logs/version_4/checkpoints/RARP-epoch=7.ckpt" +@echo "Train MobileNetV2" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_MobileNetV2_X8/lightning_logs/version_0/checkpoints/RARP-epoch=22.ckpt" +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_MobileNetV2_X8/lightning_logs/version_1/checkpoints/RARP-epoch=48.ckpt" +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_MobileNetV2_X8/lightning_logs/version_2/checkpoints/RARP-epoch=23.ckpt" +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_MobileNetV2_X8/lightning_logs/version_3/checkpoints/RARP-epoch=6.ckpt" +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_MobileNetV2_X8/lightning_logs/version_4/checkpoints/RARP-epoch=32.ckpt" +@echo "Train EfficientNetV2" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_EfficientNetV2_X8/lightning_logs/version_0/checkpoints/RARP-epoch=2.ckpt" +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_EfficientNetV2_X8/lightning_logs/version_1/checkpoints/RARP-epoch=6.ckpt" +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_EfficientNetV2_X8/lightning_logs/version_2/checkpoints/RARP-epoch=3.ckpt" +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_EfficientNetV2_X8/lightning_logs/version_3/checkpoints/RARP-epoch=5.ckpt" +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_EfficientNetV2_X8/lightning_logs/version_4/checkpoints/RARP-epoch=20.ckpt" +@echo "Train DenseNet169" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_DenseNet169_X8/lightning_logs/version_0/checkpoints/RARP-epoch=6.ckpt" +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_DenseNet169_X8/lightning_logs/version_1/checkpoints/RARP-epoch=14.ckpt" +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_DenseNet169_X8/lightning_logs/version_2/checkpoints/RARP-epoch=4.ckpt" +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_DenseNet169_X8/lightning_logs/version_3/checkpoints/RARP-epoch=1.ckpt" +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_X9" -tl 1 -roi 8 --maxEpochs 120 -lc "./log_DenseNet169_X8/lightning_logs/version_4/checkpoints/RARP-epoch=1.ckpt" +@echo "Finish Training" + + diff --git a/TrainKFolds_RARP_EN.bat b/TrainKFolds_RARP_EN.bat new file mode 100644 index 0000000..fa80a44 --- /dev/null +++ b/TrainKFolds_RARP_EN.bat @@ -0,0 +1,27 @@ +@echo "Start Train K-Folds ROI-No-distractors" + +@echo "Train ResNet50" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +@echo "Train ResNet18" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +@echo "Train MobileNetV2" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +@echo "Train EfficientNetV2" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_X7" -s 0.99 -ns 2 --sClass 1 -tl 1 -roi 3 +@echo "Finish Training" diff --git a/TrainKFolds_RARP_Full.bat b/TrainKFolds_RARP_Full.bat new file mode 100644 index 0000000..f41596d --- /dev/null +++ b/TrainKFolds_RARP_Full.bat @@ -0,0 +1,33 @@ +@echo "Start Train K-Folds Full-Size" + +@echo "Train ResNet50" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_FX2" -tl 1 -roi 6 +@echo "Train ResNet18" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_FX2" -tl 1 -roi 6 +@echo "Train MobileNetV2" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_FX2" -tl 1 -roi 6 +@echo "Train EfficientNetV2" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_FX2" -tl 1 -roi 6 +@echo "Train ViT_B_16" +python RARP_NVB.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_FX2" -tl 1 -roi 6 +python RARP_NVB.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_FX2" -tl 1 -roi 6 +@echo "Finish Training" \ No newline at end of file diff --git a/TrainKFolds_RARP_FullNorm.bat b/TrainKFolds_RARP_FullNorm.bat new file mode 100644 index 0000000..5563ce3 --- /dev/null +++ b/TrainKFolds_RARP_FullNorm.bat @@ -0,0 +1,34 @@ +@echo "Start Train K-Folds Full-Size" + +@echo "Train ResNet50" +python RARP_NVB-norm.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 0 --Log_Name "log_ResNet50_FX1N" -tl 1 -roi 6 +@echo "Train ResNet18" +python RARP_NVB-norm.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 1 --Log_Name "log_restnet18_FX1N" -tl 1 -roi 6 +@echo "Train MobileNetV2" +python RARP_NVB-norm.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 2 --Log_Name "log_MobileNetV2_FX1N" -tl 1 -roi 6 +@echo "Train EfficientNetV2" +python RARP_NVB-norm.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 3 --Log_Name "log_EfficientNetV2_FX1N" -tl 1 -roi 6 +@echo "Train DenseNet169" +python RARP_NVB-norm.py --Phase "train" --Fold 0 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 1 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 2 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 3 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_FX1N" -tl 1 -roi 6 +python RARP_NVB-norm.py --Phase "train" --Fold 4 --Remove_Blackbar 1 --Model 5 --Log_Name "log_DenseNet169_FX1N" -tl 1 -roi 6 +@echo "Finish Training" + diff --git a/Tranfo.ipynb b/Tranfo.ipynb new file mode 100644 index 0000000..6ffc4fd --- /dev/null +++ b/Tranfo.ipynb @@ -0,0 +1,1161 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torchvision\n", + "import lightning as L\n", + "\n", + "modelR50 = torchvision.models.resnet50(weights=torchvision.models.ResNet50_Weights.DEFAULT)\n", + "modelEV2 = torchvision.models.efficientnet_v2_s(weights=torchvision.models.EfficientNet_V2_S_Weights.DEFAULT)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torchvision\n", + "import lightning as L\n", + "import van\n", + "\n", + "modelR50 = torchvision.models.resnet50(weights=torchvision.models.ResNet50_Weights.DEFAULT)\n", + "modelEV2 = van.van_b2()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dummyLoad = torch.rand(1, 3, 224, 224)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize a variable to store the output\n", + "last_conv_output = None\n", + "\n", + "# Define a hook function to capture the output\n", + "def hook_fn(module, input, output):\n", + " global last_conv_output\n", + " last_conv_output = output" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "modelEV2.eval()\n", + "modelEV2.block4[-1].mlp.dwconv.register_forward_hook(hook_fn)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "modelEV2(dummyLoad).shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "last_conv_output.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "modelR50" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "torch.nn.functional.adaptive_avg_pool2d()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "modelR50.layer4[-1].conv3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "modelEV2.eval()\n", + "salida = modelEV2(dummyLoad)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "modelEV2.forward_features(dummyLoad).shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "modelEV2Sub = torch.nn.Sequential(*list(modelEV2.children())[:-1])\n", + "modelEV2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "salida.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "modelR50.eval()\n", + "subModel = torch.nn.Sequential(*list(modelR50.children())[:-2])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "subModel(dummyLoad).shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for params in modelEV2.parameters():\n", + " print(params)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "torch.norm(params, p=2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "torch.linalg.norm(params)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "modelR50_Decoder = torch.nn.Sequential(*list(modelR50.children())[:-2])\n", + "modelEV2_Decoder = modelEV2.features" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "modelEV2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import timm\n", + "\n", + "model = timm.create_model(\"davit_small.msft_in1k\", pretrained=True, num_classes=1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "modelEV2.fc2= torch.nn.Linear(12,2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "\n", + "pred = torch.tensor([0.3137, 0.3161, 0.4395, 0.4636, 0.4427, 0.3616, 0.3256, 0.3367])\n", + "trueVal = torch.tensor([0.1577, 0.8148, 0.4295, 0.4841, 0.5133, 0.2474, 0.6306, 0.3618])\n", + "\n", + "PredBach = torch.tensor([[0.3137, 0.3161, 0.4395, 0.4636, 0.4427, 0.3616, 0.3256, 0.3367],\n", + " [0.2372, 0.0121, 0.5123, 0.4597, 0.3809, 0.3405, 0.3988, 0.3922],\n", + " [0.0436, 0.0425, 0.2698, 0.5095, 0.5610, 0.2571, 0.6514, 0.4645]])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "res = torch.abs(PredBach - PredBach )\n", + "print(res)\n", + "res = torch.sum(res, 1)\n", + "\n", + "mean = res.mean(1).unsqueeze(1)\n", + "\n", + "f = (res <= mean).float()\n", + "\n", + "f.split\n", + "\n", + "f = f / f.count_nonzero(dim=1).unsqueeze(1)\n", + "\n", + "torch.sum(PredBach * f, dim=1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def CalcAgreement(x:torch):\n", + " deltas = torch.sum(torch.abs(x.unsqueeze(1) - x), 1)\n", + " deltasMean = deltas.mean()\n", + " \n", + " factor = (deltas <= deltasMean).float()\n", + " factor = factor / factor.count_nonzero()\n", + " \n", + " return torch.dot(factor, x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "torch.tensor([CalcAgreement(d.squeeze()) for d in PredBach.split(1, 0)])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "res = []\n", + "for d in PredBach.split(1, 0):\n", + " res.append(CalcAgreement(d.squeeze()))\n", + "\n", + "torch.tensor(res)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "CalcAgreement(pred)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "torch.abs(pred.unsqueeze(1) - pred)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = torch.sum(torch.abs(pred.unsqueeze(1) - pred), 1)\n", + "aMean = a.mean()\n", + "aMean" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "factor = (a <= aMean).float()\n", + "factor = factor / factor.count_nonzero()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "factor, a, pred, factor * pred, torch.dot(factor, pred)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def kl_diver(a, b):\n", + " return torch.sum(a * torch.log(a/b))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "kl_diver(pred, pred)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Dkl = torch.nn.KLDivLoss(reduction=\"sum\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Dkl(pred, trueVal)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import Models\n", + "\n", + "modelo = Models.RARP_NVB_EfficientNetV2_Deep()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "modelo.model.classifier" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class RARP_NVB_NN(L.LightningModule):\n", + " def __init__(self, input_size:int=4) -> None:\n", + " super().__init__()\n", + " \n", + " self.model = torch.nn.Sequential(\n", + " torch.nn.Linear(input_size, 3),\n", + " torch.nn.ReLU(),\n", + " torch.nn.Linear(3, 1)\n", + " )\n", + " \n", + " def forward(self, data):\n", + " x = self.model(data)\n", + " return x\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class RARP_NVB_ResNet50_CAM(L.LightningModule):\n", + " def __init__(self) -> None:\n", + " super().__init__()\n", + " \n", + " self.model = torchvision.models.resnet50()\n", + " tempFC_ft = self.model.fc.in_features \n", + " self.model.fc = torch.nn.Linear(in_features=tempFC_ft, out_features=1)\n", + " \n", + " self.feature_map = torch.nn.Sequential(*list(self.model.children())[:-2])\n", + " \n", + " def forward(self, data):\n", + " featureMap = self.feature_map(data)\n", + " Cont_Net = torch.nn.functional.adaptive_avg_pool2d(input=featureMap, output_size=(1, 1)) \n", + " Cont_Net = torch.flatten(Cont_Net)\n", + " \n", + " pred = self.model.fc(Cont_Net)\n", + " \n", + " return pred, featureMap" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Any\n", + "\n", + "\n", + "class Modelo_er(L.LightningModule):\n", + " def __init__(self, *args: Any, **kwargs: Any) -> None:\n", + " super().__init__(*args, **kwargs)\n", + " \n", + " self.feature_map1 = torch.nn.Sequential(*list(modelR50.children())[:-2])\n", + " self.feature_map2 = modelEV2.features\n", + " \n", + " def forward(self, data):\n", + " featureMap1 = self.feature_map1(data)\n", + " featureMap2 = self.feature_map2(data)\n", + " \n", + " Cont_Net1 = torch.nn.functional.adaptive_avg_pool2d(input=featureMap1, output_size=(1, 1)) \n", + " Cont_Net2 = torch.nn.functional.adaptive_avg_pool2d(input=featureMap2, output_size=(1, 1)) \n", + " \n", + " Cont_Net1 = torch.flatten(Cont_Net1)\n", + " #Cont_Net2 = torch.flatten(Cont_Net2)\n", + " \n", + " return Cont_Net1, Cont_Net2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from torchvision import transforms\n", + "import defs\n", + "import Loaders\n", + "from torch.utils.data import DataLoader\n", + "\n", + "Dataset = Loaders.RARP_DatasetCreator(\n", + " \"./DataSet_big_2\",\n", + " FoldSeed=505,\n", + " createFile=True,\n", + " SavePath=\"./DatasetBig2\",\n", + " Fold=5,\n", + " removeBlackBar=True,\n", + ")\n", + "\n", + "Dataset.CreateFolds()\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "Dataset.mean, Dataset.std = ([30.38144216, 42.03988769, 97.8896116], [40.63141752, 44.26910074, 50.29294373])\n", + "batchSize = 17\n", + "Fold = 0\n", + "rootFile = Dataset.CVS_File.parent.parent/f\"fold_{Fold}\"\n", + "\n", + "testtransform = torch.nn.Sequential(\n", + " transforms.Resize(256, antialias=True),\n", + " transforms.CenterCrop(224),\n", + " transforms.Normalize(Dataset.mean, Dataset.std)\n", + ").to(device)\n", + "\n", + "testDataset = torchvision.datasets.DatasetFolder(\n", + " str (rootFile/\"test\"),\n", + " loader=defs.load_file_tensor,\n", + " extensions=\"npy\",\n", + " transform=testtransform\n", + ")\n", + "\n", + "Test_DataLoader = DataLoader(\n", + " testDataset, \n", + " batch_size=batchSize, \n", + " num_workers=0, \n", + " shuffle=False, \n", + " pin_memory=True\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ModeloObj = Modelo_er()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ModeloObj.to(device)\n", + "ModeloObj.eval()\n", + "\n", + "with torch.no_grad():\n", + " for data, label in iter(Test_DataLoader):\n", + " data = data.float().to(device)\n", + " label = label.to(device)\n", + " pred = ModeloObj(data)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import Models as M\n", + "\n", + "lsita = [M.RARP_NVB_ResNet50(None, M.TypeLossFunction.BCEWithLogits), M.RARP_NVB_ResNet18(None, M.TypeLossFunction.BCEWithLogits)]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lsita[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "torch.flatten(pred[1]).shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from pathlib import Path\n", + "\n", + "DumpCSV = pd.read_csv(Path(\"./DatasetSmallBalanced_seed_505/dump/dataset.csv\"))\n", + "Extradata = pd.read_excel(Path(\"./DataSet_smallBalaced/data.xlsx\"))\n", + "\n", + "Extradata[\"name\"] = Extradata[\"列1\"].astype(str) + \".tiff\"\n", + "Extradata = Extradata.drop(columns=[\"列1\"])\n", + "\n", + "DumpCSV[\"raw_name\"] = \"Img0-\" + DumpCSV[\"id\"].astype(str) + \".npy\"\n", + "DumpCSV = DumpCSV.drop(columns=[\"id\", \"path\", \"mean_1\", \"mean_2\", \"mean_3\", \"std_1\", \"std_2\", \"std_3\"])\n", + "\n", + "NewData = pd.merge(Extradata, DumpCSV, on=\"name\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Path(\"./DatasetSmallBalanced_seed_505/dump/dataset.csv\").name" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Extradata.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "DumpCSV.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "NewData.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "NewData[NewData[\"name\"] == \"51.tiff\"].values.flatten().tolist()[:4]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import AutoFeatureExtractor, VanForImageClassification\n", + "\n", + "model = VanForImageClassification.from_pretrained(\"Visual-Attention-Network/van-base\")\n", + "feature_extractor = AutoFeatureExtractor.from_pretrained(\"Visual-Attention-Network/van-base\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "feature_extractor" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from timm.models.layers import DropPath, to_2tuple, trunc_normal_\n", + "from timm.models.registry import register_model\n", + "from timm.models.vision_transformer import _cfg" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "\n", + "checkpoint = torch.hub.load_state_dict_from_url(\n", + " url=\"https://huggingface.co/Visual-Attention-Network/VAN-Small-original/resolve/main/van_small_811.pth.tar\", map_location=\"cpu\", check_hash=True\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import van\n", + "\n", + "model = van.van_b1(pretrained = True)\n", + "model.head.in_features" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torchvision\n", + "\n", + "#resnet50 = torch.hub.load('facebookresearch/dino:main', 'dino_resnet50')\n", + "resnet50 = torchvision.models.resnet50(weights=torchvision.models.ResNet50_Weights.DEFAULT)\n", + "vit = torchvision.models.vit_b_16()\n", + "\n", + "vitb8 = torch.hub.load('facebookresearch/dino:main', 'dino_vitb8')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "vitb8\n", + "#vit\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#new" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "lr=0.0001, L1=None\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "import torch\n", + "import cv2\n", + "import numpy as np\n", + "import Models as M\n", + "\n", + "import torchvision.transforms as T\n", + "from tqdm.notebook import tqdm\n", + "\n", + "def _removeBlackBorder(image):\n", + " image = np.array(image)\n", + " \n", + " copyImg = cv2.cvtColor(image.copy(), cv2.COLOR_BGR2HSV)\n", + " h = copyImg[:,:,0]\n", + " mask = np.ones(h.shape, dtype=np.uint8) * 255\n", + " th = (25, 175)\n", + " mask[(h > th[0]) & (h < th[1])] = 0\n", + " copyImg = cv2.cvtColor(copyImg, cv2.COLOR_HSV2BGR)\n", + " resROI = cv2.bitwise_and(copyImg, copyImg, mask=mask)\n", + " \n", + " image_gray = cv2.cvtColor(resROI, cv2.COLOR_BGR2GRAY)\n", + " _, thresh = cv2.threshold(image_gray, 0, 255, cv2.THRESH_BINARY)\n", + " kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 15))\n", + " morph = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel)\n", + " contours = cv2.findContours(morph, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n", + " contours = contours[0] if len(contours) == 2 else contours[1]\n", + " bigCont = max(contours, key=cv2.contourArea)\n", + " x, y, w, h = cv2.boundingRect(bigCont)\n", + " crop = image[y : y + h, x : x + w]\n", + " return crop\n", + "\n", + " \n", + "\n", + "#RN50ModelToEval = M.RARP_NVB_ResNet50_VAN.load_from_checkpoint(\"./log_X12_VAN_Review/lightning_logs/version_17/checkpoints/RARP-epoch=29.ckpt\")\n", + "RN50ModelToEval = M.RARP_NVB_DINO_MultiTask.load_from_checkpoint(\"./log_X13_van_DINO/lightning_logs/version_20/checkpoints/RARP-epoch=21.ckpt\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "mean, std = ([30.38144216, 42.03988769, 97.8896116], [40.63141752, 44.26910074, 50.29294373])\n", + "transforms = T.Compose([\n", + " T.Resize((256,256), antialias=True, interpolation=T.InterpolationMode.BICUBIC),\n", + " T.CenterCrop(224),\n", + " T.Normalize(mean, std)\n", + "])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([0.0550], device='cuda:0')\n" + ] + } + ], + "source": [ + "frameToFind = cv2.imread(str(Path(\"D:/Users/user/Documents/postata/RARP/Clasification/DataSet_big/NOT_NVB/213.tiff\")), cv2.IMREAD_COLOR)\n", + "frameToFind = _removeBlackBorder(frameToFind)\n", + "frameToFind = torch.Tensor(frameToFind)\n", + "frameToFind = frameToFind.permute(2, 0, 1).float()\n", + "\n", + "originalSize = frameToFind.shape[-2:]\n", + "originalImg = frameToFind\n", + "\n", + "frameToFind = transforms(frameToFind)\n", + "\n", + "frameToFind = frameToFind.repeat(1, 1, 1, 1)\n", + "\n", + "torch.set_float32_matmul_precision('high')\n", + "torch.backends.cudnn.deterministic = True\n", + "\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "RN50ModelToEval.to(device)\n", + "RN50ModelToEval.eval()\n", + "\n", + "with torch.no_grad():\n", + " frameToFind = frameToFind.to(device)\n", + " \n", + " Doutput, _, _ = RN50ModelToEval(frameToFind)\n", + " \n", + " Doutput = Doutput.flatten()\n", + " \n", + " print (torch.sigmoid(Doutput))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from pytorch_grad_cam import GradCAM, GradCAMPlusPlus\n", + "from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget\n", + "from pytorch_grad_cam.utils.image import show_cam_on_image\n", + "\n", + "targetL = [RN50ModelToEval.student.backbone.block4[-1]]\n", + "\n", + "CAM = GradCAMPlusPlus(model=RN50ModelToEval, target_layers=targetL)#GradCAM(model=RN50ModelToEval, target_layers=targetL)\n", + "tar = [ClassifierOutputTarget(0)]\n", + "\n", + "\n", + "gi = CAM(frameToFind, targets=tar)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def Denorlalize (img:torch.Tensor, std, mean):\n", + " ImgNumpy = img.numpy().transpose((1, 2, 0))\n", + " ImgNumpy = np.clip((std * ImgNumpy + mean) / 255, 0, 1)\n", + " ImgNumpy = ImgNumpy[...,::-1].copy()\n", + " \n", + " return ImgNumpy" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "\n", + "rgb_img = Denorlalize(frameToFind.cpu()[0], std, mean)\n", + "oriImg = Denorlalize(originalImg.cpu(), [1, 1, 1], [0, 0, 0])\n", + "\n", + "grayscale_cam = gi[0]\n", + "\n", + "visualization = show_cam_on_image(rgb_img, grayscale_cam, use_rgb=True)\n", + "\n", + "smallH, smallW, _ = rgb_img.shape\n", + "x, y = (16, 16) #(256 - 224) // 2\n", + "over = np.ones((256, 256), dtype=np.uint8)\n", + "layer2 = np.zeros((224, 224), dtype=np.uint8)\n", + "over[y:y + smallH, x:x + smallW] = layer2\n", + "over = cv2.resize(over, (originalSize[1], originalSize[0]))\n", + "over = cv2.bitwise_and(oriImg, oriImg, mask=over)\n", + "\n", + "bkMask = cv2.inRange(over, (0,0,0), (0,0,0))\n", + "contours, _ = cv2.findContours(bkMask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n", + "\n", + "xBK, yBK, w, h = cv2.boundingRect(max(contours, key=cv2.contourArea)) \n", + "\n", + "layer2 = cv2.resize(visualization / 255, (w, h))\n", + "\n", + "over[yBK:yBK + h, xBK:xBK + w] = layer2\n", + "\n", + "fig, ax = plt.subplots(1, 2, figsize=(20, 8))\n", + "\n", + "ax[0].imshow(oriImg)\n", + "ax[0].set_title(\"Original Image\")\n", + "ax[0].axis(\"off\")\n", + "\n", + "ax[1].imshow(over)\n", + "ax[1].set_title(\"CAM\")\n", + "ax[1].axis(\"off\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3EAAAHWCAYAAADZ8gAzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB31klEQVR4nO3dd3hUZf7+8XtKeqWmSFVQaYqAIoqiwgKKisp3FUXBFXV1wRVZZXVXEcuKomBFsS3gb1EExYbSBCkqRalSpEknBQjpbTJzfn8MM8kkgYSQZNr7dV1cknOeOfPMMSRzz+cpJsMwDAEAAAAA/ILZ2x0AAAAAAFQfIQ4AAAAA/AghDgAAAAD8CCEOAAAAAPwIIQ4AAAAA/AghDgAAAAD8CCEOAAAAAPwIIQ4AAAAA/AghDgAAAAD8CCEOAIBqmDZtmkwmk/bu3evtrgAAghwhDgBQZ1zB59dff630/FVXXaWOHTvWc6+cWrVqpeuvv77Sc0uXLpXJZNJnn312Rs+Rn5+vcePGaenSpWd0HQAAyiLEAQBQDXfddZcKCgrUsmXLaj8mPz9fzzzzDCEOAFCrCHEAAFSDxWJReHi4TCaTt7tSbQ6HQ4WFhd7uBgCglhHiAAA+Y+/evTKZTJo2bVqFcyaTSePGjfM4dujQId1zzz1KSEhQWFiYOnTooP/+97910rfK5sT9+uuv6tevnxo3bqyIiAi1bt1a99xzj/u1NGnSRJL0zDPPyGQyVXgNS5Ys0RVXXKGoqCjFx8dr4MCB2rZtW4XnXrp0qbp166bw8HCdc845evfddzVu3LgKgdJkMmnkyJGaMWOGOnTooLCwMM2fP1+S9Morr+iyyy5To0aNFBERoa5du1Y6XNR1jdmzZ6t9+/aKiIhQjx499Ntvv0mS3n33XbVp00bh4eG66qqrmCMIAF5g9XYHAACBLysrS0ePHq1w3Gaz1fiaaWlpuvTSS92ho0mTJpo3b56GDx+u7OxsjRo1qspr2Gy2SvuVlZVV5WPT09PVt29fNWnSRI8//rji4+O1d+9ezZkzR5LUpEkTvfPOO3rwwQd1880365ZbbpEkXXDBBZKk77//Xtdee63OPvtsjRs3TgUFBXrzzTd1+eWXa926dWrVqpUkaf369erfv7+SkpL0zDPPyG6369lnn3UHxPKWLFmiWbNmaeTIkWrcuLH7Oq+//rpuvPFGDRkyRMXFxZo5c6b+/Oc/a+7cuRowYIDHNVasWKGvv/5aI0aMkCSNHz9e119/vcaMGaO3335bf/vb33T8+HFNmDBB99xzj5YsWVLl/QIA1CIDAIA6MnXqVEPSKf906NDB3X7Pnj2GJGPq1KkVriXJePrpp91fDx8+3EhKSjKOHj3q0W7w4MFGXFyckZ+ff8q+tWzZssq+zZ49u8Jr2bNnj2EYhvHFF18YkoxffvnlpM9x5MiRCv126dy5s9G0aVPj2LFj7mMbN240zGazMXToUPexG264wYiMjDQOHTrkPrZz507DarUa5X+NSzLMZrOxZcuWCs9X/n4UFxcbHTt2NK655poK1wgLC3O/TsMwjHfffdeQZCQmJhrZ2dnu40888YTHPQEA1A8qcQCAOjd58mSde+65FY7/4x//kN1uP+3rGYahzz//XLfeeqsMw/CopvXr108zZ87UunXrdPnll5/yOt27d9fzzz9f4fjGjRv16KOPnvKx8fHxkqS5c+fqwgsvVEhISLX7n5KSog0bNmjMmDFq2LCh+/gFF1ygP/3pT/ruu+8kSXa7Xd9//71uvvlmJScnu9u1adNG1157rb755psK1+7Vq5fat29f4XhERIT778ePH5fdbtcVV1yhTz75pELb3r17uyt4kvM+SdKgQYMUExNT4fgff/zh0R4AULcIcQCAOnfJJZeoW7duFY43aNCg0uGMVTly5IgyMzP13nvv6b333qu0TXp6epXXady4sfr06VPhuNVa9a/HXr16adCgQXrmmWf06quv6qqrrtJNN92kO+64Q2FhYad87L59+yRJ5513XoVz7dq104IFC5SXl6fs7GwVFBSoTZs2FdpVdkySWrduXenxuXPn6vnnn9eGDRtUVFTkPl7ZQi0tWrTw+DouLk6S1Lx580qPHz9+vNLnBADUDUIcAMBnnGzlx/LVOofDIUm68847NWzYsEof45p7Vldc+8itWrVK33zzjRYsWKB77rlHEydO1KpVqxQdHV2nz38yZStuLitWrNCNN96oK6+8Um+//baSkpIUEhKiqVOn6uOPP67Q3mKxVHrtkx03DOPMOg0AOC2EOACAz2jQoIEkKTMz0+O4q3Ll0qRJE8XExMhut1daSatPl156qS699FL95z//0ccff6whQ4Zo5syZuvfee08aSl17zW3fvr3Cud9//12NGzdWVFSUwsPDFR4erl27dlVoV9mxk/n8888VHh6uBQsWeFQJp06dWu1rAAB8B1sMAAB8RmxsrBo3bqzly5d7HH/77bc9vrZYLBo0aJA+//xzbd68ucJ1jhw5Uqf9lJxDCMtXoDp37ixJ7uGKkZGRkiqG0qSkJHXu3FnTp0/3OLd582YtXLhQ1113nSTn6+zTp4++/PJLHT582N1u165dmjdvXrX7arFYZDKZPCqae/fu1ZdfflntawAAfAeVOACAT7n33nv14osv6t5771W3bt20fPly7dixo0K7F198UT/88IO6d++u++67T+3bt1dGRobWrVun77//XhkZGXXaz+nTp+vtt9/WzTffrHPOOUc5OTl6//33FRsb6w5hERERat++vT799FOde+65atiwoTp27KiOHTvq5Zdf1rXXXqsePXpo+PDh7i0G4uLiPPaSGzdunBYuXKjLL79cDz74oOx2u9566y117NhRGzZsqFZfBwwYoEmTJql///664447lJ6ersmTJ6tNmzbatGlTHdwdAEBdohIHAPApY8eO1fDhw/XZZ59pzJgxstvtlVadEhIStGbNGv3lL3/RnDlzNHLkSL3++uvKyMjQSy+9VOf97NWrl7p166aZM2fq73//uyZMmKC2bdtqyZIlHouLfPDBBzrrrLP0yCOP6Pbbb3dvsN2nTx/Nnz9fjRo10tixY/XKK6/o0ksv1U8//eTx+K5du2revHlq0KCBnnrqKX344Yd69tln1bt3b4WHh1err9dcc40+/PBDpaamatSoUfrkk0/00ksv6eabb67dmwIAqBcmg9nIAAD4nZtuuklbtmzRzp07vd0VAEA9oxIHAICPKygo8Ph6586d+u6773TVVVd5p0MAAK+iEgcAgI9LSkrS3XffrbPPPlv79u3TO++8o6KiIq1fv15t27b1dvcAAPWMhU0AAPBx/fv31yeffKLU1FSFhYWpR48eeuGFFwhwABCkvDqccvny5brhhhuUnJwsk8lUYaljwzA0duxYJSUlKSIiQn369Kkw9j8jI0NDhgxRbGys4uPjNXz4cOXm5nq02bRpk6644gqFh4erefPmmjBhQoW+zJ49W+eff77Cw8PVqVMnfffdd7X+egEAqImpU6dq7969KiwsVFZWlubPn68uXbp4u1sAAC/xaojLy8vThRdeqMmTJ1d6fsKECXrjjTc0ZcoUrV69WlFRUerXr58KCwvdbYYMGaItW7Zo0aJFmjt3rpYvX67777/ffT47O1t9+/ZVy5YttXbtWr388ssaN26c3nvvPXebn3/+WbfffruGDx+u9evX66abbtJNN91U6d5DAAAAAOBNPjMnzmQy6YsvvtBNN90kyVmFS05O1j/+8Q89+uijkqSsrCwlJCRo2rRpGjx4sLZt26b27dvrl19+Ubdu3SRJ8+fP13XXXaeDBw8qOTlZ77zzjv79738rNTVVoaGhkqTHH39cX375pX7//XdJ0m233aa8vDzNnTvX3Z9LL71UnTt31pQpU+rxLgAAAADAqfnsnLg9e/YoNTVVffr0cR+Li4tT9+7dtXLlSg0ePFgrV65UfHy8O8BJzn13zGazVq9erZtvvlkrV67UlVde6Q5wktSvXz+99NJLOn78uBo0aKCVK1dq9OjRHs/fr1+/CsM7yyoqKlJRUZH7a4fDoYyMDDVq1Egmk6kW7gAAAAAAf2QYhnJycpScnCyzufYHP/psiEtNTZXk3My1rISEBPe51NRUNW3a1OO81WpVw4YNPdqU3TS17DVTU1PVoEEDpaamnvJ5KjN+/Hg988wzNXhlAAAAAILBgQMH1KxZs1q/rs+GOF/3xBNPeFTvsrKy1KJFCx2QFBtSyQNCy30dVcV5SYqsok1V16yl5/0q/yNt/Wyr+rzYRxc/eHElDwAAAADgkp2drebNmysmJqZOru+zIS4xMVGSlJaWpqSkJPfxtLQ0de7c2d0mPT3d43ElJSXKyMhwPz4xMVFpaWkebVxfV9XGdb4yYWFhCgsLq3A8VlJsZaMpyx8rX1WtrMpqOc2vK/u/Wf5Y+YBZjcAZbUQrXOGKsEYoNja2kgcAAAAAKK+upll5dXXKU2ndurUSExO1ePFi97Hs7GytXr1aPXr0kCT16NFDmZmZWrt2rbvNkiVL5HA41L17d3eb5cuXy2azudssWrRI5513nho0aOBuU/Z5XG1czxPszFbnt4mjxOHlngAAAADwaojLzc3Vhg0btGHDBknOxUw2bNig/fv3y2QyadSoUXr++ef19ddf67ffftPQoUOVnJzsXsGyXbt26t+/v+677z6tWbNGP/30k0aOHKnBgwcrOTlZknTHHXcoNDRUw4cP15YtW/Tpp5/q9ddf9xgK+fDDD2v+/PmaOHGifv/9d40bN06//vqrRo4cWd+3xCcR4gAAAADf4dXhlL/++quuvvpq99euYDVs2DBNmzZNY8aMUV5enu6//35lZmaqZ8+emj9/vsLDw92PmTFjhkaOHKnevXvLbDZr0KBBeuONN9zn4+LitHDhQo0YMUJdu3ZV48aNNXbsWI+95C677DJ9/PHHevLJJ/Wvf/1Lbdu21ZdffqmOHTvWw13wfYQ4AAAAwHf4zD5x/i47O1txcXHKkhRb2WIh5Y9FV3FeqnoRkqquWUvPOy/iO615c42uePIKXfPcNZU8AAAAAICLOxtkZdXJmhI+OycOvsNkcU7IpBIHAAAAeB8hDlViOCUAAADgOwhxqJIrxBl2Rt4CAAAA3kaIQ5WoxAEAAAC+gxCHKhHiAAAAAN9BiEOVCHEAAACA7yDEoUqEOAAAAMB3EOJQJbOFEAcAAAD4CkIcqkQlDgAAAPAdhDhUiRAHAAAA+A5CHKpEiAMAAAB8ByEOVWKzbwAAAMB3EOJQJSpxAAAAgO8gxKFKhDgAAADAdxDiUCVCHAAAAOA7CHGokslikkSIAwAAAHwBIQ5VohIHAAAA+A5CHKpEiAMAAAB8ByEOVSLEAQAAAL6DEIcqEeIAAAAA30GIQ5XcIc5OiAMAAAC8jRCHKlGJAwAAAHwHIQ5VMlsIcQAAAICvIMShSlTiAAAAAN9BiEOVCHEAAACA7yDEoUqEOAAAAMB3EOJQJUIcAAAA4DsIcagSIQ4AAADwHYQ4VIkQBwAAAPgOQhyqZLKYJEmG3fByTwAAAAAQ4lAlKnEAAACA7yDEoUplQ5xhUI0DAAAAvIkQhyq5QpwkGQ5CHAAAAOBNhDhUqWyIY0glAAAA4F2EOFSJEAcAAAD4DkIcqkSIAwAAAHwHIQ5VIsQBAAAAvoMQhyqZzCb33wlxAAAAgHcR4lAlk8nEht8AAACAjyDEoVrY8BsAAADwDYQ4VAshDgAAAPANhDhUCyEOAAAA8A2EOFSLK8TZbXYv9wQAAAAIboQ4VG2ESdbCNEmS/ZnO3u0LAAAAEOQIcagWq6VEklRSYvVyTwAAAIDgRohDtVitJ0KcnRAHAAAAeBMhDtXiqsTZqMQBAAAAXkWIQ7W4h1NSiQMAAAC8ihCHagmx2iQR4gAAAABvI8ShWljYBAAAAPANhDhUS+nCJiFe7gkAAAAQ3AhxqBYqcQAAAIBvIMShWthiAAAAAPANhDhUC1sMAAAAAL6BEIdqYYsBAAAAwDcQ4lAtVrYYAAAAAHwCIQ7VwsImAAAAgG8gxKFa2GIAAAAA8A2EOFQLlTgAAADANxDiUC0hbDEAAAAA+ARCHKqFShwAAADgGwhxqBa2GAAAAAB8AyEO1cIWAwAAAIBvIMShWhhOCQAAAPgGQhyqxbXFgI0tBgAAAACvIsShWqjEAQAAAL7Bp0Oc3W7XU089pdatWysiIkLnnHOOnnvuORmG4W5jGIbGjh2rpKQkRUREqE+fPtq5c6fHdTIyMjRkyBDFxsYqPj5ew4cPV25urkebTZs26YorrlB4eLiaN2+uCRMm1Mtr9BdsMQAAAAD4Bp8OcS+99JLeeecdvfXWW9q2bZteeuklTZgwQW+++aa7zYQJE/TGG29oypQpWr16taKiotSvXz8VFha62wwZMkRbtmzRokWLNHfuXC1fvlz333+/+3x2drb69u2rli1bau3atXr55Zc1btw4vffee/X6en0Zq1MCAAAAvsGn35H//PPPGjhwoAYMGCBJatWqlT755BOtWbNGkrMK99prr+nJJ5/UwIEDJUkfffSREhIS9OWXX2rw4MHatm2b5s+fr19++UXdunWTJL355pu67rrr9Morryg5OVkzZsxQcXGx/vvf/yo0NFQdOnTQhg0bNGnSJI+wF8xcIc5ut8pwGDKZTV7uEQAAABCcfLoSd9lll2nx4sXasWOHJGnjxo368ccfde2110qS9uzZo9TUVPXp08f9mLi4OHXv3l0rV66UJK1cuVLx8fHuACdJffr0kdls1urVq91trrzySoWGhrrb9OvXT9u3b9fx48cr7VtRUZGys7M9/gQy1xYDklRSVOLFngAAAADBzacrcY8//riys7N1/vnny2KxyG636z//+Y+GDBkiSUpNTZUkJSQkeDwuISHBfS41NVVNmzb1OG+1WtWwYUOPNq1bt65wDde5Bg0aVOjb+PHj9cwzz9TCq/QPrkqcJJUUligkglUqAQAAAG/w6UrcrFmzNGPGDH388cdat26dpk+frldeeUXTp0/3dtf0xBNPKCsry/3nwIED3u5SnTKbHTKZHJKkkgIqcQAAAIC3+HQl7rHHHtPjjz+uwYMHS5I6deqkffv2afz48Ro2bJgSExMlSWlpaUpKSnI/Li0tTZ07d5YkJSYmKj093eO6JSUlysjIcD8+MTFRaWlpHm1cX7valBcWFqawsLAzf5F+wmRyVuNsJaEqKSTEAQAAAN7i05W4/Px8mc2eXbRYLHI4nBWh1q1bKzExUYsXL3afz87O1urVq9WjRw9JUo8ePZSZmam1a9e62yxZskQOh0Pdu3d3t1m+fLlsttJ5X4sWLdJ5551X6VDKYOXa8JsQBwAAAHiPT4e4G264Qf/5z3/07bffau/evfriiy80adIk3XzzzZIkk8mkUaNG6fnnn9fXX3+t3377TUOHDlVycrJuuukmSVK7du3Uv39/3XfffVqzZo1++uknjRw5UoMHD1ZycrIk6Y477lBoaKiGDx+uLVu26NNPP9Xrr7+u0aNHe+ul+yT3NgOEOAAAAMBrfHo45ZtvvqmnnnpKf/vb35Senq7k5GT99a9/1dixY91txowZo7y8PN1///3KzMxUz549NX/+fIWHh7vbzJgxQyNHjlTv3r1lNps1aNAgvfHGG+7zcXFxWrhwoUaMGKGuXbuqcePGGjt2LNsLlOMKcbYCWxUtAQAAANQVk2EYhrc7EQiys7MVFxenLEmxoZU0KH8suorzkhRVRZuqrlnLz/vOzAeVnpGgu76/S2f3PruSBwIAAABwZ4OsLMXGxtb69X16OCV8C8MpAQAAAO8jxKHaWNgEAAAA8D5CHKrNXYljnzgAAADAawhxqDYqcQAAAID3EeJQbcyJAwAAALyPEIdqY4sBAAAAwPsIcag2q9UZ3qjEAQAAAN5DiEO1MZwSAAAA8D5CHKqNhU0AAAAA7yPEodrYYgAAAADwPkIcqi2EShwAAADgdYQ4VBtz4gAAAADvI8Sh2hhOCQAAAHgfIQ7VxhYDAAAAgPcR4lBtDKcEAAAAvI8Qh2pjiwEAAADA+whxqDZXJc5WYPNyTwAAAIDgRYhDtbHFAAAAAOB9hDhUG3PiAAAAAO8jxKHaCHEAAACA9xHiUG3uLQbYJw4AAADwGkIcqo1KHAAAAOB9hDhUm2uLAXuxXYbD8HJvAAAAgOBEiEO1uSpxEtU4AAAAwFsIcag21xYDEiEOAAAA8BZCHKrNbHbIZHJIIsQBAAAA3kKIw2lhcRMAAADAuwhxOC2uxU1sBTYv9wQAAAAIToQ4nJYQy4m94qjEAQAAAF5BiMNpcVXiCHEAAACAdxDicFqYEwcAAAB4FyEOp8VdiSsgxAEAAADeQIjDaaESBwAAAHgXIQ6nhRAHAAAAeBchDqeFLQYAAAAA7yLE4bSwxQAAAADgXYQ4nBa2GAAAAAC8ixCH02JhThwAAADgVYQ4nJYQthgAAAAAvIoQh9PC6pQAAACAdxHicFoIcQAAAIB3EeJwWqwMpwQAAAC8ihCH02JliwEAAADALWNXhl5r9Zqm9ZpWb89JiMNpYYsBAAAAoFR+277K2pelrOWbJVPLenlOQhxOC3PiAAAAgFIFCpMkhauo3p6TEIfT4tpiwFZg83JPAAAAAO8rUKgkKULF9fachDicFipxAAAAQKnCE5W4CCpx8FWEOAAAAKCUqxIXTiUOvoqFTQAAAIBSzImDz3NvMcA+cQAAAADDKeH7qMQBAAAApQpZ2AS+jjlxAAAAQCmGU8LnscUAAAAAUKrAPZySShx8lKsS57A55LA7vNwbAAAAwLtKh1NSiYOPcs2JkyR7kd2LPQEAAAC8j+GU8HmuSpzEvDgAAAAEt5LCEpXIKonhlPBhZrNDZqvz24Z5cQAAAAhmBccLTvzNUBghDr7MGu78tIFKHAAAAIJZ4fFCSc75cKZ6fF5CHE4bIQ4AAAAorcSF12MVTiLEoQasERVDXHFesb4Y+oW2f73dW90CAAAA6lVBhjPE1efKlBIhDjXgrsQVlIa4nUMv0qb/t0k/jZggPVWfxWQAAADAO1zDKanEwedVNpwyKytekmQrCfFGlwAAAIB65xpOSSUOPq+yEJedEytJststXukTAAAAUN9KK3GEOPi4kAhnta3sFgPZ2YQ4AAAABJfSOXEMp4SPq3Q4ZXacJEIcAAAAggeVOPiNSodTUokDAABAkGFO3EkcOnRId955pxo1aqSIiAh16tRJv/76q/u8YRgaO3askpKSFBERoT59+mjnzp0e18jIyNCQIUMUGxur+Ph4DR8+XLm5uR5tNm3apCuuuELh4eFq3ry5JkyYUC+vzx+V32LAXmxXbm608++EOAAAAASJ0s2+GU7pdvz4cV1++eUKCQnRvHnztHXrVk2cOFENGjRwt5kwYYLeeOMNTZkyRatXr1ZUVJT69eunwsJCd5shQ4Zoy5YtWrRokebOnavly5fr/vvvd5/Pzs5W37591bJlS61du1Yvv/yyxo0bp/fee69eX6+/KL/FQE5KjnRij3pCHAAAAIKFa05cfQ+ntNbrs52ml156Sc2bN9fUqVPdx1q3bu3+u2EYeu211/Tkk09q4MCBkqSPPvpICQkJ+vLLLzV48GBt27ZN8+fP1y+//KJu3bpJkt58801dd911euWVV5ScnKwZM2aouLhY//3vfxUaGqoOHTpow4YNmjRpkkfYg1P54ZTZB7Ld5whxAAAACBalwympxLl9/fXX6tatm/785z+radOmuuiii/T++++7z+/Zs0epqanq06eP+1hcXJy6d++ulStXSpJWrlyp+Ph4d4CTpD59+shsNmv16tXuNldeeaVCQ0Pdbfr166ft27fr+PHjlfatqKhI2dnZHn+CRfkQl3Ugy33ObrfKMLzSLQAAAKDeGIZRZjglc+Lc/vjjD73zzjtq27atFixYoAcffFB///vfNX36dElSamqqJCkhIcHjcQkJCe5zqampatq0qcd5q9Wqhg0berSp7Bpln6O88ePHKy4uzv2nefPmZ/hq/YdrTpxri4Hsg54B1uHw6W8rAAAA4IzZ8m2yF9slsTqlB4fDoS5duuiFF17QRRddpPvvv1/33XefpkyZ4u2u6YknnlBWVpb7z4EDB7zdpXpzquGUEkMqAQAAEPhcVTiTHApVSRWta5dPh7ikpCS1b9/e41i7du20f/9+SVJiYqIkKS0tzaNNWlqa+1xiYqLS09M9zpeUlCgjI8OjTWXXKPsc5YWFhSk2NtbjT7BwhTh7ofOTh/KVOEIcAAAAAl3Z7QVM9fzcPh3iLr/8cm3fvt3j2I4dO9SyZUtJzkVOEhMTtXjxYvf57OxsrV69Wj169JAk9ejRQ5mZmVq7dq27zZIlS+RwONS9e3d3m+XLl8tms7nbLFq0SOedd57HSphwCokIkXSqSpxPr5cDAAAAnDFvbS8g+XiIe+SRR7Rq1Sq98MIL2rVrlz7++GO99957GjFihCTJZDJp1KhRev755/X111/rt99+09ChQ5WcnKybbrpJkrNy179/f913331as2aNfvrpJ40cOVKDBw9WcnKyJOmOO+5QaGiohg8fri1btujTTz/V66+/rtGjR3vrpfs0VyXONSeu7MImEpU4AAAABD5vbS8g+fgWAxdffLG++OILPfHEE3r22WfVunVrvfbaaxoyZIi7zZgxY5SXl6f7779fmZmZ6tmzp+bPn6/w8HB3mxkzZmjkyJHq3bu3zGazBg0apDfeeMN9Pi4uTgsXLtSIESPUtWtXNW7cWGPHjmV7gZMoOyfOXmxXXlqex3lCHAAAAAKdt7YXkGoY4v744w+dffbZtd2XSl1//fW6/vrrT3reZDLp2Wef1bPPPnvSNg0bNtTHH398yue54IILtGLFihr3M5iUDXHZh5xDKS2WEoWGFqugIJIQBwAAgIDnre0FpBoOp2zTpo2uvvpq/e9//1NhYWFt9wk+zrXFQElhiXs+XGxstqxW5xw5QhwAAAACnasS543hlDUKcevWrdMFF1yg0aNHKzExUX/961+1Zs2a2u4bfJS7EldQ4l6ZMi42Sxazc7VKQhwAAAACXemcOD9Z2KRz5856/fXXdfjwYf33v/9VSkqKevbsqY4dO2rSpEk6cuRIbfcTPqTscErXoiaxMdmyWAhxAAAACA5+N5zSxWq16pZbbtHs2bP10ksvadeuXXr00UfVvHlzDR06VCkpKbXVT/iQslsMuCpxsbGEOAAAAAQPvw1xv/76q/72t78pKSlJkyZN0qOPPqrdu3dr0aJFOnz4sAYOHFhb/YQPKbvFgHtOXFxWaYhzEOIAAAAQ2ErnxPnJ6pSTJk3S1KlTtX37dl133XX66KOPdN1118lsdmbC1q1ba9q0aWrVqlVt9hU+wmN1SleIKzOcsqSEEAcAAIDA5poT541KXI1C3DvvvKN77rlHd999t5KSkipt07RpU3344Ydn1Dn4Jo8Q517YhOGUAAAACB6u4ZR+U4nbuXNnlW1CQ0M1bNiwmlwePs61xYDD5lBeunOj79jYLEIcAAAAgoJhGGU2+/aTOXFTp07V7NmzKxyfPXu2pk+ffsadgm9zVeLKfh0RUUCIAwAAQFAozimWYTck+VGIGz9+vBo3blzheNOmTfXCCy+ccafg28qHuNjmsTKZRIgDAABAUHBV4SyhFlllr/fnr1GI279/v1q3bl3heMuWLbV///4z7hR8m9liljmk9FsntlmsJLE6JQAAAIKCez5cg3CZvPD8NQpxTZs21aZNmyoc37hxoxo1anTGnYLvK1uNi2seJ4lKHAAAAIKDez5cwwivPH+NQtztt9+uv//97/rhhx9kt9tlt9u1ZMkSPfzwwxo8eHBt9xE+qGyIi21erhJHiAMAAEAAc28v0MA7Ia5Gq1M+99xz2rt3r3r37i2r9cRKhQ6Hhg4dypy4IOER4prFSofKhLiSGn1bAQAAAH6h7HBKb6jRu+3Q0FB9+umneu6557Rx40ZFRESoU6dOatmyZW33Dz4qJCLE/ffY5uVCHJU4AAAABDD3cEp/qsS5nHvuuTr33HNrqy/wIxXmxK1iYRMAAAAEB3clrqEfVeLsdrumTZumxYsXKz09XQ6Hw+P8kiVLaqVz8F0VhlNKspipxAEAACDw+eWcuIcffljTpk3TgAED1LFjR5lM3lhYE95kjXB+64REhrjHAlusJZIIcQAAAAhsfjknbubMmZo1a5auu+662u4P/ISrEufc6NsZ4pkTBwAAgGDg7TlxNdpiIDQ0VG3atKntvsCPuEPciaGUEiEOAAAAwcFVifOrfeL+8Y9/6PXXX5dhGLXdH/gJV4hzbfQtEeIAAAAQHFxz4vxqOOWPP/6oH374QfPmzVOHDh0UEhLicX7OnDm10jn4rpBI5/9z10bfEgubAAAAIDh4ezhljUJcfHy8br755truC/zFIyZ1zmmprOa91GnfW9IjR6VoKnEAAAAIfIbDUGGmHy5sMnXq1NruB/xMy2b7NLTZRx7HCHEAAAAIdIVZhdKJWWV+tbCJJJWUlOj777/Xu+++q5ycHEnS4cOHlZubW2udg38hxAEAACDQuRY1sUZYPfZOrk81etZ9+/apf//+2r9/v4qKivSnP/1JMTExeumll1RUVKQpU6bUdj/hBwhxAAAACHTeng8n1bAS9/DDD6tbt246fvy4IiJKO3/zzTdr8eLFtdY5+BcrIQ4AAAABztvbC0g1rMStWLFCP//8s0JDQz2Ot2rVSocOHaqVjsH/UIkDAABAoPP29gJSDStxDodDdru9wvGDBw8qJibmjDsF/0SIAwAAQKDz2+GUffv21Wuvveb+2mQyKTc3V08//bSuu+662uob/AwhDgAAAIHONZzSm5W4Gg2nnDhxovr166f27dursLBQd9xxh3bu3KnGjRvrk08+qe0+wk+4QlyJ3Tur9AAAAAB1ytRWheosqaPCp8+Upj/mlW7U6N12s2bNtHHjRs2cOVObNm1Sbm6uhg8friFDhngsdILgQiUOAAAAga5IIZKkMNm81ocal0ysVqvuvPPO2uwL/BwhDgAAAIGu2F9D3EcffXTK80OHDq1RZ+DfCHEAAAAIdK5KXKhKvNaHGoW4hx9+2ONrm82m/Px8hYaGKjIykhAXpFwhzuGwyDAMmUwmL/cIAAAAqF2+MJyyRqtTHj9+3ONPbm6utm/frp49e7KwSRCzWEo/jXDYHF7sCQAAAFA3/DbEVaZt27Z68cUXK1TpEDxclThJshdX3EcQAAAA8He+MCeu1kKc5Fzs5PDhw7V5SfgRQhwAAAACnS9U4mo0J+7rr7/2+NowDKWkpOitt97S5ZdfXisdg/8xmw2ZTA4ZhlklRd6b6AkAAADUFb8NcTfddJPH1yaTSU2aNNE111yjiRMn1ka/4KcsFrtKSsxU4gAAABBwHDLJdiJChfpbiHM4WLQClXOGuBBCHAAAAAJOcZn4FDBz4gD3XnGEOAAAAAQY11BKi+yyynuFrRpV4kaPHl3ttpMmTarJU8BPEeIAAAAQqEo3+vZeFU6qYYhbv3691q9fL5vNpvPOO0+StGPHDlksFnXp0sXdjs2egw8hDgAAAIHKFxY1kWoY4m644QbFxMRo+vTpatCggSTnBuB/+ctfdMUVV+gf//hHrXYS/oMQBwAAgEDlC3vESTWcEzdx4kSNHz/eHeAkqUGDBnr++edZnTLIEeIAAAAQqEorcd7dTqtGIS47O1tHjhypcPzIkSPKyck5407BfxHiAAAAEKh8ZThljULczTffrL/85S+aM2eODh48qIMHD+rzzz/X8OHDdcstt9R2H+FH3CGuiBAHAACAwFLkA3vESTWcEzdlyhQ9+uijuuOOO2SzOV+A1WrV8OHD9fLLL9dqB+FfLGYqcQAAAAhMRQqV5P1KXI1CXGRkpN5++229/PLL2r17tyTpnHPOUVRUVK12Dv6H4ZQAAAAIVH49nNIlJSVFKSkpatu2raKiomQYRm31C36KEAcAAIBAVewjwylrFOKOHTum3r1769xzz9V1112nlJQUSdLw4cPZXiDIEeIAAAAQqPy6EvfII48oJCRE+/fvV2RkpPv4bbfdpvnz59da5+B/rBbncquEOAAAAAQaXwlxNZoTt3DhQi1YsEDNmjXzON62bVvt27evVjoG/0QlDgAAAIHKrzf7zsvL86jAuWRkZCgsLOyMOwX/ZSbEAQAAIED5SiWuRiHuiiuu0EcffeT+2mQyyeFwaMKECbr66qtrrXPwP65KXEmRd3exBwAAAGqbr4S4Gg2nnDBhgnr37q1ff/1VxcXFGjNmjLZs2aKMjAz99NNPtd1H+BGGUwIAACBQuUJcqLxbsKhRJa5jx47asWOHevbsqYEDByovL0+33HKL1q9fr3POOae2+wg/QogDAABAoPLbSpzNZlP//v01ZcoU/fvf/66LPsGPEeIAAAAQiOzFdtllkeT9EHfalbiQkBBt2rSpLvqCAECIAwAAQCAqyily/93vQpwk3Xnnnfrwww9ruy8IAK4Q5yh2eLknAAAAQO0pynaGOKtKZJbh1b7UaGGTkpIS/fe//9X333+vrl27KioqyuP8pEmTaqVz8D9WKnEAAAAIQMU5xZK8X4WTTjPE/fHHH2rVqpU2b96sLl26SJJ27Njh0cZkMtVe7+B3GE4JAACAQOSqxPldiGvbtq1SUlL0ww8/SJJuu+02vfHGG0pISKiTzsH/EOIAAAAQiHwpxJ3WnDjD8Bz7OW/ePOXl5dVqh+Df2OwbAAAAgci1sInfhbjyyoc6gEocAAAAApGrEuftjb6l0wxxJpOpwpy3+pwD9+KLL8pkMmnUqFHuY4WFhRoxYoQaNWqk6OhoDRo0SGlpaR6P279/vwYMGKDIyEg1bdpUjz32mEpKPG/+0qVL1aVLF4WFhalNmzaaNm1aPbyiwEOIAwAAQCDypeGUpzUnzjAM3X333QoLC5PkDFAPPPBAhdUp58yZU3s9POGXX37Ru+++qwsuuMDj+COPPKJvv/1Ws2fPVlxcnEaOHKlbbrlFP/30kyTJbrdrwIABSkxM1M8//6yUlBQNHTpUISEheuGFFyRJe/bs0YABA/TAAw9oxowZWrx4se69914lJSWpX79+tf5aAhkhDgAAAIHItTplqL+FuGHDhnl8feedd9ZqZ04mNzdXQ4YM0fvvv6/nn3/efTwrK0sffvihPv74Y11zzTWSpKlTp6pdu3ZatWqVLr30Ui1cuFBbt27V999/r4SEBHXu3FnPPfec/vnPf2rcuHEKDQ3VlClT1Lp1a02cOFGS1K5dO/3444969dVXCXGnyWImxAEAACDw+G0lburUqXXVj1MaMWKEBgwYoD59+niEuLVr18pms6lPnz7uY+eff75atGihlStX6tJLL9XKlSvVqVMnjxU0+/XrpwcffFBbtmzRRRddpJUrV3pcw9Wm7LDN8oqKilRUVLpre3Z2di28Uv9nsTqHqRLiAAAAEEj8NsR5w8yZM7Vu3Tr98ssvFc6lpqYqNDRU8fHxHscTEhKUmprqblN+CwTX11W1yc7OVkFBgSIiIio89/jx4/XMM8/U+HUFKoZTAgAAIBD50mbfZ7Q6ZV07cOCAHn74Yc2YMUPh4eHe7o6HJ554QllZWe4/Bw4c8HaXfAIhDgAAAIHIlypxPh3i1q5dq/T0dHXp0kVWq1VWq1XLli3TG2+8IavVqoSEBBUXFyszM9PjcWlpaUpMTJQkJSYmVlit0vV1VW1iY2MrrcJJUlhYmGJjYz3+oEyIKyLEAQAAIHAQ4qqpd+/e+u2337Rhwwb3n27dumnIkCHuv4eEhGjx4sXux2zfvl379+9Xjx49JEk9evTQb7/9pvT0dHebRYsWKTY2Vu3bt3e3KXsNVxvXNVB9VOIAAAAQiFybffvd6pT1LSYmRh07dvQ4FhUVpUaNGrmPDx8+XKNHj1bDhg0VGxurhx56SD169NCll14qSerbt6/at2+vu+66SxMmTFBqaqqefPJJjRgxwr1VwgMPPKC33npLY8aM0T333KMlS5Zo1qxZ+vbbb+v3BQcAVqcEAABAIPKlSpxPh7jqePXVV2U2mzVo0CAVFRWpX79+evvtt93nLRaL5s6dqwcffFA9evRQVFSUhg0bpmeffdbdpnXr1vr222/1yCOP6PXXX1ezZs30wQcfsL1ADVCJAwAAQCDypYVNTIZhGN7uRCDIzs5WXFycsiTFhlbSoPyx6CrOS1JUFW2qumZ9PW+Z6+blReqVV8dIksbax8pkNlXSGAAAAPAfhmHo+dDn5Shx6BHNUazyy5wtLtd4X2k2yMqqk7UzfHpOHPyPqxInSXYb1TgAAAD4v5LCEjlKHJJ8oxJHiEOtslrLhDiGVAIAACAAuIZSSr6xsAkhDrXKbCbEAQAAILC4FjUJlU2+MFmIEIdaZTYbMpmcpWZCHAAAAAKBL61MKRHiUAfY8BsAAACBxLVHHCEOAYttBgAAABBIyg6n9AWEONQ6QhwAAAACCcMpEfAIcQAAAAgkvrTRt0SIQx0gxAEAACCQUIlDwLNaSiQR4gAAABAYmBOHgEclDgAAAIGkdHXKEi/3xIkQh1pHiAMAAEAgKc5mThwCnCvElRT5xicVAAAAwJlgnzgEPCpxAAAACCTMiUPAI8QBAAAgkLA6JQIeIQ4AAACBhH3iEPAIcQAAAAgkVOIQ8CxmQhwAAAACByEOAc9iJcQBAAAgMBiGweqUCHwMpwQAAECgsOXZJMP5d1anRMByh7giQhwAAAD8m2sopclsUoh84/0tIQ61jkocAAAAAoV7KGVsmExe7osLIQ61jhAHAACAQOHe6Dsm1Ms9KUWIQ61jdUoAAAAECvfKlLFhXu5JKUIcah2VOAAAAAQK90bfhDgEMkIcAAAAAoW7EhdDiEMAI8QBAAAgUJRd2MRXEOJQ6yzWEkmEOAAAAPg/98ImsSxsggDGwiYAAAAIFAynRFBgs28AAAAEChY2QVBgThwAAAACBVsMICgQ4gAAABAo2OwbQYEQBwAAgEDhi5U4q7c7gMBDiAMAAIC/ytqfpZ3zdurATwe0/8f9ytyTKYkQhwBHiAMAAIA/Ksou0tsd3lZxbrH7mEmGmuuYWlx/pxd75okQh1pnJcQBAADADx2Nu17F6qlQlehS7VELpauZjitMJd7umgdCHGodlTgAAAD4oyxFSJKaKkdXa4ckm3c7dBIsbIJa5wpxJUW+9YkFAAAAcCqZJ0JcnAq83JNTI8Sh1lGJAwAAgD/KIsQhWBHiAAAA4I9cIS6eEIdgQ4gDAACAP6ISh6DlCnGG3ZDD7vBybwAAAIDqYU4cgpYrxEmSw0aIAwAAgO8ryilSoUIlMZwSQahsiGNIJQAAAPxB1r4sSVK4bD63L1x5hDjUOkIcAAAA/E3mvkxJUpzyvduRaiDEodaZTIbMVue3FiEOAAAA/iBrv7MS5+tDKSVCHOqIJdQiiQ2/AQAA4B9cwyl9fVETiRCHOuIKcVTiAAAA4A8IcQh6hDgAAAD4k9I5cYQ4BClCHAAAAPyJqxLHnDgErWAMcakbU7X0maWyFdi83RUAAACcBnuxXTkpOZKoxCGIBVuIs+ebtOSJ0Vo2bpl+/+wib3cHAAAApyH7YLZkSFbZFaVib3enSoQ41AlLWHCFOEnKPxYpSSrIiPByTwAAAHA6ys6HM3m3K9VCiEOdCLZKnCTZ8kIlScUn/gsAAAD/4E8rU0qEONQRd4grCp4QV0yIAwAA8Ev+tDKlRIhDHQnOSlyIx38BAADgH6jEAQrOEEclDgAAwD/50/YCEiEOdSTYQpzhMMmW7wxvNkIcAACAX8naTyUOCLoQZ8svHUJJJQ4AAMB/GA7DHeKoxCGoBVuIK84NrfTvAAAA8G25abmyF9tlMpsUo0Jvd6daCHGoE0EX4spU4spW5QAAAODbXPPhYs6KkUWGl3tTPYQ41Ilg2+zbRiUOAADAL7m2F4hvGe/VfpwOQhzqRNBV4srMg3MtcAIAAADf517UpEWcl3tSfYQ41AlXiCspKvFyT+pH2RBHJQ4AAMB/uPeIa0mIQ5ALtkqczaMSx5w4AAAAf0GIA04IthBXnOe5xYDh8I9JsQAAAMGOOXG1bPz48br44osVExOjpk2b6qabbtL27ds92hQWFmrEiBFq1KiRoqOjNWjQIKWlpXm02b9/vwYMGKDIyEg1bdpUjz32mEpKPIf5LV26VF26dFFYWJjatGmjadOm1fXLC2jBFuI8Nvg2TLIV2LzXGQAAAFQblbhatmzZMo0YMUKrVq3SokWLZLPZ1LdvX+Xl5bnbPPLII/rmm280e/ZsLVu2TIcPH9Ytt9ziPm+32zVgwAAVFxfr559/1vTp0zVt2jSNHTvW3WbPnj0aMGCArr76am3YsEGjRo3SvffeqwULFtTr6w0krhDnKHZ4uSf1o/w8OFseIQ4AAMDXFWYWqii7SJJ/LWxi9XYHTmX+/PkeX0+bNk1NmzbV2rVrdeWVVyorK0sffvihPv74Y11zzTWSpKlTp6pdu3ZatWqVLr30Ui1cuFBbt27V999/r4SEBHXu3FnPPfec/vnPf2rcuHEKDQ3VlClT1Lp1a02cOFGS1K5dO/3444969dVX1a9fv3p/3YEg2CpxxeVWpCzOLVZU0ygv9QYAAADV4VqZMrJxpEKj/GdxOp+uxJWXleW8yQ0bNpQkrV27VjabTX369HG3Of/889WiRQutXLlSkrRy5Up16tRJCQkJ7jb9+vVTdna2tmzZ4m5T9hquNq5rVKaoqEjZ2dkef1Aq2EKcrVwlrjiv2Es9AQAAQHW55sP5UxVO8qMQ53A4NGrUKF1++eXq2LGjJCk1NVWhoaGKj4/3aJuQkKDU1FR3m7IBznXede5UbbKzs1VQUFBpf8aPH6+4uDj3n+bNm5/xawwk1jBnkTdYQlxxuRUpi3MJcQAAAL7u6O9HJUnxreK925HT5DchbsSIEdq8ebNmzpzp7a5Ikp544gllZWW5/xw4cMDbXfIpQbdPHHPiAAAA/IvpGu0ZM0uS1GLON5LpGi93qPp8ek6cy8iRIzV37lwtX75czZo1cx9PTExUcXGxMjMzPapxaWlpSkxMdLdZs2aNx/Vcq1eWbVN+Rcu0tDTFxsYqIiKi0j6FhYUpLCzsjF9boAq64ZR5FefEAQAAwHeVyKR9cg6jPEfHvdyb0+PTlTjDMDRy5Eh98cUXWrJkiVq3bu1xvmvXrgoJCdHixYvdx7Zv3679+/erR48ekqQePXrot99+U3p6urvNokWLFBsbq/bt27vblL2Gq43rGjh9wRbiiglxAAAAfmW/4lQii2JUpMbK93Z3TotPV+JGjBihjz/+WF999ZViYmLcc9ji4uIUERGhuLg4DR8+XKNHj1bDhg0VGxurhx56SD169NCll14qSerbt6/at2+vu+66SxMmTFBqaqqefPJJjRgxwl1Je+CBB/TWW29pzJgxuueee7RkyRLNmjVL3377rddeu78LthDnqsSZzA4ZDjMLmwAAAPi43XIulniOjsvk5b6cLp+uxL3zzjvKysrSVVddpaSkJPefTz/91N3m1Vdf1fXXX69BgwbpyiuvVGJioubMmeM+b7FYNHfuXFksFvXo0UN33nmnhg4dqmeffdbdpnXr1vr222+1aNEiXXjhhZo4caI++OADthc4A8EW4orznAubRDZ2fopDJQ4AAMC37VYDSdLZyvByT06fT1fiDMOosk14eLgmT56syZMnn7RNy5Yt9d13353yOldddZXWr19/2n1E5YIvxDkrcVFNc5WXHs3CJgAAAD4sNy1XaYqWJJ2tTO92pgZ8uhIH/xVsIc61T1xU0zxJVOIAAAB82R/f/yFJSlKOouR/H74T4lAnLGHBFeKK80srcRIhDgAAwJf9sdAZ4s72s1UpXQhxqBPBVIkzHIZ7YZPoBGeIYzglAACAbzIMQ7sX7pbkf1sLuBDiUCfcIa4o8EOcraA0sDGcEgAAwLelb05XbmqurLKrubK83Z0aIcShTgRTJc4d2EyGIhudWJ2SLQYAAAB8kqsK10qZsqrqhRR9ESEOdSIYQ1xIpE2hMUUexwAAAOBbXPPh/HUopUSIQx1xhTjDYchhd3i5N3XLNf8tNKpYoVHFHscAAADgO0oKS7Rv+T5JhDigAleIkwK/GuequoVGFyskyuZxDAAAAL5j/4/7VVJYopizYtRY+d7uTo0R4lAngirE5bmGU5ZW4ghxAAAgWB3bcUwzrpuh/T/t93ZXKti1YJck6Zw/nSOTl/tyJqze7gACk+WlEJnMY2U4zCp6LkHhr/jnyj/VUbYSFxp9IsSxsAkAAAhGpsn6TXnapQJFzDugFoqRjBHe7pUkKdM0UGt1oSSL2kz71NvdOSNU4lAnTCapQQPnOONjRxt5uTd1q+zCJiGRpZU4w/DP1Y4AAADORM6JFR9z5DvrIhgOQ1/pHBXLoubKVjtleLtLZ4QQhzrTpMkRSdKRI0283JO65V7YpEwlToZz4iwAAECwyT0R3nJ9KMT98vYv2qs4hcium7Tb70OQv/cfPqzxiRB3NMBDnHs4ZVSxQiJtFY4DAAAEE1d485VK3LGdx7RozCJJUh/tU0MVerlHZ44QhzrTpMlRSdLRI4293JO65V7YJKpYZosha4QzyLHNAAAACEauEFckQ8Ve3kzbYXfoq7u/UklBiVorSxcrzav9qS2EONSZYBlOWbYSV/a/VOIAAECwMWR4DKP09pDKlZNW6sDPBxQaE6obtcuvV6QsixCHOtO4sbMSl5cXrYKMghpfx9c3C3cvbHJij7gQQhwABLWCjAI5Snz7dxdQVwpleMQ2bw6ptBXYtPTppZKkfq/2U7wC570ZIQ51JjSsWLFxzq0Fjmw7UqNrLHxsoSY0mqDjfxyvza7VKvfCJuUrcWwzAABBJ+dwjiadNUkzB870dlcArygf2rwZ4o5E3qWSghJFqEQX3TvOa/2oC4Q41Cn3kMqtNQhxH5u0/X9zVZRVpP0vX1W7HatFZfeJk6TQExU5KnEAEHy6nJumksISbZh3SKYG3u4NUP/KD5/05nDKNEVIkhKVHzDDKF0IcahT7hUqtx097ccaDpOyjsVJknIyY2q1X7XJVYlz7RHnGk7JwiYAEHwijbwT/82XyWBIJYJP+dDmzUpc6okQ11Q1n9bjqwhxqFNnUonLy46S3WaVJOUc990QV7ESx5w4AAhWUY58SZJJUoQReG8cgar4UiUuXZGSpERCHHB63NsM1KAS56rCSVKuH4Q41x5xIcyJA4Cg5arESVKUke/FnsCbju085tPz+etS7oktBaJODGD0ViXOMAx3JS5BgfdvkRCHOuUaTpm1P+u0K1OZR0tDnE9X4vLKVeKiqcQBQLCKLBPcIglxQamksETvX/y+3r/kfdltdm93p97lnQhtSToxmspLIS77YLYKZZVJhpoEwObe5RHiUKciIwsUFZUrSTr6++lV47KOxrv/7stz4irsExfJwiYAEKxcwyklKdKRd4qWCFQHIrJVlFWkgmMFOhwafN8DrtCW6OUQl7bJual3YxXK6uUNx+sCIQ51rvGJIZWnu81A+UqcYfjmP0D3wiYnQlxINAubAECwKlt9YzhlcMpXbqV/Dxa55SpxRTJky6+d90R7l+7V5k83V6tt2kZniEsMwKGUEiEO9aBJDVeoLFuJs5dYz2jD8LpiOIzS4ZTuShzDKQEgWEWVmRNXdn4cgkfZ4JYXxCGukSwnYpyUk5Jzxtd1mEZq5tVT9fngz3XINKrK9q5KXCCuTCkR4lAPGtdwhcqsMpU4ybmBqq+xFdjkqtC79ocLpRIHAEHLoxLnCMwKAE4tL4grcfZiuwpOvDGKkVkxJ6JGbsqZ34ejsqjoxPU2KrzK9qWVOEIcUCM1XaEy80QlzhriDEM+GeLKBLUKq1NSiQtKhsM3h/0CqHt2m10RRukCCixsEpyCeThlXrqz+myWFCGTO8TVxnu4FHddT9qsMNmLT75ojK3ApmM7jkmSEghxQM24hlNm7M5QSVFJtR5TmFWoonznpyxJrVMk+WaIc28vEFUsk9n55t1VkWOLgeCzZfYWjY8dr9+/+t3bXQHgBQXHPN8sEuKCUzAPp3QNm4ySWaayIa4WhlOWDXEFMmvnvJ0nbXtkyxEZDkORsilagTkyihCHOhcdk6Ow2DAZdkMZOzOq9Zis/VmSpIjofDVKcn6S4pMhLs9zHpzEZt/BKkImjZ33b9nybPrngkcVcWJ/HADBI++I5xy4KFanDEp5yivz9+AKcbmpztcbfSJiRNdBJS5Ozgrcpo82nbRt6sZUSc4qXKD+NibEoc6ZTFKT9k0kVX+Fyqx9zhAX1zhLMfHOf/g+GeJyPVeklBhOGcyiD8d4/BdAcMk/4qy8uQZVU4kLTsE8nNIV4mJORKfamhNnOAylnghxvU+E5O3fbD/poneu+XCBOpRSIsShnjRu11hS9efFZe7LlCTFN85UTANneMs97Hs/CN17xEWWlupdlTgWNgk+0Yec4S3mECEOCEauSlymOV6Sc6VKX90eB3WHEOccTinVXiUuY1eGimWWVYY6qEiJsslhc5x0uwHXypQJAbq9gESIQz1xhbjqrlDpUYlr4LuVOFdQC/WoxLHZd7CKoRIHBDVXJe6I2Tn6xCKHirKLvNkl1DPDYRDiVBreaqsSd3jtYUlSgkpklnSBnP+uKhtSaRhGwK9MKRHiUE9cwymrW4krDXGllbjamBRb28oubOLiCnTFecV8AhtErAVWRWRESpKiUqNlKuHHKxBsXJW4LHOsihUiqTTYITgUHC+Q48Q+aZJkky2oPtTNS3X+Gygf4s70g/iUdc5F7pLkXCCvkwplsph0cNVB9yqULtkHs1WYWSiz1azGKqxwrUDBuwzUiybtToS47UflsDuqaF26sEl8mTlxuSm5Prd8e/mNvsv+3bAbshedfPlbBJaolNLqm9lhVlR6lBd7A8AbXIEt3xSlfJPzQ53yi50gsLkqUeGKUMiJIO86FgxcH7iXD3GFmYXOvXVrKHWdc6ESV4iLlqE2/dpIkjb+v40ebV1VuMbnN5ZVvvW+sTYR4lAv4lrGyRphlb3Irsw9mVW2d82Ji2uUpai4XMlkyFHiUP5R3/pEs7JKXNm/s81A8IgpN4SSIZVA8HH9jso3RyrPHOVxDMHBFdgiFa1IRXscCwblh1OGyeTeGKCmQyoNw6hQiZOkC4ZeIEn67X+/eXzI716Z8oKEGj2fvyDEoV6YLWY1Ps85L27te2tVUnjy/eJKikrc/9DjGmfKYnUoKtb5SaavzYtzL2wSVfrpktliyBpu9TiPwBddbjETFjcBgo+rEpdninRX4hhOGVyCOcQZhlFmdUpnxKiNveIy92SqMLNQFhlqWibEnXfjeQqLDVPm3kxtmbXFfTx9U7okKeFCQhxw5l416dymMyVJP7/8s95KfkybZmyqdHhk9oFsSZI11KbIGOcvP19d3MS9sEmUZ1gLiXIOoSDEBQ8qcQBcQyfzTVHKM0V5HENwKF2dMVpRcv4e8MU5/XWhOKdYJQXOkBVVJmKc6QqVripcU5XIUuZ4SOR9uiDbGdg+v/1zLTCNVklRSWkljhAH1I5efZfpxtu+UkxstrKOx+uLO7/Qe93eq7B3XNntBUwndmj01b3iKtsnTpJCo0Mlsc1AMIk+FHvKrwEEPnclzhypfDOVuGBUWomLUqSiPI4FOtfrDJVJoWW22D7TFSpdK1OWHUrp8icd18Vyfvi/SnH6oPsHytiZIYnhlECtMZsNXdR9vR7615u65rrvFRpepNT1qfpu4GPS5NJ/7GW3F3Dx+UpcZOUhjkpc8HBV3goanqgeU4kDgorhMJR/rHRhkzyGUwYl1+qMkYpWVJANpyxd1MTkcfxMK3HlFzUpK0SGrtMx3a5URcqutI1pMhyGIptEKjoxukbP5y8Icah3IaE2XdHnR93/2HuSpH27W6ogL8J93r2oSeNM9zFfDXHuOXHlK3FRJ0IcC5sEDVdoS7nY+YkhwymB4FJwvECG3TlFIL/MnDiGUwaXyubEuYJdoCu/qInLmVTiTraoSXnnqkAP6JDOkfNetziSJpN5yGk/nz8hxMFrGiUcU9OkNBkOs3ZubeM+nr3fWRaP94NKnHs4ZaTnsEkqccHHtbBJysWHPL4GEBxcq1AWKkx2k0X5rE4ZlMrOiQu2hU3KL2riciZ7xWUfyFb+0XyZrWYlnCLEOZ/HriE6qGHarxuVetrP5W8IcfCqczvtkCTt+O0897Gy2wu4+OycuLzKK3GuhU2YExccDMNwV95SuzkrcQynBIKLe4+4E3PhGE4ZnMpW4oJtOGVpgD1JiKvBAi+uKlyTDk3cWxWciklSKxUoQlXvSezvCHHwqvM6bZck7draRvZi58bYpXPiMt3tfL4SF8WcuGBWlFWk0Hzn//OUEyEuIiPyjDY2BeBfXMMmXatS5rM6ZdCx2+zuyqvHFgNpuZWuxh1oXMNGyw+nPJM5ce6hlF2SzrB3gYcQB686q+UhRcXkqqgwXPtW7JPhMJR1wBniKhtOmZeWJ0eJ73y6whYDkEp/MRU0KFBuco5s4c7vi5quxAXA/7grca65cCcqcrY8Gx/oBIm8dGeIMcmkCEUq4sTqlIa9dNGbQFbVnLjC44Wn3Ce4Mu4Q15UQVx4hDl5lMhtq29E5pHL719uVk5Ijh80hk8XkDm6SFBmbJ5PFJMNhuH9I+oLSzb5PUoljYZOg4Apxuck5kunEf+V7lWMAdcddiTsR3ooUJvuJt1kMqQwOZYdSmmSSRRaFy/n9EAwf6pWuTukZL8JlkiXM4tGmMju+3aE5Q+boh7E/aM+SPbIV2JSylkrcyVRneClQp87ruEMbVnbRjm92qONtHSVJsc1iZbaUVtzMZkPRidHKOZSjnMM5ikn2jflGpcMpWdgkmGUfci7Gk3OW87+5Z+WowR8N3ccBBL7SSpyz+iKTSXmmKMUaOco7kqe4FnFe7B3qQ9kQ5xKlaBUqX7mpuQG/b9nJFjYxyaSY5Bhl7slUbkquGrRu4HE+Lz1P8xMmaHOZxy1/brnMIWbnB/tmkxIvTKz7F+BnqMTB684+f7cs1hJl7snUzu92SpLiW8ZXaOcKbr5S3TAMo3Rhk/KVuCg2+w4mHpU4STlU4oCg497o+8RwSql0aCWVuOBQdmVKl2BZodJhd7i/z8tX4iQpJqniezjDMLTx/23U5PaTtVlmmWSoqxzqJIdiZMhhc36Yn+SwKSTqn/XwKvwLlTh4XWiYTWef94d2bjlX695fJ0mKa1nxE0tfC3ElBSXSiXnKFfaJoxIXVHIOnQhtZ50Icycqcq7jAAKfa0EL19YCzr9HSg62GQgWpZW40u+BYFmhMv9IvgyHIZPZpEiHqcJ593u4E8Mp7Ta75gyZo62zt0qSEmToRtmVfKK9Iem4CnRIFjWrYmuBYEWIg084t+MO7dxyrnu+W2XDTnwtxJWd71Z+nzi2GAgu5StxzIkDgo9rTlx+mUpcHitUBpXKhlMGSyXO/dqbRMqcVjHERSc570PO4RzZbXZ9Hvq8tkmySOolky5TiSxl2pskNZRDDYNgq4CaYjglfMK5JxY3cfGHSlzpRt8hMpk9lw6mEhdcGE4JgOGUcC2xH4zDKd0rUyZGV3re9R4u+0C2vrjrC3eAGyyTrpDJI8Cheghx8AmxDbI9Vh7yhzlxpYuahFQ4R4gLLqXDKUsXNil7HMGjpKhEy/+zXEd/P+rtrqAeGYZRphJXOpTOtVIllbjgcLKFTcqeC1TulSlPEuJclbjNn2zWlk+3yCzpVpnURhWrdqgeQhx8xrk3nOv+uz9U4tx7xJ0IbGW5FjZhi4HAZzgM9y+vyipxhhH4G7yi1OXvr9YPT/6g0Q/NlUkF3u4O6klxbrHsRXZJpcFNKg10VOKCA8MpSxcwKc/1Hs5wGDJbzfqzTDqXAHdGCHHwGefdeJ7zLyY/mRPn2iOushBHJS5o5KXnybAbcpgdyktwftruCnO2fJuKsoq82T3Us5bLDkiSmv98WGab3cu9QX1xhTRrhFU2U+nvBIZTBpdgXp3S/doToyo936DvLEnOuW6DSiw6nwB3xghx8BmJG5N11c1LdO0d3ynk04rByBXi8o/ky17s/TdHpdsLVOxrsC5skroxVcf3HPd2N+qV60OFvIQ8GVbnBOySSJsK4ws8ziPwGYahlisOSpJC821KWp/u5R6hvrhWn4xq4vkG1lWVY3XKwFecW+z+4Lay4ZSFxwtVUhi4qyy65gOebDhlQ5k1SCG6W6Fqzwy4WsHqlPAZJpPU68blJz0f0SjCvfFjbmqu1zdOpRLnKXNvpj645ANFJUTp4T0Py2wJjs+Iyi9q4j6enKPwzAjlHM5Rk/ZNvNE11LPju48rOq107lOLHw9Kl5ztxR6hvrjmvEU2iZSyS4/nszpl0MhNc1aiQiJDFJJf+r4gTOGyhFpkL7YrNy230jn//shhd+jwL4e1a8Eu7V6wW4dWH5J08hAnSR0Jb7UqON5lISCYTKZKN4v0FleVrdKFTU5U5xwlDp+oGtaHN+f2k73YruwD2XphTUtvd6feZB9yLWaS7XHctbiJ6zwC3/4f93t83eLHg17qCeqba7hkhUrcieGUhccLZWd4bUAruzqjqcxQQZNM7mDjq0Mqf//yd22YvkGGo3pzuHfM3aE3znlDH/b4UMvGLdPBlQdlOAwlKUStB/9Yx72FC5U4+JWY5Bhl7c/yiRB3qkpc2WBXnFusiIYR9dYvbzHmtXH/3TGvrdTDi52pR67vxZxylTj2igs+rhC398pmarX8oFr8eEiGYchkYu5HoHNX4hpHehwvMEU4JwEZUsGxglNWKeDfPJbY/8PzXHRitLL2Z/lkiFtn+ljfaKckacfdP+qmnPsrfV8jOV/j/Ifna8usLZKkMJl1tiJ1jixqozDFuWMFH1jUBypx8CvVWdzEMAzZ8ut+LtqpQpwlxCJLmMWjXSArKSyR8UNr99dlA12gc20j4Kq8uY+fqMyxzUDw2L/CGeJWP9xNJWEWRR3J17Edx7zcK9QHVyUusolniDNMZkU2YpuBYHCqfdJ8tRK3/ZvtmnsiwEnSNh3Th5d9WGFuuy3fprXvrdXkdpO1ZdYWmSRdpgYarbN1q5LVVVFlAhzqCyEOfiU62fmD8GRD1EqKSjT96umadNYkHVh5oE774lrYpLLhlFJwbTOwd9leqSBEanRi8v6vZ7nnBwS6k82JoxIXXPLS83RsxzEZJmnP1S106BLnvpflh1giMJ0sxEml1blgWqHywM8H9NltnynrQJa3u1JvTrU6o+uYL4W4Az8f0Ge3fiZDUmcl6B5dqCiFKP23dL1/8fvaMnuLVr2+Sv/r9z+91PAlzf3rXBVmFiqpa5LuUwv9SU0USozwKu4+/MdnJjXMfVaStOndecp5v+JeJItuv1H7lu1TYWahZt3wep2+gT5VJa7s8WCoxO38zvlJnunmbdJFKZKk3Qt2e7NL9YbhlJCk/T85w1p6xyYqbBCufVc0kyQd+LFuP0yCb3BV2crPiZNKg12wVOL+YTL0/uXfaMusLZrQYon+ESSjiX21Epe5L1PL/7Ncm/63SakbUlVSWKIjW4/o4+s/VklhidqqoW5QWzVXrO7XRUrulqyCYwX67NbPtGDUAu1euFv2IrviFKK+StS9axsqSeH1/jpQEbVP+JWLrlmvdd931ZGDTfXpy4N1910lsoY7v423zdmmNV90lyTFNslS9pE4zRo0S8OWDpM1rPa/1d2bfVeyxYAUXNsM7Jq3S5Jkum6nlJAnY32Sds3bpQuHXujlntW90uGUntXhnBPDKxlOGRxcQyn39zzrxH+dIW7fin1e6xPqj2sLgcoqca5gFyzbDFj0hyw6IkkK0WYVqbekWO92qh6caol91zFXm/qSuTdTU6+cquwDpb+fTGaTLGEWlRSUqNmlzfTnVS1kPrEQS6zCdPevZ+k7Fes3HVMLxaiN4tVWoWqsMI8FW+B9VOLgV8IiijV4zEyFRxXo0M5mmvvAXBmGoeN7juure76SJPW49ScNmzhd4dEFOrjqoL4b+Z0Mo3orLp0Of67EbZm1RR/2+FBHth4542tl7M5Qxs4MyWqXqfcema91VuV2L9wth91xxtf3ZSVFJe43ZietxKXkVHvFL/gv17BJV3g72CNZhsm57UBOCkE+0J1sdUqpNNgFy3DKUK2WJBmSTHK4vw501anE1efPgqwDWZre+n1lH8hWvCLVQo0UrhAZDkMlBSVqrEjdvupshZRb9j9EZg3UOfq3LtZQtdNlSlIThRPgfBAhDn6nYVKG/u+R2TKZHNo4faN+fvlnfT74cxVlFalZuwPqPXyxGp6VoUFPfiaT2aT1H6zX2nfX1no//DXEfZEWrTn3/U8HVx3U9Pse1zfGmf1gdlfheu6XKbZI6n5Iii9QQUaBDq05VBtd9lm5Kc5f2pYwiwobFnieS8yVTJJhN5SXHhzDqCTn3kElRYG7oW1livOKlbLOOYzYFeIK48OV1sm5P+CBnxhSGeg89okrJ5iGUx7dflQh2ilDUpH6SZJCtVZFOUW1cv2M3Rk+O8/uVCHOtT1SXQynrOxD6pyUHH10zUfKVL4aKEp/UU/9RT01RtdqtHrqbnXRcHVTpCqf0y+J0OYHGE4Jv3TOhX+o77CFWjCtv77/5/eSpPD4cA168nNZrM7qT5uLd6v3+N76/p/fa95D82QvtqvLvV0UEnnyH1qn41T7xEm+u7DJoSf6yJHtHM+e93MLZXzcSRpS8+u5Q9y1J/5rdcjUd7eMWR2187udat6j+Rn32Ve55rvFJMeo/O87w+pQdEK0clNzlXM4JyiWFi/MLNS0XtNUkFGgu5ffrQatG3i7S/Xi0OpDMuyG4lrEKatF6bCx/Vc0U+KmI9r/4361/7/2Xuwh6lJJUYmKc5w/58tvMSCVGU4ZBJW41a87q24lOk/F6q4Q/SqLjmn9f9fr0ocvPaNrb5m9RXPumCPDMNT57s7qNbaX4lrE1Ua3z5jhMNyLeUUnRqv8GJSyc+Jqsu2IYRjKTcnVsR3HdGznMR3bcUwZOzJ0bMcxHf/juCIaRuis7mfprO5nKbFzohb+Y6EydmUoXpEapssUK+c2RyaZFKMwxSjsjF8zvI8QB7/V/bpVStPj2jBtgyRp4NSBio993KPNZb16KrXvIG1e2EnzH56v5U9/rkseGaCLR1zsXva5pvyxEndw9UEdm3qRJKnBn7fo+OwOOjTmTyoeWHzS13EqtgKb9izZI0kyXVu6TLHp2l0yZnXUrnm7dM1z15xRn4//cVzb5mzThcMurHSokje5QlzsWZXP94g5K8Yd4pK6JNVn1+qdYRgaet9/1GGT89fKmMGvasqKp2UJtVTxSP/nmvfWomcLj+P7ezbTJZPXu+fLITC5wpnZalZ4fMUFH3x5dcrctFx9c+83ij87Xn1f6StLSM3/vRZkFGjj9I2SpGJ1l2RSsS5VhL7V6tdW65IRl8hsrdkAsE3/26Qv7vpSzkGa0voP12vT/9ukrn/tqiv+dUWNPiQzDEN5aXk6tvOYsvZlyVZgk73IrpKiEjlsDjU6r5FaX9Na4XFVL+JRcLxADpszukU1jVL5QZNRCc7fXfYiu4qyiip8n9iL7Tqw8oD++P4P5RzMka3AppKCEtkKbMo/kq9jO4+dcn59bmqutn+1Xdu/2u4+FtssVkMPXqI4ndl7HfguQhz8lskkDbh5kKLyrlajZkd1fvi4Stvc9PQXatF5n1bOuEzHDzXU0qeX6qeXflLTTk1ltphlMptkMpsUkxyj8285X+cOOLda1TpXhc3XFjZxlDi09fOtSrggQU3aNXEfNxyG5j00T5LUaNgGtZgyV3lrk1T8R0OteGGFer/Qu7StYTj3gjGb1P7/2p/0U8N9y/appLBEsc1ildcx3X3c1N9ZlUtZm6LctFxFJ9SsCnXPbwk6q89QWdOj9e2HH+vg9x9p+lmVby/hDa6tLlz7F5YXkxyjlLUpJ90SI5D8OuVXdfjMKrvVkC1KarbGosX/Xqy+L/f1dtfqnGsFyuY9PavOrqGVqRtSVZRTpLCY4Pj02zAM2YvtdbKglC8qu9F3ZT8rfXU4ZW5arp5LnK5IHZUkffdGjl4rGlTjD17WfbBOtnyb7EqQXa0kSTZdqDD9oMy9mdr2xTZ1+HOHGl33m/u/kSRFqrMidZGy9YOKi/dqzZtrtO79dep0Zyd1f6i7Ei5IcD/OcBg69Msh7fhmh3IO5zhDUb7NHYwydmVU+SGryWJS8x7NdU6/c9T88uaKbRarmOSYCr/3XcMkIxpGVPp9HxIRorC4MBVlFSk3NVcmi0npm9OVsjZFfyz6Q3uW7Km6LzIpXjFqpDg1VJwaKU6NFKWGilWO8nVQR3RIKTqkDFll1u0HL1MDKm4BLTh+wp6GyZMn6+WXX1ZqaqouvPBCvfnmm7rkkku83S2chDXUrj73fH/KNharQxcP+lVdB67T1h/a6af/11Op25N0aHXF+VqbZ25WSFSIzrvhPLW/tb1aXtnypBU7X6zEpW1K01d/+Uop61JkDjHryqeuVM/He8oSYtGGaRt0+JfDMscU6awXv5c5vETNX12g3QNv18qJK3XRPRepYZuGyk3N1Vf3fOUeJtnyypa6/t3r1fj8xhWeb+c8Z/WtzbVttKnMexdTYq6SuiQpZV2Kdi/YXaNVKg+vPaxmfe+WJcN5/0N/b6Jmvf6izMWZim8Zf/o3pw64KnGu/QvLq87m9IEgdWOqFjyyQJL0/UvFOn62Q4NvjtDKV1aq9dWt1fa6tl7uYd1xlDjce1K2vKKlx7nsZjGKbxWvzL2ZOrjqoM750zne6GK9Slmfom/u+0ZHthzRFU9eocvHXH5G1R1/cKqVKSXfXJ0yNy1XH13zkSJ1VMWKklWFaqxtmvV/s/Tn2X8+7QBut9m15s01kqRiXarS8eUhsqmbwrRcKyeu9PhQ0FHi0JGtR3T418M69MshHf7lsHIO56hJ+yZK7JyoxM6Jyj6UrcWPL5YkRamb4nSdTDKpiYbJrj90XD+oqPCg1n+wXus/WK+WvVrqwqEXKmV9in7/4vdqrA5sUoTiFKEGsihUJllklUUmmZSpQ8qzH9P+H/dX2O8xLC5MMckxikmOUexZsbLb7JIqnw/nEp0YraKsIk3rNa3SedKRitTZaqkmaqIQWRUqQ1ZZFa4wNVK8GihcFpX/t+R8f9FAMWqhBOlEeC5/HoGJEFfGp59+qtGjR2vKlCnq3r27XnvtNfXr10/bt29X06ZNvd09nCGz1aGOf9qiDtdt0aHfmikvI0qGYZJhNsnhMCllS7K2zO+gzEMNtHnmZm2euVmS1OCcBmrWvZl7rHmTDk0U2SiyyhDnqsTVZE6cvdiu1I2pOvDzAR1ec1jFucWyhFlkDbPKEmZRZONINevRTC0ub6HIxpGy2+z6cfyPWv78cjlsDpnCSuQosmrp2KXa/uV29X+9v75/3Bl2k59eqpBE56eGcTdsV2y/Xcpe0EYLRi9Q57901jf3faOCYwUyhZVIFof2Ld+ndy54Rz2f6KkrnrjCvaWDVDofrs21bbSp3Gtoc20bpaxL0c7vdlYIcSWFJTrw8wHtWbJH+3/cr5ikGLX7v3Zqe21bhUSG6MDKA5px7QxZsiJV0P2g0qfMVdKgWxW6u6GmXTlNQxcPVcM2DU9+/2x25aXlKSQyRKExoXX2JtL1BuFUwynLtvMlhsO54Epkk0iZLTVf46o4t1if3fqZ7EV27RhQopWP2CSTtPqhYnV/M1RfDP1CD2x4QLHNarbEeG5qrrZ9sU0HfjygJh2bqP2g9mp0bqMa97e2pW5IlS3PpvD4cDVp30RSocf5Fj1bKHNvpvav2F/vIc5wGHLYHZV+/xuGocw9mUr7LU2xzWKVeGFijYe6Sc6h1cueWaYVL/8s84nVWH948gdtnbVVN354o5K7Jdf42r7uVCtTSmVWpzyaL8NhyGSunwUjivOKdeCnA8o6kKWECxKUcEGCrGFWd4A7svWIihSjTRqmcB1Xe32qHd/s0Kc3fapb59yqkIiKI1IcdodyU3OVfTBbZqtZEQ0jFNkoUju/26nsg9mKahql7PSOnv3QJYoM+0mHVh/Sjy/+qLz0PB3+5bBS16fKll9xpEpuSq72LN7jcazHP3po38Q/eSy2EaGzFa7WKtIBZWu18i3btG/ZPu1bVrqth1mhitO5ilSCzApRiKwyK0RWhStcDdVI8TKXeytc9jd6vo4rW7uVqt3K1hEVKFslsqkoq0hFWUU6uu2ox2NdP/PLyzNJ8WqkYzrmDnDRilZTNVELtdDZOltJauTx+izlfpYQyFCeyaiLtdf9VPfu3XXxxRfrrbfekiQ5HA41b95cDz30kB5//PFTPjY7O1txcXHKkhRb2Xv68sfKf1hT2WPK/z4o36aqa9bX81bnutXpm7eet8zXhiEd2nmWtsztqJ0/tNWxPypWnyTnJ2qu4ROjD49WZJznG1RLpKEV41doyb+WqNVVrdT1r13dwzYLMwuVfShb2QezlXMwRwXHC2Qym9xDO0uKSpS2MU0lhdVb4a/ReY1kMpl09HfnL5NGN/6utlPmKvOH1to18jqVHI/waNti0yiZQ+3uY4W/N9a2Tn+Xo6R0KnZo5xQ1/d8cmaJsOjriOhV8d64kKbZ5rJK6JCmuRZzCG4Rr+bPLZbaaNebYGL0S6znG/66f9mlqz6kKjw/XlWOvVF5anvLS8pS5N1MHVh6Qvciu8kIiQ9SmfxvtXrhbxbnFKrhinw59O0NGTLEsh2LU7JphCt3RWNFJ0er1dC9Zw62yhFhkDjErNzVXqRtSlbYhTemb02UvLr2+NcKqsNgwRTWJUkxyjKKTohWdFK2IBhEKiQyRNcKqkIgQWcIspzXhfNkzy5S2KU23zLhFl9xxQYXzP324Vt/c+42SuyWr5xM9q33dmjAchgoyCpR/NF95R/JUcNT5fRXZJFKRjSMV2SRShsNQ2sY0533amKbi3GJZI6xKuCDB/cl3RMMIOUocstvsctgc7jedJovJ4/vUdWzrrK3a+tlWxZwVo6c2pCj/xD8ZS5H09mVtlbIuRS16ttClj5QuamAYziWui3OLVZxXrOLcYplMJoVEhSg0KlSh0aHKS8/TtjnbtP/nAzKV+y3VpEMTtRvUTgkXJHj8/3LYHbIX2WUvLp3XYg4xyxJa+gHImQTWyuxeuFtr312rtgPa6o65d8gkz1VKf3l3i7594FsldUnSFf++4oyey/X6SopKZC+2u1+f67VZQizK3JepI1uOKH1zuo5uO+oc7tw8Vg3ObqAG5zRQeHy40jel6/Cvh1WQUdrX0JhQtbi8hVpc0ULRidGlP6MO5agoq0iRjSMVlRDl/NM0SiERITKHmGW2mmUvsmvFCyucW41I2nxhB/3RtrX6fLdYkfnO78PuD3evMGewKq4PY3IO5yg3JVe5abkKiQxRdFK0YpKc/47D48NPe5GI2rZz3k6t/2C9OtzWQf838/9kKreejy21RP8J/48k6eb/d/MZLa5lK7Apa1+WMvdmKnNvprIPZiuyUaTiW8UrrlWc4lvGK/tQtvYs3qODqw6652lJkjnErMQLE1VwvEDHdx9XzFkxWnJomArl/FAkTnvUNfIT2fJtSrggQfGt4t0/B2wFNuUcylH2wWyP3xXl9Xq6l7555qqKx+/9Wus/WF/huKFQSckKUbLMSpZJcTJ0RFKq7EqVQ8cUposVpisVXW71qPK/yk3KUqZ+VZ52KUyJilE7NdXZHiGtNt6aSEUqUI4KlKN8ZatAOSpSjopUqPPVTQlqXulbk2xlaZ92K04NlKwGiiw3V80sz9/51Qtx5Y+VX/2yssdU1aayx5SvHPrq81anTXWet/xjyn/YUI3nNfaVZoOsLMXG1v5eiYS4E4qLixUZGanPPvtMN910k/v4sGHDlJmZqa+++sqjfVFRkYqKSpfMzcrKUosWLXRAUmxlP59PN7BIqjAXtapQU9mHgHXxvJW9vvI/scq3qewnZfk25ftW/nxNAmd17kn5r8u8/oLsMKVsTtbhLUlK2ZSsIzuaKOtw6WpYIZE2/X3ja7JEewYSS2SW1r6/VgsfXVhJB6onrEGBGnU7rEaXHFJ40zw5iqwqKDbLUWxRwb54ZaxqppztpSEzpEGB2k1YpJg/b5XrPU1RapR2PXytjs9vI0k6b86niuy9p8Jzhfx7jta85RwKc+moS5X671tkCnX+ojYMKeOr85Q75k9ypFX8H9myZ0vd8e0delmeq4T9o+S4Xj/ndRVmlv9FdEJCrop67ZXt8gOy7GqosK/Ok3l/vPt0q16ttOSTkVJU6S82c3qkLr7xOR3ZVo397cyG5KifN3dDvhuibpd3qnB85ffrNGvQrHrpgzeZTCbd8d0d6nTZex7H9+weralXTj3jIcWHu4Zq79XhSlxfrFZLC2WumP+97qqnr1KP0T0UVy7E7f49T+93f99LvTo1u8WiY80aKe5IlsLyz3wJ+JjEGE3t3U+72jmHz0bk5um93Yu1ZfaWM762P+j2127604Q/Ka5cVs3aL73a4lUVZp3kZ2EdKlSs8tVQMUpTSJnvzSLFaKPukF2eIxqaar9aa7bMp6z6mGRXjCRDZhXIdCJ8GIrQEd2riEp+4YcpUyH6XFKIHEqSWYmSkiU1lGTy67cmlfWl6s+kK97fqkNcZfPry1+nqtBTnTaVPab8UOC6eN7KXl/5x1QnTFXVpvz56vS1/GMqm99a7jpZW5Sdna3mzZsrMzNTcXG1v5IqIe6Ew4cP66yzztLPP/+sHj16uI+PGTNGy5Yt0+rVnptVjhs3Ts8880x9dxMAAACAn9i9e7fOPvvsWr8uc+Jq6IknntDo0aPdX2dmZqply5bav39/naTtYOX6FOPAgQN1UooOVtzXusF9rTvc27rBfa0b3Ne6wX2tG9zXuuEapdew4cnn8J8JQtwJjRs3lsViUVpamsfxtLQ0JSYmVmgfFhamsLCKS7fGxcXxD6AOxMbGcl/rAPe1bnBf6w73tm5wX+sG97VucF/rBve1bpjNtTsX233dOrmqHwoNDVXXrl21ePFi9zGHw6HFixd7DK8EAAAAAG+iElfG6NGjNWzYMHXr1k2XXHKJXnvtNeXl5ekvf/mLt7sGAAAAAJIIcR5uu+02HTlyRGPHjlVqaqo6d+6s+fPnKyEhocrHhoWF6emnn650iCVqjvtaN7ivdYP7Wne4t3WD+1o3uK91g/taN7ivdaOu7yurUwIAAACAH2FOHAAAAAD4EUIcAAAAAPgRQhwAAAAA+BFCHAAAAAD4EUJcLZk8ebJatWql8PBwde/eXWvWrPF2l/zK+PHjdfHFFysmJkZNmzbVTTfdpO3bt3u0KSws1IgRI9SoUSNFR0dr0KBBFTZnx8m9+OKLMplMGjVqlPsY97TmDh06pDvvvFONGjVSRESEOnXqpF9//dV93jAMjR07VklJSYqIiFCfPn20c+dOL/bY99ntdj311FNq3bq1IiIidM455+i5555T2fW3uK9VW758uW644QYlJyfLZDLpyy+/9DhfnXuYkZGhIUOGKDY2VvHx8Ro+fLhyc3Pr8VX4nlPdV5vNpn/+85/q1KmToqKilJycrKFDh+rw4cMe1+C+VlTV92tZDzzwgEwmk1577TWP49zXiqpzX7dt26Ybb7xRcXFxioqK0sUXX6z9+/e7z/MeoaKq7mtubq5GjhypZs2aKSIiQu3bt9eUKVM82tTWfSXE1YJPP/1Uo0eP1tNPP61169bpwgsvVL9+/ZSenu7trvmNZcuWacSIEVq1apUWLVokm82mvn37Ki8vz93mkUce0TfffKPZs2dr2bJlOnz4sG655RYv9tp//PLLL3r33Xd1wQUXeBznntbM8ePHdfnllyskJETz5s3T1q1bNXHiRDVo0MDdZsKECXrjjTc0ZcoUrV69WlFRUerXr58KCwu92HPf9tJLL+mdd97RW2+9pW3btumll17ShAkT9Oabb7rbcF+rlpeXpwsvvFCTJ0+u9Hx17uGQIUO0ZcsWLVq0SHPnztXy5ct1//3319dL8Emnuq/5+flat26dnnrqKa1bt05z5szR9u3bdeONN3q0475WVNX3q8sXX3yhVatWKTk5ucI57mtFVd3X3bt3q2fPnjr//PO1dOlSbdq0SU899ZTCw8PdbXiPUFFV93X06NGaP3++/ve//2nbtm0aNWqURo4cqa+//trdptbuq4EzdskllxgjRoxwf223243k5GRj/PjxXuyVf0tPTzckGcuWLTMMwzAyMzONkJAQY/bs2e4227ZtMyQZK1eu9FY3/UJOTo7Rtm1bY9GiRUavXr2Mhx9+2DAM7umZ+Oc//2n07NnzpOcdDoeRmJhovPzyy+5jmZmZRlhYmPHJJ5/URxf90oABA4x77rnH49gtt9xiDBkyxDAM7mtNSDK++OIL99fVuYdbt241JBm//PKLu828efMMk8lkHDp0qN767svK39fKrFmzxpBk7Nu3zzAM7mt1nOy+Hjx40DjrrLOMzZs3Gy1btjReffVV9znua9Uqu6+33Xabceedd570MbxHqFpl97VDhw7Gs88+63GsS5cuxr///W/DMGr3vlKJO0PFxcVau3at+vTp4z5mNpvVp08frVy50os9829ZWVmSpIYNG0qS1q5dK5vN5nGfzz//fLVo0YL7XIURI0ZowIABHvdO4p6eia+//lrdunXTn//8ZzVt2lQXXXSR3n//fff5PXv2KDU11ePexsXFqXv37tzbU7jsssu0ePFi7dixQ5K0ceNG/fjjj7r22mslcV9rQ3Xu4cqVKxUfH69u3bq52/Tp00dms1mrV6+u9z77q6ysLJlMJsXHx0vivtaUw+HQXXfdpccee0wdOnSocJ77evocDoe+/fZbnXvuuerXr5+aNm2q7t27ewwN5D1CzVx22WX6+uuvdejQIRmGoR9++EE7duxQ3759JdXufSXEnaGjR4/KbrcrISHB43hCQoJSU1O91Cv/5nA4NGrUKF1++eXq2LGjJCk1NVWhoaHuX4Yu3OdTmzlzptatW6fx48dXOMc9rbk//vhD77zzjtq2basFCxbowQcf1N///ndNnz5dktz3j58Lp+fxxx/X4MGDdf755yskJEQXXXSRRo0apSFDhkjivtaG6tzD1NRUNW3a1OO81WpVw4YNuc/VVFhYqH/+85+6/fbbFRsbK4n7WlMvvfSSrFar/v73v1d6nvt6+tLT05Wbm6sXX3xR/fv318KFC3XzzTfrlltu0bJlyyTxHqGm3nzzTbVv317NmjVTaGio+vfvr8mTJ+vKK6+UVLv31VpbnQZqy4gRI7R582b9+OOP3u6KXztw4IAefvhhLVq0yGOMO86cw+FQt27d9MILL0iSLrroIm3evFlTpkzRsGHDvNw7/zVr1izNmDFDH3/8sTp06KANGzZo1KhRSk5O5r7Cb9hsNt16660yDEPvvPOOt7vj19auXavXX39d69atk8lk8nZ3AobD4ZAkDRw4UI888ogkqXPnzvr55581ZcoU9erVy5vd82tvvvmmVq1apa+//lotW7bU8uXLNWLECCUnJ1cYEXWmqMSdocaNG8tisVRYVSYtLU2JiYle6pX/GjlypObOnasffvhBzZo1cx9PTExUcXGxMjMzPdpzn09u7dq1Sk9PV5cuXWS1WmW1WrVs2TK98cYbslqtSkhI4J7WUFJSktq3b+9xrF27du5VvVz3j58Lp+exxx5zV+M6deqku+66S4888oi7ksx9PXPVuYeJiYkVFuYqKSlRRkYG97kKrgC3b98+LVq0yF2Fk7ivNbFixQqlp6erRYsW7t9j+/bt0z/+8Q+1atVKEve1Jho3biyr1Vrl7zHeI5yegoIC/etf/9KkSZN0ww036IILLtDIkSN122236ZVXXpFUu/eVEHeGQkND1bVrVy1evNh9zOFwaPHixerRo4cXe+ZfDMPQyJEj9cUXX2jJkiVq3bq1x/muXbsqJCTE4z5v375d+/fv5z6fRO/evfXbb79pw4YN7j/dunXTkCFD3H/nntbM5ZdfXmELjB07dqhly5aSpNatWysxMdHj3mZnZ2v16tXc21PIz8+X2ez5a8lisbg/Nea+nrnq3MMePXooMzNTa9eudbdZsmSJHA6HunfvXu999heuALdz5059//33atSokcd57uvpu+uuu7Rp0yaP32PJycl67LHHtGDBAknc15oIDQ3VxRdffMrfY7zvOn02m002m+2Uv8dq9b7WYDEWlDNz5kwjLCzMmDZtmrF161bj/vvvN+Lj443U1FRvd81vPPjgg0ZcXJyxdOlSIyUlxf0nPz/f3eaBBx4wWrRoYSxZssT49ddfjR49ehg9evTwYq/9T9nVKQ2De1pTa9asMaxWq/Gf//zH2LlzpzFjxgwjMjLS+N///udu8+KLLxrx8fHGV199ZWzatMkYOHCg0bp1a6OgoMCLPfdtw4YNM8466yxj7ty5xp49e4w5c+YYjRs3NsaMGeNuw32tWk5OjrF+/Xpj/fr1hiRj0qRJxvr1692rJFbnHvbv39+46KKLjNWrVxs//vij0bZtW+P222/31kvyCae6r8XFxcaNN95oNGvWzNiwYYPH77GioiL3NbivFVX1/Vpe+dUpDYP7Wpmq7uucOXOMkJAQ47333jN27txpvPnmm4bFYjFWrFjhvgbvESqq6r726tXL6NChg/HDDz8Yf/zxhzF16lQjPDzcePvtt93XqK37SoirJW+++abRokULIzQ01LjkkkuMVatWebtLfkVSpX+mTp3qblNQUGD87W9/Mxo0aGBERkYaN998s5GSkuK9Tvuh8iGOe1pz33zzjdGxY0cjLCzMOP/884333nvP47zD4TCeeuopIyEhwQgLCzN69+5tbN++3Uu99Q/Z2dnGww8/bLRo0cIIDw83zj77bOPf//63x5tg7mvVfvjhh0p/ng4bNswwjOrdw2PHjhm33367ER0dbcTGxhp/+ctfjJycHC+8Gt9xqvu6Z8+ek/4e++GHH9zX4L5WVNX3a3mVhTjua0XVua8ffvih0aZNGyM8PNy48MILjS+//NLjGrxHqKiq+5qSkmLcfffdRnJyshEeHm6cd955xsSJEw2Hw+G+Rm3dV5NhGMbp1e4AAAAAAN7CnDgAAAAA8COEOAAAAADwI4Q4AAAAAPAjhDgAAAAA8COEOAAAAADwI4Q4AAAAAPAjhDgAAAAA8COEOAAAAADwI4Q4AAB8yFVXXaVRo0Z5uxsAAB9GiAMABIy7775bN910U4XjS5culclkUmZmZp099w033KD+/ftXem7FihUymUzatGlTnT0/ACB4EOIAAKgFw4cP16JFi3Tw4MEK56ZOnapu3brpggsu8ELPAACBhhAHAAg648aNU+fOnT2Ovfbaa2rVqpXHsQ8++EDt2rVTeHi4zj//fL399tsnveb111+vJk2aaNq0aR7Hc3NzNXv2bA0fPlzHjh3T7bffrrPOOkuRkZHq1KmTPvnkk1P21WQy6csvv/Q4Fh8f7/E8Bw4c0K233qr4+Hg1bNhQAwcO1N69e095XQCA/yLEAQBQiRkzZmjs2LH6z3/+o23btumFF17QU089penTp1fa3mq1aujQoZo2bZoMw3Afnz17tux2u26//XYVFhaqa9eu+vbbb7V582bdf//9uuuuu7RmzZoa99Nms6lfv36KiYnRihUr9NNPPyk6Olr9+/dXcXFxja8LAPBdVm93AACA2jR37lxFR0d7HLPb7ad9naeffloTJ07ULbfcIklq3bq1tm7dqnfffVfDhg2r9DH33HOPXn75ZS1btkxXXXWVJOdQykGDBikuLk5xcXF69NFH3e0feughLViwQLNmzdIll1xy2n2UpE8//VQOh0MffPCBTCaT+znj4+O1dOlS9e3bt0bXBQD4LkIcACCgXH311XrnnXc8jq1evVp33nlnta+Rl5en3bt3a/jw4brvvvvcx0tKShQXF3fSx51//vm67LLL9N///ldXXXWVdu3apRUrVujZZ5+V5AyTL7zwgmbNmqVDhw6puLhYRUVFioyMPM1XWWrjxo3atWuXYmJiPI4XFhZq9+7dNb4uAMB3EeIAAAElKipKbdq08ThWfrERs9nsMeRRcg5LdMnNzZUkvf/+++revbtHO4vFcsrnHz58uB566CFNnjxZU6dO1TnnnKNevXpJkl5++WW9/vrreu2119SpUydFRUVp1KhRpxz2aDKZquxr165dNWPGjAqPbdKkySn7CgDwT4Q4AEDQadKkiVJTU2UYhnsI4oYNG9znExISlJycrD/++ENDhgw5rWvfeuutevjhh/Xxxx/ro48+0oMPPuh+jp9++kkDBw50VwUdDod27Nih9u3bn7KvKSkp7q937typ/Px899ddunTRp59+qqZNmyo2Nva0+goA8E8sbAIACDpXXXWVjhw5ogkTJmj37t2aPHmy5s2b59HmmWee0fjx4/XGG29ox44d+u233zR16lRNmjTplNeOjo7WbbfdpieeeEIpKSm6++673efatm2rRYsW6eeff9a2bdv017/+VWlpaae83jXXXKO33npL69ev16+//qoHHnhAISEh7vNDhgxR48aNNXDgQK1YsUJ79uzR0qVL9fe//73S7Q4AAP6PEAcACDrt2rXT22+/rcmTJ+vCCy/UmjVrPBYckaR7771XH3zwgaZOnapOnTqpV69emjZtmlq3bl3l9YcPH67jx4+rX79+Sk5Odh9/8skn1aVLF/Xr109XXXWVEhMTK92cvKyJEyeqefPmuuKKK3THHXfo0Ucf9ZhDFxkZqeXLl6tFixa65ZZb1K5dOw0fPlyFhYVU5gAgQJmM8gPtAQAAAAA+i0ocAAAAAPgRQhwAAAAA+BFCHAAAAAD4EUIcAAAAAPgRQhwAAAAA+BFCHAAAAAD4EUIcAAAAAPgRQhwAAAAA+BFCHAAAAAD4EUIcAAAAAPgRQhwAAAAA+JH/D7NynUYIe76dAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "copyImg = cv2.cvtColor((oriImg * 255).astype(np.uint8), cv2.COLOR_RGB2HSV)\n", + "h_channel = copyImg[:, :, 0]\n", + "\n", + "hist = cv2.calcHist([h_channel], [0], None, [180], [0, 180])\n", + "\n", + "Dominant_hue = np.argmax(hist)\n", + "\n", + "lower_tool = max(0, Dominant_hue - 5)\n", + "upper_tool = min(179, Dominant_hue + 5)\n", + "\n", + "plt.figure(figsize=(10, 5))\n", + "for i in range(180):\n", + " # Normalize the histogram values for display purposes\n", + " plt.bar(i, hist[i][0], color=plt.cm.hsv(i / 180), edgecolor='none', width=1.0)\n", + "\n", + "plt.plot(hist, color='purple')\n", + "plt.title('Hue Histogram')\n", + "plt.xlabel('Hue Value')\n", + "plt.ylabel('Frequency')\n", + "plt.xlim([0, 180]) \n", + "plt.ylim([0, 10000]) \n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0, 9, 4)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lower_tool, upper_tool, Dominant_hue" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mask = cv2.inRange(h_channel, 0, 7)\n", + "plt.imshow(mask, cmap=\"gray\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "copyImg = cv2.cvtColor((oriImg * 255).astype(np.uint8), cv2.COLOR_RGB2HSV)\n", + "\n", + "h = copyImg[:,:,0]\n", + "mask = np.zeros(h.shape, dtype=np.uint8)\n", + "th = (25, 175)\n", + "mask[(h > th[0])] = 1\n", + "\n", + "plt.imshow(mask, cmap=\"gray\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 2, figsize=(20, 8))\n", + "lower_tool = np.array([0, 0, 115])\n", + "upper_tool = np.array([180, 77, 255])\n", + "\n", + "#175, 180; 9, 20\n", + "\n", + "\n", + "\n", + "copyImg = cv2.cvtColor((oriImg * 255).astype(np.uint8), cv2.COLOR_RGB2HSV)\n", + "\n", + "mask = cv2.inRange(copyImg, lower_tool, upper_tool)\n", + "\n", + "kernel = np.ones((5, 5), dtype=np.uint8)\n", + "\n", + "\n", + "mask = cv2.bitwise_not(mask)\n", + "\n", + "copyImg = cv2.cvtColor(copyImg, cv2.COLOR_HSV2RGB)\n", + "resROI = cv2.bitwise_and(copyImg, copyImg, mask=mask)\n", + "\n", + "ax[0].imshow(mask, cmap=\"gray\")\n", + "ax[0].set_title(\"Original Image\")\n", + "ax[0].axis(\"off\")\n", + "\n", + "ax[1].imshow(resROI)\n", + "ax[1].set_title(\"CAM\")\n", + "ax[1].axis(\"off\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pyRARP", + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Video3D/AutoSnippet.py b/Video3D/AutoSnippet.py new file mode 100644 index 0000000..3bda8c2 --- /dev/null +++ b/Video3D/AutoSnippet.py @@ -0,0 +1,140 @@ +import decord +from pathlib import Path +import torch +import cv2 +import numpy as np +from inflateDEMO import I3DResNet50 +import torchvision.transforms as T +import sys +from tqdm import tqdm +import argparse +import ffmpeg + +try: + print (sys.path.index("d:\\Users\\user\\Documents\\postata\\RARP\\Clasification")) +except: + sys.path.append("d:\\Users\\user\\Documents\\postata\\RARP\\Clasification") + +print(sys.path) +from Models import RARP_NVB_ResNet50 + +def seconds_to_hms(seconds): + hours = seconds // 3600 + minutes = (seconds % 3600) // 60 + secs = seconds % 60 + return f'{int(hours)}:{int(minutes):02}:{int(secs):02}' + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + + parser.add_argument("--BaseLib", default="ffmpeg", type=str) + parser.add_argument("-i", "--Input", type=str) + parser.add_argument("-o", "--Output", type=str) + parser.add_argument("-t", "--Target", type=str) + parser.add_argument("-c", "--Chunk", type=int, default=15) + parser.add_argument("-b", "--BaseModel", type=str, default="../log_ResNet50_X10/lightning_logs/version_8/checkpoints/RARP-epoch=5.ckpt") + + args = parser.parse_args() + + + +RN50Model = RARP_NVB_ResNet50.load_from_checkpoint(args.BaseModel) +RN50ModelToEval = RARP_NVB_ResNet50.load_from_checkpoint(args.BaseModel) + +videoPathLong = Path(args.Input) + +decord.bridge.set_bridge('native') +vr = decord.VideoReader(str(videoPathLong.absolute())) + +fps = vr.get_avg_fps() +print (f"FPS:{vr.get_avg_fps()}") +segs = len(vr)/fps +print (f"Video Length: {segs} seg.") +print (f"Video Length: {round(segs*fps)} frames.") +print (f"Chuks of 15 seg: {segs//15} chunks") +print (f"Chuks of 30 seg: {segs//30} chunks") +print (f"Chuks of 35 seg: {segs//35} chunks") +print (f"Chuks of 40 seg: {segs//40} chunks") + +mean, std = ([30.38144216, 42.03988769, 97.8896116], [40.63141752, 44.26910074, 50.29294373]) +transforms = T.Compose([ + T.Resize((256,256), antialias=True, interpolation=T.InterpolationMode.BICUBIC), + T.CenterCrop(224), + T.Normalize(mean, std) +]) + +frameToFind = cv2.imread(str(Path(args.Target)), cv2.IMREAD_COLOR) +#frameToFind = _removeBlackBorder(frameToFind) +frameToFind = torch.Tensor(frameToFind) +frameToFind = frameToFind.permute(2, 0, 1).float() + +frameToFind = transforms(frameToFind) + +frameToFind = frameToFind.repeat(1, 1, 1, 1) + +torch.set_float32_matmul_precision('medium') +torch.backends.cudnn.deterministic = True + +device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + +InfalteModel = I3DResNet50(RN50Model.model).to(device) +InfalteModel.fc = torch.nn.Identity() +InfalteModel.eval() + +RN50ModelToEval.model.fc = torch.nn.Identity() +RN50ModelToEval.to(device) +RN50ModelToEval.eval() + +framesChunk = np.array([15, 30, 35, 40]) * round(fps) + +chunk_size = framesChunk[0] +total_frames = len(vr) + +with torch.no_grad(): + frameToFind = frameToFind.to(device) + + Doutput = RN50ModelToEval(frameToFind) + Doutput = Doutput.squeeze() + + maxSim = 0 + + ListSim = [] + + initFrame = None + + for start_idx in tqdm(range(0, total_frames, chunk_size)): + end_idx = min(start_idx + chunk_size, total_frames) + chunk_frames = vr.get_batch(range(start_idx, end_idx)).asnumpy() + + chunk_frames_bgr = chunk_frames[..., ::-1].copy() + + frames = torch.from_numpy(chunk_frames_bgr).to(device) + frames = frames.permute(0, 3, 1, 2) + frames = frames.float() + + frames = transforms(frames) + + frames = frames.repeat(1, 1, 1, 1, 1) + frames = frames.permute(0, 2, 1, 3, 4) + + outPut = InfalteModel(frames) + outPut = outPut.squeeze() + + #print(outPut.shape, Doutput.shape) + + cos_sim = torch.nn.functional.cosine_similarity(outPut, Doutput, dim=0) + + #maxSim = cos_sim if cos_sim > maxSim else maxSim + if cos_sim > maxSim: + print(cos_sim) + maxSim = cos_sim + initFrame = (start_idx, end_idx) + + + ListSim.append(cos_sim) + +print(seconds_to_hms(initFrame[0]/fps), seconds_to_hms(initFrame[1]/fps)) + +fileVideo = ffmpeg.input(str(videoPathLong.absolute()), hwaccel='cuda') +outPutVideo = ffmpeg.output(fileVideo.trim(start_frame=initFrame[0], end_frame=initFrame[1]), args.Output)#, vcodec='h264_nvenc') +ffmpeg.run(outPutVideo) \ No newline at end of file diff --git a/Video3D/Resnet.txt b/Video3D/Resnet.txt new file mode 100644 index 0000000..42c06cd --- /dev/null +++ b/Video3D/Resnet.txt @@ -0,0 +1,176 @@ +ResNet( + (conv1): Conv3d(3, 64, kernel_size=(3, 7, 7), stride=(1, 2, 2), padding=(1, 3, 3), bias=False) + (bn1): BatchNorm3d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + (maxpool): MaxPool3d(kernel_size=(3, 3, 3), stride=(2, 2, 2), padding=(1, 1, 1), dilation=1, ceil_mode=False) + (layer1): Sequential( + (0): Bottleneck( + (conv1): Conv3d(64, 64, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm3d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(64, 64, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm3d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(64, 256, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + (downsample): Sequential( + (0): Conv3d(64, 256, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (1): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): Bottleneck( + (conv1): Conv3d(256, 64, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm3d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(64, 64, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm3d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(64, 256, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + (2): Bottleneck( + (conv1): Conv3d(256, 64, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm3d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(64, 64, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm3d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(64, 256, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + ) + (layer2): Sequential( + (0): Bottleneck( + (conv1): Conv3d(256, 128, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm3d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(128, 128, kernel_size=(3, 3, 3), stride=(1, 2, 2), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm3d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(128, 512, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + (downsample): Sequential( + (0): Conv3d(256, 512, kernel_size=(3, 1, 1), stride=(1, 2, 2), bias=False) + (1): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): Bottleneck( + (conv1): Conv3d(512, 128, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm3d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(128, 128, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm3d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(128, 512, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + (2): Bottleneck( + (conv1): Conv3d(512, 128, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm3d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(128, 128, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm3d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(128, 512, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + (3): Bottleneck( + (conv1): Conv3d(512, 128, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm3d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(128, 128, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm3d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(128, 512, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + ) + (layer3): Sequential( + (0): Bottleneck( + (conv1): Conv3d(512, 256, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(256, 256, kernel_size=(3, 3, 3), stride=(1, 2, 2), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(256, 1024, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm3d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + (downsample): Sequential( + (0): Conv3d(512, 1024, kernel_size=(3, 1, 1), stride=(1, 2, 2), bias=False) + (1): BatchNorm3d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): Bottleneck( + (conv1): Conv3d(1024, 256, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(256, 256, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(256, 1024, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm3d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + (2): Bottleneck( + (conv1): Conv3d(1024, 256, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(256, 256, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(256, 1024, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm3d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + (3): Bottleneck( + (conv1): Conv3d(1024, 256, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(256, 256, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(256, 1024, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm3d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + (4): Bottleneck( + (conv1): Conv3d(1024, 256, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(256, 256, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(256, 1024, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm3d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + (5): Bottleneck( + (conv1): Conv3d(1024, 256, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(256, 256, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(256, 1024, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm3d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + ) + (layer4): Sequential( + (0): Bottleneck( + (conv1): Conv3d(1024, 512, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(512, 512, kernel_size=(3, 3, 3), stride=(1, 2, 2), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(512, 2048, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm3d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + (downsample): Sequential( + (0): Conv3d(1024, 2048, kernel_size=(3, 1, 1), stride=(1, 2, 2), bias=False) + (1): BatchNorm3d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): Bottleneck( + (conv1): Conv3d(2048, 512, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(512, 512, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(512, 2048, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm3d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + (2): Bottleneck( + (conv1): Conv3d(2048, 512, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(512, 512, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(512, 2048, kernel_size=(3, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm3d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + ) + (avgpool): AdaptiveAvgPool3d(output_size=(1, 1, 1)) + (fc): Linear(in_features=2048, out_features=1000, bias=True) +) \ No newline at end of file diff --git a/Video3D/ResnetI3D.txt b/Video3D/ResnetI3D.txt new file mode 100644 index 0000000..5504f96 --- /dev/null +++ b/Video3D/ResnetI3D.txt @@ -0,0 +1,176 @@ +I3DResNet50( + (conv1): Conv3d(3, 64, kernel_size=(3, 7, 7), stride=(1, 2, 2), padding=(1, 3, 3), bias=False) + (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + (maxpool): MaxPool3d(kernel_size=(3, 3, 3), stride=(2, 2, 2), padding=(1, 1, 1), dilation=(1, 1, 1), ceil_mode=False) + (layer1): Sequential( + (0): Bottleneck3d( + (conv1): Conv3d(64, 64, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(64, 64, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(64, 256, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + (downsample): Sequential( + (0): Conv3d(64, 256, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): Bottleneck3d( + (conv1): Conv3d(256, 64, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(64, 64, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(64, 256, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + (2): Bottleneck3d( + (conv1): Conv3d(256, 64, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(64, 64, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(64, 256, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + ) + (layer2): Sequential( + (0): Bottleneck3d( + (conv1): Conv3d(256, 128, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(128, 128, kernel_size=(3, 3, 3), stride=(2, 2, 2), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(128, 512, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + (downsample): Sequential( + (0): Conv3d(256, 512, kernel_size=(1, 1, 1), stride=(2, 2, 2), bias=False) + (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): Bottleneck3d( + (conv1): Conv3d(512, 128, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(128, 128, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(128, 512, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + (2): Bottleneck3d( + (conv1): Conv3d(512, 128, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(128, 128, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(128, 512, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + (3): Bottleneck3d( + (conv1): Conv3d(512, 128, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(128, 128, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(128, 512, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + ) + (layer3): Sequential( + (0): Bottleneck3d( + (conv1): Conv3d(512, 256, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(256, 256, kernel_size=(3, 3, 3), stride=(2, 2, 2), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(256, 1024, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + (downsample): Sequential( + (0): Conv3d(512, 1024, kernel_size=(1, 1, 1), stride=(2, 2, 2), bias=False) + (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): Bottleneck3d( + (conv1): Conv3d(1024, 256, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(256, 256, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(256, 1024, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + (2): Bottleneck3d( + (conv1): Conv3d(1024, 256, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(256, 256, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(256, 1024, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + (3): Bottleneck3d( + (conv1): Conv3d(1024, 256, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(256, 256, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(256, 1024, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + (4): Bottleneck3d( + (conv1): Conv3d(1024, 256, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(256, 256, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(256, 1024, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + (5): Bottleneck3d( + (conv1): Conv3d(1024, 256, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(256, 256, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(256, 1024, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + ) + (layer4): Sequential( + (0): Bottleneck3d( + (conv1): Conv3d(1024, 512, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(512, 512, kernel_size=(3, 3, 3), stride=(2, 2, 2), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(512, 2048, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + (downsample): Sequential( + (0): Conv3d(1024, 2048, kernel_size=(1, 1, 1), stride=(2, 2, 2), bias=False) + (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): Bottleneck3d( + (conv1): Conv3d(2048, 512, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(512, 512, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(512, 2048, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + (2): Bottleneck3d( + (conv1): Conv3d(2048, 512, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv2): Conv3d(512, 512, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1), bias=False) + (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (conv3): Conv3d(512, 2048, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False) + (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (relu): ReLU(inplace=True) + ) + ) + (avgpool): AdaptiveAvgPool3d(output_size=(1, 1, 1)) + (fc): Linear(in_features=2048, out_features=1000, bias=True) +) \ No newline at end of file diff --git a/Video3D/extratVideo.py b/Video3D/extratVideo.py new file mode 100644 index 0000000..9379f5f --- /dev/null +++ b/Video3D/extratVideo.py @@ -0,0 +1,162 @@ +import decord +from pathlib import Path +import torch +import cv2 +import numpy as np +from inflateDEMO import I3DResNet50 +import torchvision.transforms as T +import sys +from tqdm import tqdm +import ffmpeg +import argparse +from nested_lookup import nested_lookup +import gc + +try: + print (sys.path.index("d:\\Users\\user\\Documents\\postata\\RARP\\Clasification")) +except: + sys.path.append("d:\\Users\\user\\Documents\\postata\\RARP\\Clasification") + +from Models import RARP_NVB_ResNet50 + +def extract_frames_ffmpeg(video_path, start_frame, end_frame, width=None, height=None, fps=30): + # Construir el comando ffmpeg + stream = ( + ffmpeg + .input(video_path, ss=start_frame / fps, t=end_frame / fps, hwaccel='cuda') # Suponiendo 30 fps, ajusta según el FPS del video + .output('pipe:', format='rawvideo', pix_fmt='rgb24') + .run(capture_stdout=True) + ) + + # Convertir el stream en un array de NumPy + video = np.frombuffer(stream[0], np.uint8) + # Asumiendo que conocemos el ancho y el alto del video + if width and height: + video = video.reshape((-1, height, width, 3)) # Num_frames, altura, anchura, canales + + del stream + gc.collect() + return video + +def ffmpegVideoInfo (VideoPath:Path): + viodeoInfo = ffmpeg.probe(str(VideoPath.absolute())) + fps = eval (nested_lookup("avg_frame_rate", viodeoInfo)[0]) + w = int(nested_lookup("width", viodeoInfo)[0]) + h = int(nested_lookup("height", viodeoInfo)[0]) + total_frames = int(nested_lookup("nb_frames", viodeoInfo)[0]) + + return (fps, (w, h), total_frames, None) + +def decordVideoInfo (VideoPath:Path): + decord.bridge.set_bridge('native') + vr = decord.VideoReader(str(VideoPath.absolute())) + fps = vr.get_avg_fps() + total_frames = len(vr) + + return (fps, None, total_frames, vr) + + +def seconds_to_hms(seconds): + hours = seconds // 3600 + minutes = (seconds % 3600) // 60 + secs = seconds % 60 + return f'{int(hours)}:{int(minutes):02}:{int(secs):02}' + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + + parser.add_argument("--BaseLib", default="ffmpeg", type=str) + parser.add_argument("-i", "--Input", type=str) + parser.add_argument("-o", "--Output", type=str) + parser.add_argument("-t", "--Target", type=str) + parser.add_argument("-c", "--Chunk", type=int, default=15) + parser.add_argument("-b", "--BaseModel", type=str) + + args = parser.parse_args() + + + RN50Model = RARP_NVB_ResNet50.load_from_checkpoint(args.BaseModel) + RN50ModelToEval = RARP_NVB_ResNet50.load_from_checkpoint(args.BaseModel) + + mean, std = ([30.38144216, 42.03988769, 97.8896116], [40.63141752, 44.26910074, 50.29294373]) + transforms = T.Compose([ + T.Resize((256,256), antialias=True, interpolation=T.InterpolationMode.BICUBIC), + T.CenterCrop(224), + T.Normalize(mean, std) + ]) + + frameToFind = cv2.imread(str(Path(args.Target)), cv2.IMREAD_COLOR) + frameToFind = torch.Tensor(frameToFind) + frameToFind = frameToFind.permute(2, 0, 1).float() + + frameToFind = transforms(frameToFind) + + frameToFind = frameToFind.repeat(1, 1, 1, 1) + + torch.set_float32_matmul_precision('medium') + torch.backends.cudnn.deterministic = True + + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + + InfalteModel = I3DResNet50(RN50Model.model).to(device) + InfalteModel.fc = torch.nn.Identity() + InfalteModel.eval() + + RN50ModelToEval.model.fc = torch.nn.Identity() + RN50ModelToEval.to(device) + RN50ModelToEval.eval() + + chunk_size = args.Chunk + + + with torch.no_grad(): + frameToFind = frameToFind.to(device) + + Doutput = RN50ModelToEval(frameToFind) + Doutput = Doutput.squeeze() + + maxSim = 0 + + ListSim = [] + + initFrame = None + videoPathLong = Path(args.Input) + + fps, size, total_frames, vr = ffmpegVideoInfo(videoPathLong) if args.BaseLib == "ffmpeg" else decordVideoInfo(videoPathLong) + + for start_idx in tqdm(range(0, total_frames, chunk_size)): + end_idx = min(start_idx + chunk_size, total_frames) + + chunk_frames = extract_frames_ffmpeg(str(videoPathLong.absolute()), start_idx, end_idx, width=size[0], height=size[1], fps=fps) \ + if args.BaseLib == "ffmpeg" else vr.get_batch(range(start_idx, end_idx)).asnumpy() + + chunk_frames_bgr = chunk_frames[..., ::-1].copy() + + frames = torch.from_numpy(chunk_frames_bgr).to(device) + frames = frames.permute(0, 3, 1, 2) + frames = frames.float() + + frames = transforms(frames) + + frames = frames.repeat(1, 1, 1, 1, 1) + frames = frames.permute(0, 2, 1, 3, 4) + + outPut = InfalteModel(frames) + outPut = outPut.squeeze() + + cos_sim = torch.nn.functional.cosine_similarity(outPut, Doutput, dim=0) + + #maxSim = cos_sim if cos_sim > maxSim else maxSim + if cos_sim > maxSim: + #print(cos_sim) + maxSim = cos_sim + initFrame = (start_idx, end_idx) + + del frames + del chunk_frames + gc.collect() + + ListSim.append(cos_sim) + + print(seconds_to_hms(initFrame[0]/fps), seconds_to_hms(initFrame[1]/fps)) \ No newline at end of file diff --git a/Video3D/i3ddemo.ipynb b/Video3D/i3ddemo.ipynb new file mode 100644 index 0000000..0479dbd --- /dev/null +++ b/Video3D/i3ddemo.ipynb @@ -0,0 +1,499 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import decord\n", + "from pathlib import Path\n", + "import torch\n", + "import cv2\n", + "import numpy as np\n", + "from inflateDEMO import I3DResNet50\n", + "import torchvision.transforms as T\n", + "import sys\n", + "from tqdm.notebook import tqdm\n", + "\n", + "try:\n", + " print (sys.path.index(\"d:\\\\Users\\\\user\\\\Documents\\\\postata\\\\RARP\\\\Clasification\"))\n", + "except:\n", + " sys.path.append(\"d:\\\\Users\\\\user\\\\Documents\\\\postata\\\\RARP\\\\Clasification\")\n", + " \n", + "print(sys.path)\n", + "from Models import RARP_NVB_ResNet50\n", + "\n", + "\n", + "def _removeBlackBorder(image):\n", + " image = np.array(image)\n", + " \n", + " copyImg = cv2.cvtColor(image.copy(), cv2.COLOR_BGR2HSV)\n", + " h = copyImg[:,:,0]\n", + " mask = np.ones(h.shape, dtype=np.uint8) * 255\n", + " th = (25, 175)\n", + " mask[(h > th[0]) & (h < th[1])] = 0\n", + " copyImg = cv2.cvtColor(copyImg, cv2.COLOR_HSV2BGR)\n", + " resROI = cv2.bitwise_and(copyImg, copyImg, mask=mask)\n", + " \n", + " image_gray = cv2.cvtColor(resROI, cv2.COLOR_BGR2GRAY)\n", + " _, thresh = cv2.threshold(image_gray, 0, 255, cv2.THRESH_BINARY)\n", + " kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 15))\n", + " morph = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel)\n", + " contours = cv2.findContours(morph, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n", + " contours = contours[0] if len(contours) == 2 else contours[1]\n", + " bigCont = max(contours, key=cv2.contourArea)\n", + " x, y, w, h = cv2.boundingRect(bigCont)\n", + " crop = image[y : y + h, x : x + w]\n", + " return crop\n", + "\n", + "def VideoPrePros_BackBars(VideoIN_Path:str, VideoOUT_Path:str, demoVideo:int = None):\n", + " size = (1269, 1007)\n", + " fourcc = cv2.VideoWriter_fourcc(*'mp4v')\n", + " video = cv2.VideoWriter(VideoOUT_Path, fourcc, 30, size)\n", + " \n", + " if demoVideo is not None:\n", + " demoVideoOut = cv2.VideoWriter(\"demo.mp4\", fourcc, demoVideo, size)\n", + "\n", + " cap = cv2.VideoCapture(VideoIN_Path)\n", + " while (True):\n", + " ret, frame = cap.read()\n", + " if not ret:\n", + " break\n", + " \n", + " img = _removeBlackBorder(frame)\n", + " img = cv2.resize(img, size, interpolation=cv2.INTER_CUBIC)\n", + " video.write(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))\n", + " #video.write(img)\n", + " if demoVideo is not None:\n", + " demoVideoOut.write(img)\n", + " \n", + " video.release()\n", + " if demoVideo is not None:\n", + " demoVideoOut.release()\n", + " cap.release()\n", + " \n", + "RN50Model = RARP_NVB_ResNet50.load_from_checkpoint(\"../log_ResNet50_X10/lightning_logs/version_8/checkpoints/RARP-epoch=5.ckpt\")\n", + "RN50ModelToEval = RARP_NVB_ResNet50.load_from_checkpoint(\"../log_ResNet50_X10/lightning_logs/version_8/checkpoints/RARP-epoch=5.ckpt\")" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import ffmpeg\n", + "\n", + "def extract_frames_ffmpeg(video_path, start_frame, end_frame, width=None, height=None, fps=30):\n", + " # Construir el comando ffmpeg\n", + " stream = (\n", + " ffmpeg\n", + " .input(video_path, ss=start_frame / fps, t=end_frame / fps, hwaccel='cuda') # Suponiendo 30 fps, ajusta según el FPS del video\n", + " .output('pipe:', format='rawvideo', pix_fmt='rgb24')\n", + " .run(capture_stdout=True)\n", + " )\n", + " \n", + " # Convertir el stream en un array de NumPy\n", + " video = np.frombuffer(stream[0], np.uint8)\n", + " # Asumiendo que conocemos el ancho y el alto del video\n", + " if width and height:\n", + " video = video.reshape((-1, height, width, 3)) # Num_frames, altura, anchura, canales\n", + " return video" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "videoPathLong = Path(\"./dataset/NVB/350Full.mp4\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "decord.bridge.set_bridge('native')\n", + "vr = decord.VideoReader(str(videoPathLong.absolute()))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from nested_lookup import nested_lookup\n", + "\n", + "viodeoInfo = ffmpeg.probe(str(videoPathLong.absolute()))\n", + "fps = eval (nested_lookup(\"avg_frame_rate\", viodeoInfo)[0])\n", + "w = int(nested_lookup(\"width\", viodeoInfo)[0])\n", + "h = int(nested_lookup(\"height\", viodeoInfo)[0])\n", + "total_frames = int(nested_lookup(\"nb_frames\", viodeoInfo)[0])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "total_frames" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "def show_picture(im):\n", + " plt.imshow(im)\n", + " plt.xticks([])\n", + " plt.yticks([])\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fps = vr.get_avg_fps()\n", + "print (f\"FPS:{vr.get_avg_fps()}\")\n", + "segs = len(vr)/fps\n", + "print (f\"Video Length: {segs} seg.\")\n", + "print (f\"Video Length: {round(segs*fps)} frames.\")\n", + "print (f\"Chuks of 15 seg: {segs//15} chunks\")\n", + "print (f\"Chuks of 30 seg: {segs//30} chunks\")\n", + "print (f\"Chuks of 35 seg: {segs//35} chunks\")\n", + "print (f\"Chuks of 40 seg: {segs//40} chunks\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "start_frame = 0 # Fotograma de inicio\n", + "num_frames = 450 # Número de fotogramas que quieres extraer\n", + " # Ancho y alto del video (ajusta según el video)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "frames_batch = extract_frames_ffmpeg(str(videoPathLong.absolute()), start_frame, num_frames, width=w, height=h, fps=fps)\n", + "\n", + "print(f'Frames extraídos: {frames_batch.shape}')\n", + "\n", + "bgrFramesBatch = frames_batch[..., ::-1].copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "chunk_frames = vr.get_batch(range(start_frame, num_frames)).asnumpy()\n", + " \n", + "chunk_frames_bgr = chunk_frames[..., ::-1].copy()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "show_picture(chunk_frames_bgr[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "mean, std = ([30.38144216, 42.03988769, 97.8896116], [40.63141752, 44.26910074, 50.29294373])\n", + "transforms = T.Compose([\n", + " T.Resize((256,256), antialias=True, interpolation=T.InterpolationMode.BICUBIC),\n", + " T.CenterCrop(224),\n", + " T.Normalize(mean, std)\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "frameToFind = cv2.imread(str(Path(\"../DataSet_Ando_All/NVB/350.tiff\")), cv2.IMREAD_COLOR)\n", + "#frameToFind = _removeBlackBorder(frameToFind)\n", + "frameToFind = torch.Tensor(frameToFind)\n", + "frameToFind = frameToFind.permute(2, 0, 1).float()\n", + "\n", + "frameToFind = transforms(frameToFind)\n", + "\n", + "frameToFind = frameToFind.repeat(1, 1, 1, 1)\n", + "\n", + "torch.set_float32_matmul_precision('medium')\n", + "torch.backends.cudnn.deterministic = True\n", + "\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "InfalteModel = I3DResNet50(RN50Model.model).to(device)\n", + "InfalteModel.fc = torch.nn.Identity()\n", + "InfalteModel.eval()\n", + "\n", + "RN50ModelToEval.model.fc = torch.nn.Identity()\n", + "RN50ModelToEval.to(device)\n", + "RN50ModelToEval.eval()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "framesChunk = np.array([15, 30, 35, 40]) * round(fps)\n", + "\n", + "chunk_size = framesChunk[0]\n", + "total_frames = len(vr)\n", + "\n", + "with torch.no_grad():\n", + " frameToFind = frameToFind.to(device)\n", + " \n", + " Doutput = RN50ModelToEval(frameToFind)\n", + " Doutput = Doutput.squeeze()\n", + " \n", + " maxSim = 0\n", + " \n", + " ListSim = []\n", + " \n", + " initFrame = None\n", + " \n", + " for start_idx in tqdm(range(0, total_frames, chunk_size)):\n", + " end_idx = min(start_idx + chunk_size, total_frames)\n", + " chunk_frames = vr.get_batch(range(start_idx, end_idx)).asnumpy()\n", + " \n", + " chunk_frames_bgr = chunk_frames[..., ::-1].copy()\n", + " \n", + " frames = torch.from_numpy(chunk_frames_bgr).to(device)\n", + " frames = frames.permute(0, 3, 1, 2)\n", + " frames = frames.float()\n", + "\n", + " frames = transforms(frames)\n", + "\n", + " frames = frames.repeat(1, 1, 1, 1, 1)\n", + " frames = frames.permute(0, 2, 1, 3, 4)\n", + " \n", + " outPut = InfalteModel(frames)\n", + " outPut = outPut.squeeze()\n", + " \n", + " #print(outPut.shape, Doutput.shape)\n", + " \n", + " cos_sim = torch.nn.functional.cosine_similarity(outPut, Doutput, dim=0)\n", + " \n", + " #maxSim = cos_sim if cos_sim > maxSim else maxSim\n", + " if cos_sim > maxSim:\n", + " print(cos_sim)\n", + " maxSim = cos_sim\n", + " initFrame = (start_idx, end_idx)\n", + " \n", + "\n", + " ListSim.append(cos_sim)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def seconds_to_hms(seconds):\n", + " hours = seconds // 3600\n", + " minutes = (seconds % 3600) // 60\n", + " secs = seconds % 60\n", + " return f'{int(hours)}:{int(minutes):02}:{int(secs):02}'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(seconds_to_hms(initFrame[0]/fps), seconds_to_hms(initFrame[1]/fps))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import ffmpeg\n", + "from pathlib import Path\n", + "\n", + "videoPathLong = Path(\"./dataset/NVB/350Full.mp4\")\n", + "fileVideo = ffmpeg.input(str(videoPathLong.absolute()))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "outPutVideo = ffmpeg.output(fileVideo.trim(start_frame=initFrame[0], end_frame=initFrame[1]), \"350_1.mp4\", vcodec='h264_nvenc')\n", + "ffmpeg.run(outPutVideo)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from scipy.signal import savgol_filter\n", + "\n", + "Name = \"NVB/350.mp4\"\n", + "chunks = range(0, total_frames, chunk_size)\n", + "sim = torch.tensor(ListSim)\n", + "\n", + "smoothed_accuracy = savgol_filter(sim, window_length=5, polyorder=2)\n", + "\n", + "maxSim = sim.max()\n", + "indexmax = sim.argmax()\n", + "bestSim = chunks[indexmax]\n", + "\n", + "plt.figure(figsize=(15, 6))\n", + "plt.plot(chunks, sim, marker='o', linestyle='-', color='b', label='Cosine similarity')\n", + "plt.plot(chunks, smoothed_accuracy, color='g', linestyle='--', label='Smoothed Data')\n", + "plt.title(f\"frames vs. Sim. [{Name}]\")\n", + "plt.xlabel('frames')\n", + "plt.ylabel('Cos Sim.')\n", + "plt.grid(True)\n", + "\n", + "plt.scatter(bestSim, maxSim, zorder=5, marker=\"x\", color='r', label=f'Higth Sim: {maxSim:.4f} at {bestSim} start frame')\n", + "plt.legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from scipy.signal import savgol_filter\n", + "\n", + "# Data from the table\n", + "Name = \"NVB/349.mp4\"\n", + "frames = [19,24,31,47,52,58,59,66,72,73,76,77,93,116,154,231,461]\n", + "accuracy = [0.7166,0.7372,0.7518,0.7503,0.6988,0.713,0.7233,0.6932,0.6776,0.6842,0.6858,0.689,0.6887,0.6643,0.6811,0.6605,0.6827]\n", + "\n", + "smoothed_accuracy = savgol_filter(accuracy, window_length=5, polyorder=2)\n", + "\n", + "\n", + "# Finding the best accuracy and corresponding number of frames\n", + "max_acc = max(accuracy)\n", + "max_acc_index = accuracy.index(max_acc)\n", + "best_frames = frames[max_acc_index]\n", + "\n", + "# Plotting the data\n", + "plt.figure(figsize=(8, 6))\n", + "plt.plot(frames, accuracy, marker='o', linestyle='-', color='b', label='Original Data')\n", + "plt.plot(frames, smoothed_accuracy, color='g', linestyle='--', label='Smoothed Data')\n", + "plt.title(f\"No. Frames vs. Prob. NVB [{Name}]\")\n", + "plt.xlabel('No. Frames')\n", + "plt.ylabel('Prob. NVB')\n", + "plt.grid(True)\n", + "\n", + "# Highlight the best accuracy point\n", + "plt.scatter(best_frames, max_acc, zorder=5, marker=\"x\", color='r', label=f'Best Acc: {max_acc} at {best_frames} Frames')\n", + "plt.legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from scipy.signal import savgol_filter\n", + "\n", + "# Data from the table\n", + "Name = \"NOT_NVB/201.mp4\"\n", + "frames = [18,23,30,45,50,57,59,65,72,73,75,76,90,113,150,224,450]\n", + "accuracy = [0.4945,0.5124,0.5194,0.5173,0.501,0.5206,0.5222,0.5322,0.496,0.5042,0.5007,0.4977,0.5042,0.5139,0.51,0.5116,0.5123]\n", + "\n", + "smoothed_accuracy = savgol_filter(accuracy, window_length=5, polyorder=2)\n", + "\n", + "\n", + "# Finding the best accuracy and corresponding number of frames\n", + "max_acc = min(accuracy)\n", + "max_acc_index = accuracy.index(max_acc)\n", + "best_frames = frames[max_acc_index]\n", + "\n", + "# Plotting the data\n", + "plt.figure(figsize=(8, 6))\n", + "plt.plot(frames, accuracy, marker='o', linestyle='-', color='r', label='Original Data')\n", + "plt.plot(frames, smoothed_accuracy, color='g', linestyle='--', label='Smoothed Data')\n", + "plt.title(f\"No. Frames vs. Prob. NVB [{Name}]\")\n", + "plt.xlabel('No. Frames')\n", + "plt.ylabel('Prob. NVB')\n", + "plt.grid(True)\n", + "\n", + "# Highlight the best accuracy point\n", + "plt.scatter(best_frames, max_acc, zorder=5, marker=\"x\", color='b', label=f'Best Acc: {max_acc} at {best_frames} Frames')\n", + "plt.legend()\n", + "\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pyRARP", + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Video3D/inflate.py b/Video3D/inflate.py new file mode 100644 index 0000000..de91cd9 --- /dev/null +++ b/Video3D/inflate.py @@ -0,0 +1,94 @@ +import torch +from torch.nn import Parameter + + +def inflate_conv( + conv2d, + time_dim=3, + time_padding=0, + time_stride=1, + time_dilation=1, + center=False + ): + # To preserve activations, padding should be by continuity and not zero + # or no padding in time dimension + kernel_dim = (time_dim, conv2d.kernel_size[0], conv2d.kernel_size[1]) + padding = (time_padding, conv2d.padding[0], conv2d.padding[1]) + stride = (time_stride, conv2d.stride[0], conv2d.stride[0]) + dilation = (time_dilation, conv2d.dilation[0], conv2d.dilation[1]) + conv3d = torch.nn.Conv3d( + conv2d.in_channels, + conv2d.out_channels, + kernel_dim, + padding=padding, + dilation=dilation, + stride=stride) + # Repeat filter time_dim times along time dimension + weight_2d = conv2d.weight.data + if center: + weight_3d = torch.zeros(*weight_2d.shape) + weight_3d = weight_3d.unsqueeze(2).repeat(1, 1, time_dim, 1, 1) + middle_idx = time_dim // 2 + weight_3d[:, :, middle_idx, :, :] = weight_2d + else: + weight_3d = weight_2d.unsqueeze(2).repeat(1, 1, time_dim, 1, 1) + weight_3d = weight_3d / time_dim + + # Assign new params + conv3d.weight = Parameter(weight_3d) + conv3d.bias = conv2d.bias + return conv3d + +def inflate_linear(linear2d, time_dim): + """ + Args: + time_dim: final time dimension of the features + """ + linear3d = torch.nn.Linear(linear2d.in_features * time_dim, + linear2d.out_features) + weight3d = linear2d.weight.data.repeat(1, time_dim) + weight3d = weight3d / time_dim + + linear3d.weight = Parameter(weight3d) + linear3d.bias = linear2d.bias + return linear3d + +def inflate_batch_norm(batch2d): + # In pytorch 0.2.0 the 2d and 3d versions of batch norm + # work identically except for the check that verifies the + # input dimensions + + batch3d = torch.nn.BatchNorm3d(batch2d.num_features) + # retrieve 3d _check_input_dim function + batch2d._check_input_dim = batch3d._check_input_dim + return batch2d + +def inflate_pool( + pool2d, + time_dim=1, + time_padding=0, + time_stride=None, + time_dilation=1 +): + if isinstance(pool2d, torch.nn.AdaptiveAvgPool2d): + pool3d = torch.nn.AdaptiveAvgPool3d((1, 1, 1)) + else: + kernel_dim = (time_dim, pool2d.kernel_size, pool2d.kernel_size) + padding = (time_padding, pool2d.padding, pool2d.padding) + if time_stride is None: + time_stride = time_dim + stride = (time_stride, pool2d.stride, pool2d.stride) + if isinstance(pool2d, torch.nn.MaxPool2d): + dilation = (time_dilation, pool2d.dilation, pool2d.dilation) + pool3d = torch.nn.MaxPool3d( + kernel_dim, + padding=padding, + dilation=dilation, + stride=stride, + ceil_mode=pool2d.ceil_mode) + elif isinstance(pool2d, torch.nn.AvgPool2d): + pool3d = torch.nn.AvgPool3d(kernel_dim, stride=stride) + else: + raise ValueError('{} is not among known pooling classes'.format(type(pool2d))) + + return pool3d \ No newline at end of file diff --git a/Video3D/inflateDEMO.py b/Video3D/inflateDEMO.py new file mode 100644 index 0000000..f3d3a4c --- /dev/null +++ b/Video3D/inflateDEMO.py @@ -0,0 +1,182 @@ +import torch +import torchvision +import inflate + + +def Inflate_2D_to_3D(Layer:torch.nn.Module, framesDepth:int=3): + newLayer3D = Layer + + if isinstance(Layer, torch.nn.Conv2d): + newLayer3D = torch.nn.Conv3d( + in_channels=Layer.in_channels, + out_channels=Layer.out_channels, + kernel_size=(framesDepth, Layer.kernel_size[0], Layer.kernel_size[1]), + stride=(1, Layer.stride[0], Layer.stride[1]), + padding=(1 if Layer.padding[0] > 0 else 0, Layer.padding[0], Layer.padding[1]), + bias=Layer.bias is not None + ) + + with torch.no_grad(): + newLayer3D.weight.copy_(Layer.weight.unsqueeze(2).repeat(1, 1, framesDepth, 1, 1) / framesDepth) + if Layer.bias is not None: + newLayer3D.bias.copy_(Layer.bias) + + elif isinstance(Layer, torch.nn.AdaptiveAvgPool2d): + newLayer3D = torch.nn.AdaptiveAvgPool3d((1,1,1)) + elif isinstance(Layer, torch.nn.MaxPool2d): + if isinstance(Layer.kernel_size, int): + Layer.kernel_size = (Layer.kernel_size, Layer.kernel_size) + if isinstance(Layer.stride, int): + Layer.stride = (Layer.stride, Layer.stride) + if isinstance(Layer.padding, int): + Layer.padding = (Layer.padding, Layer.padding) + newLayer3D = torch.nn.MaxPool3d( + kernel_size=(Layer.kernel_size[0], Layer.kernel_size[0], Layer.kernel_size[1]), + stride=(Layer.stride[0], Layer.stride[0], Layer.stride[1]), + padding=(Layer.padding[0], Layer.padding[0], Layer.padding[1]), + ) + elif isinstance(Layer, torch.nn.BatchNorm2d): + newLayer3D = torch.nn.BatchNorm3d( + num_features=Layer.num_features, + ) + elif isinstance(Layer, torch.nn.AvgPool2d): + newLayer3D = torch.nn.AvgPool3d( + kernel_size=(framesDepth, Layer.kernel_size[0], Layer.kernel_size[1]), + stride=(1, Layer.stride[0], Layer.stride[1]), + padding=(1, Layer.padding[0], Layer.padding[1]) + ) + + return newLayer3D + +def Recurcive_InflateModel(Model:torch.nn.Module): + for name, module in Model.named_children(): + if len([*module.children()]) > 0: + Recurcive_InflateModel(module) + else: + setattr(Model, name, Inflate_2D_to_3D(module, 3)) + +def inflate_downsample(downsample2d, time_stride=1): + downsample3d = torch.nn.Sequential( + inflate.inflate_conv(downsample2d[0], time_dim=1, time_stride=time_stride, center=True), + inflate.inflate_batch_norm(downsample2d[1]) + ) + return downsample3d + +class Bottleneck3d(torch.nn.Module): + def __init__(self, bottleneck2d): + super(Bottleneck3d, self).__init__() + + spatial_stride = bottleneck2d.conv2.stride[0] + + self.conv1 = inflate.inflate_conv(bottleneck2d.conv1, time_dim=1, center=True) + self.bn1 = inflate.inflate_batch_norm(bottleneck2d.bn1) + + self.conv2 = inflate.inflate_conv( + bottleneck2d.conv2, + time_dim=3, + time_padding=1, + time_stride=spatial_stride, + center=True + ) + self.bn2 = inflate.inflate_batch_norm(bottleneck2d.bn2) + + self.conv3 = inflate.inflate_conv(bottleneck2d.conv3, time_dim=1, center=True) + self.bn3 = inflate.inflate_batch_norm(bottleneck2d.bn3) + + self.relu = torch.nn.ReLU(inplace=True) + + if bottleneck2d.downsample is not None: + self.downsample = inflate_downsample(bottleneck2d.downsample, time_stride=spatial_stride) + else: + self.downsample = None + + self.stride = bottleneck2d.stride + + def forward(self, x): + residual = x + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + out = self.relu(out) + + out = self.conv3(out) + out = self.bn3(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + return out + +def inflate_reslayer(reslayer2d): + reslayers3d = [] + for layer2d in reslayer2d: + layer3d = Bottleneck3d(layer2d) + reslayers3d.append(layer3d) + return torch.nn.Sequential(*reslayers3d) + +class I3DResNet50(torch.nn.Module): + def __init__(self, RN50Model:torch.nn.Module, *args, **kwargs) -> None: + super().__init__(*args, **kwargs) + + self.conv1 = inflate.inflate_conv(RN50Model.conv1, time_dim=7, time_stride=2, time_padding=3, center=True) + self.bn1 = inflate.inflate_batch_norm(RN50Model.bn1) + self.relu = torch.nn.ReLU(True) + self.maxpool = inflate.inflate_pool(RN50Model.maxpool, time_dim=3, time_padding=1, time_stride=2) + + self.layer1 = inflate_reslayer(RN50Model.layer1) + self.layer2 = inflate_reslayer(RN50Model.layer2) + self.layer3 = inflate_reslayer(RN50Model.layer3) + self.layer4 = inflate_reslayer(RN50Model.layer4) + + self.avgpool = inflate.inflate_pool(RN50Model.avgpool, time_dim=1) + self.fc = inflate.inflate_linear(RN50Model.fc, 1) + + def forward(self, x): + x = self.conv1(x) + x = self.bn1(x) + x = self.relu(x) + x = self.maxpool(x) + + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + + x = self.avgpool(x) + x_reshape = x.view(x.size(0), -1) + x = self.fc(x_reshape) + + return x + + +if __name__ == "__main__": + torch.set_float32_matmul_precision('medium') + torch.backends.cudnn.deterministic = True + + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + model = torchvision.models.resnet50(weights=torchvision.models.ResNet50_Weights.DEFAULT) + + model = I3DResNet50(model).to(device) + model.eval() + + + print("Model Test") + + domyTest = torch.rand(8, 3, 15, 224, 224).to(device) + + outPut = model(domyTest) + + print("out_shape", outPut.shape) + outPut = torch.softmax(outPut, dim=1) + print("out", outPut.argmax(dim=1)) + + + + + + \ No newline at end of file diff --git a/defs.py b/defs.py new file mode 100644 index 0000000..1b1b694 --- /dev/null +++ b/defs.py @@ -0,0 +1,33 @@ +import numpy as np +import torch +import cv2 + +def load_file(path): + return np.load(path).astype(float) + +def load_file_tensor(path): + return torch.from_numpy(np.load(path).astype(float).transpose((2, 0, 1))) + +def load_file_tensor_norm(path): + return torch.from_numpy(np.load(path).astype(float).transpose((2, 0, 1))) / 255.0 + +def load_Img(path): + cv2.imread(str(path), cv2.IMREAD_COLOR) + +def clip_gradients(model, clip=2.0): + """Rescale norm of computed gradients. + + Parameters + ---------- + model : nn.Module + Module. + + clip : float + Maximum norm. + """ + for p in model.parameters(): + if p.grad is not None: + param_norm = p.grad.data.norm(2) + clip_coef = clip / (param_norm + 1e-6) + if clip_coef < 1: + p.grad.data.mul_(clip_coef) \ No newline at end of file diff --git a/eval-E1.yaml b/eval-E1.yaml new file mode 100644 index 0000000..537dcae --- /dev/null +++ b/eval-E1.yaml @@ -0,0 +1,42 @@ +models: + ResNet50_ckpt: + - ./log_ResNet50_X6/lightning_logs/version_5/checkpoints/epoch=25-step=104.ckpt + - ./log_ResNet50_X6/lightning_logs/version_6/checkpoints/epoch=29-step=90.ckpt + - ./log_ResNet50_X6/lightning_logs/version_7/checkpoints/epoch=14-step=45.ckpt + - ./log_ResNet50_X6/lightning_logs/version_8/checkpoints/epoch=20-step=84.ckpt + - ./log_ResNet50_X6/lightning_logs/version_9/checkpoints/epoch=44-step=180.ckpt + ResNet18_ckpt: + #- ./log_restnet18_X6/lightning_logs/version_14/checkpoints/epoch=22-step=92.ckpt + MovilNetV2_ckpt: + #- ./log_MobileNetV2_X6/lightning_logs/version_14/checkpoints/epoch=41-step=168.ckpt + EfficientNetV2_ckpt: + - ./log_EfficientNetV2_X6/lightning_logs/version_5/checkpoints/epoch=25-step=104.ckpt + - ./log_EfficientNetV2_X6/lightning_logs/version_6/checkpoints/epoch=23-step=72.ckpt + - ./log_EfficientNetV2_X6/lightning_logs/version_7/checkpoints/epoch=49-step=150.ckpt + - ./log_EfficientNetV2_X6/lightning_logs/version_8/checkpoints/epoch=23-step=96.ckpt + - ./log_EfficientNetV2_X6/lightning_logs/version_9/checkpoints/epoch=19-step=80.ckpt + + +dataset_type: YOLO_ROI #full_size, Manual_ROI, Manual_ROIwD, YOLO_ROI + +YOLO_Accuracy_min_ROI: 0.40 + +Fold_Num: 4 + +Fold_Ensamble: False + +# este es el mejor hasta ahora +#- ./log_ResNet50_X6/lightning_logs/version_14/checkpoints/epoch=23-step=96.ckpt +#- ./log_ResNet50_X6/lightning_logs/version_9/checkpoints/epoch=44-step=180.ckpt + +#- ./log_EfficientNetV2_X6/lightning_logs/version_8/checkpoints/epoch=23-step=96.ckpt +#- ./log_EfficientNetV2_X5/lightning_logs/version_10/checkpoints/epoch=25-step=104.ckpt + +#- ./log_ResNet50_X6/lightning_logs/version_6/checkpoints/epoch=29-step=90.ckpt +#- ./log_ResNet50_X6/lightning_logs/version_14/checkpoints/epoch=23-step=96.ckpt + +#- ./log_ResNet50_X6/lightning_logs/version_10/checkpoints/epoch=26-step=108.ckpt + #- ./log_ResNet50_X6/lightning_logs/version_11/checkpoints/epoch=23-step=72.ckpt + #- ./log_ResNet50_X6/lightning_logs/version_12/checkpoints/epoch=22-step=69.ckpt + #- ./log_ResNet50_X6/lightning_logs/version_13/checkpoints/epoch=10-step=44.ckpt + #- ./log_ResNet50_X6/lightning_logs/version_14/checkpoints/epoch=23-step=96.ckpt \ No newline at end of file diff --git a/eval-E2.yaml b/eval-E2.yaml new file mode 100644 index 0000000..d51cc10 --- /dev/null +++ b/eval-E2.yaml @@ -0,0 +1,22 @@ +models: + ResNet50_ckpt: + - ./log_ResNet50_X6/lightning_logs/version_10/checkpoints/epoch=26-step=108.ckpt + - ./log_ResNet50_X6/lightning_logs/version_11/checkpoints/epoch=23-step=72.ckpt + - ./log_ResNet50_X6/lightning_logs/version_12/checkpoints/epoch=22-step=69.ckpt + - ./log_ResNet50_X6/lightning_logs/version_13/checkpoints/epoch=10-step=44.ckpt + - ./log_ResNet50_X6/lightning_logs/version_14/checkpoints/epoch=23-step=96.ckpt + EfficientNetV2_ckpt: + - ./log_EfficientNetV2_X5/lightning_logs/version_10/checkpoints/epoch=25-step=104.ckpt + - ./log_EfficientNetV2_X5/lightning_logs/version_11/checkpoints/epoch=24-step=75.ckpt + - ./log_EfficientNetV2_X5/lightning_logs/version_12/checkpoints/epoch=7-step=24.ckpt + - ./log_EfficientNetV2_X5/lightning_logs/version_13/checkpoints/epoch=39-step=160.ckpt + - ./log_EfficientNetV2_X5/lightning_logs/version_14/checkpoints/epoch=9-step=40.ckpt + + +dataset_type: YOLO_ROI #full_size, Manual_ROI, Manual_ROIwD, YOLO_ROI + +YOLO_Accuracy_min_ROI: 0.40 + +Fold_Num: 4 + +Fold_Ensamble: False diff --git a/eval-E3.yaml b/eval-E3.yaml new file mode 100644 index 0000000..ab1e459 --- /dev/null +++ b/eval-E3.yaml @@ -0,0 +1,22 @@ +models: + ResNet50_ckpt: + #X6-Full-size + - ./log_ResNet50_X6/lightning_logs/version_10/checkpoints/epoch=26-step=108.ckpt + - ./log_ResNet50_X6/lightning_logs/version_11/checkpoints/epoch=23-step=72.ckpt + - ./log_ResNet50_X6/lightning_logs/version_12/checkpoints/epoch=22-step=69.ckpt + - ./log_ResNet50_X6/lightning_logs/version_13/checkpoints/epoch=10-step=44.ckpt + - ./log_ResNet50_X6/lightning_logs/version_14/checkpoints/epoch=23-step=96.ckpt + #X6-ROI-fix + - ./log_ResNet50_X6/lightning_logs/version_5/checkpoints/epoch=25-step=104.ckpt + - ./log_ResNet50_X6/lightning_logs/version_6/checkpoints/epoch=29-step=90.ckpt + - ./log_ResNet50_X6/lightning_logs/version_7/checkpoints/epoch=14-step=45.ckpt + - ./log_ResNet50_X6/lightning_logs/version_8/checkpoints/epoch=20-step=84.ckpt + - ./log_ResNet50_X6/lightning_logs/version_9/checkpoints/epoch=44-step=180.ckpt + +dataset_type: YOLO_ROI #full_size, Manual_ROI, Manual_ROIwD, YOLO_ROI + +YOLO_Accuracy_min_ROI: 0.40 + +Fold_Num: 4 + +Fold_Ensamble: False \ No newline at end of file diff --git a/eval-E4.yaml b/eval-E4.yaml new file mode 100644 index 0000000..1495641 --- /dev/null +++ b/eval-E4.yaml @@ -0,0 +1,22 @@ +models: + EfficientNetV2_ckpt: + #X5-Full-size + - ./log_EfficientNetV2_X5/lightning_logs/version_10/checkpoints/epoch=25-step=104.ckpt + - ./log_EfficientNetV2_X5/lightning_logs/version_11/checkpoints/epoch=24-step=75.ckpt + - ./log_EfficientNetV2_X5/lightning_logs/version_12/checkpoints/epoch=7-step=24.ckpt + - ./log_EfficientNetV2_X5/lightning_logs/version_13/checkpoints/epoch=39-step=160.ckpt + - ./log_EfficientNetV2_X5/lightning_logs/version_14/checkpoints/epoch=9-step=40.ckpt + #X6-ROI-fix + - ./log_EfficientNetV2_X6/lightning_logs/version_5/checkpoints/epoch=25-step=104.ckpt + - ./log_EfficientNetV2_X6/lightning_logs/version_6/checkpoints/epoch=23-step=72.ckpt + - ./log_EfficientNetV2_X6/lightning_logs/version_7/checkpoints/epoch=49-step=150.ckpt + - ./log_EfficientNetV2_X6/lightning_logs/version_8/checkpoints/epoch=23-step=96.ckpt + - ./log_EfficientNetV2_X6/lightning_logs/version_9/checkpoints/epoch=19-step=80.ckpt + +dataset_type: YOLO_ROI #full_size, Manual_ROI, Manual_ROIwD, YOLO_ROI + +YOLO_Accuracy_min_ROI: 0.40 + +Fold_Num: 4 + +Fold_Ensamble: False diff --git a/eval-EFold0.yaml b/eval-EFold0.yaml new file mode 100644 index 0000000..a748c6c --- /dev/null +++ b/eval-EFold0.yaml @@ -0,0 +1,20 @@ +models: + ResNet50_ckpt: + - ./log_ResNet50_X6/lightning_logs/version_5/checkpoints/epoch=25-step=104.ckpt #ROI-FIX X6 + - ./log_ResNet50_X6/lightning_logs/version_10/checkpoints/epoch=26-step=108.ckpt #Full-size X6 + - ./log_ResNet50_X5/lightning_logs/version_5/checkpoints/epoch=17-step=72.ckpt #ROI_FIX X5 + - ./log_ResNet50_X5/lightning_logs/version_10/checkpoints/epoch=3-step=16.ckpt #Full-size X5 + #nuevo + #- ./log_ResNet50_X6_1/lightning_logs/version_0/checkpoints/epoch=8-step=36.ckpt + EfficientNetV2_ckpt: + - ./log_EfficientNetV2_X6/lightning_logs/version_5/checkpoints/epoch=25-step=104.ckpt #ROI-FIX x6 + - ./log_EfficientNetV2_X5/lightning_logs/version_10/checkpoints/epoch=25-step=104.ckpt #Full-size X5 + - ./log_EfficientNetV2_X5/lightning_logs/version_5/checkpoints/epoch=12-step=52.ckpt #ROI-FIX X5 + ResNet18_ckpt: + - ./log_restnet18_X6/lightning_logs/version_10/checkpoints/epoch=17-step=72.ckpt #Full-size X6 + +dataset_type: small_Ando #full_size, Manual_ROI, Manual_ROIwD, YOLO_ROI +YOLO_Accuracy_min_ROI: 0.40 +Fold_Num: 0 +Fold_Ensamble: True +Youden-Index: "ROC" #"ROC" from the ROC curve, "RatS" from the definition (Recall + Specificity - 1) diff --git a/eval-EFold1.yaml b/eval-EFold1.yaml new file mode 100644 index 0000000..fd5d636 --- /dev/null +++ b/eval-EFold1.yaml @@ -0,0 +1,18 @@ +models: + ResNet50_ckpt: + - ./log_ResNet50_X6/lightning_logs/version_6/checkpoints/epoch=29-step=90.ckpt + - ./log_ResNet50_X6/lightning_logs/version_11/checkpoints/epoch=23-step=72.ckpt + - ./log_ResNet50_X5/lightning_logs/version_6/checkpoints/epoch=23-step=72.ckpt + - ./log_ResNet50_X5/lightning_logs/version_11/checkpoints/epoch=25-step=78.ckpt + EfficientNetV2_ckpt: + - ./log_EfficientNetV2_X6/lightning_logs/version_6/checkpoints/epoch=23-step=72.ckpt + - ./log_EfficientNetV2_X5/lightning_logs/version_11/checkpoints/epoch=24-step=75.ckpt + - ./log_EfficientNetV2_X5/lightning_logs/version_6/checkpoints/epoch=16-step=51.ckpt + ResNet18_ckpt: + - ./log_restnet18_X6/lightning_logs/version_11/checkpoints/epoch=22-step=69.ckpt + +dataset_type: small_balaced #full_size, Manual_ROI, Manual_ROIwD, YOLO_ROI +YOLO_Accuracy_min_ROI: 0.40 +Fold_Num: 1 +Fold_Ensamble: True +Youden-Index: "ROC" \ No newline at end of file diff --git a/eval-EFold2.yaml b/eval-EFold2.yaml new file mode 100644 index 0000000..2ee4981 --- /dev/null +++ b/eval-EFold2.yaml @@ -0,0 +1,18 @@ +models: + ResNet50_ckpt: + - ./log_ResNet50_X6/lightning_logs/version_7/checkpoints/epoch=14-step=45.ckpt + - ./log_ResNet50_X6/lightning_logs/version_12/checkpoints/epoch=22-step=69.ckpt + - ./log_ResNet50_X5/lightning_logs/version_7/checkpoints/epoch=49-step=150.ckpt + - ./log_ResNet50_X5/lightning_logs/version_12/checkpoints/epoch=23-step=72.ckpt + EfficientNetV2_ckpt: + - ./log_EfficientNetV2_X6/lightning_logs/version_7/checkpoints/epoch=49-step=150.ckpt + - ./log_EfficientNetV2_X5/lightning_logs/version_12/checkpoints/epoch=7-step=24.ckpt + - ./log_EfficientNetV2_X5/lightning_logs/version_7/checkpoints/epoch=25-step=78.ckpt + ResNet18_ckpt: + - ./log_restnet18_X6/lightning_logs/version_12/checkpoints/epoch=21-step=66.ckpt + +dataset_type: small_balaced #full_size, Manual_ROI, Manual_ROIwD, YOLO_ROI +YOLO_Accuracy_min_ROI: 0.40 +Fold_Num: 2 +Fold_Ensamble: True +Youden-Index: "ROC" \ No newline at end of file diff --git a/eval-EFold3.yaml b/eval-EFold3.yaml new file mode 100644 index 0000000..7df488c --- /dev/null +++ b/eval-EFold3.yaml @@ -0,0 +1,18 @@ +models: + ResNet50_ckpt: + - ./log_ResNet50_X6/lightning_logs/version_8/checkpoints/epoch=20-step=84.ckpt + - ./log_ResNet50_X6/lightning_logs/version_13/checkpoints/epoch=10-step=44.ckpt + - ./log_ResNet50_X5/lightning_logs/version_8/checkpoints/epoch=10-step=44.ckpt + - ./log_ResNet50_X5/lightning_logs/version_12/checkpoints/epoch=23-step=72.ckpt + EfficientNetV2_ckpt: + - ./log_EfficientNetV2_X6/lightning_logs/version_8/checkpoints/epoch=23-step=96.ckpt + - ./log_EfficientNetV2_X5/lightning_logs/version_13/checkpoints/epoch=39-step=160.ckpt + - ./log_EfficientNetV2_X5/lightning_logs/version_8/checkpoints/epoch=21-step=88.ckpt + ResNet18_ckpt: + - ./log_restnet18_X6/lightning_logs/version_13/checkpoints/epoch=4-step=20.ckpt + +dataset_type: small_balaced #full_size, Manual_ROI, Manual_ROIwD, YOLO_ROI +YOLO_Accuracy_min_ROI: 0.40 +Fold_Num: 3 +Fold_Ensamble: True +Youden-Index: "ROC" \ No newline at end of file diff --git a/eval-EFold4.yaml b/eval-EFold4.yaml new file mode 100644 index 0000000..59780ec --- /dev/null +++ b/eval-EFold4.yaml @@ -0,0 +1,18 @@ +models: + ResNet50_ckpt: + - ./log_ResNet50_X6/lightning_logs/version_9/checkpoints/epoch=44-step=180.ckpt + - ./log_ResNet50_X6/lightning_logs/version_14/checkpoints/epoch=23-step=96.ckpt + - ./log_ResNet50_X5/lightning_logs/version_9/checkpoints/epoch=30-step=124.ckpt + - ./log_ResNet50_X5/lightning_logs/version_14/checkpoints/epoch=21-step=88.ckpt + EfficientNetV2_ckpt: + - ./log_EfficientNetV2_X6/lightning_logs/version_9/checkpoints/epoch=19-step=80.ckpt + - ./log_EfficientNetV2_X5/lightning_logs/version_14/checkpoints/epoch=9-step=40.ckpt + - ./log_EfficientNetV2_X5/lightning_logs/version_9/checkpoints/epoch=13-step=56.ckpt + ResNet18_ckpt: + - ./log_restnet18_X6/lightning_logs/version_14/checkpoints/epoch=22-step=92.ckpt + +dataset_type: small_balaced #full_size, Manual_ROI, Manual_ROIwD, YOLO_ROI +YOLO_Accuracy_min_ROI: 0.40 +Fold_Num: 4 +Fold_Ensamble: True +Youden-Index: "ROC" \ No newline at end of file diff --git a/evalImageModel.ipynb b/evalImageModel.ipynb new file mode 100644 index 0000000..55fa806 --- /dev/null +++ b/evalImageModel.ipynb @@ -0,0 +1,189 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import numpy as np\n", + "import pandas as pd\n", + "import torch\n", + "import Loaders\n", + "from torchvision import transforms\n", + "import defs\n", + "import Models as M\n", + "import csv\n", + "import cv2\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "Dataset = Loaders.RARP_DatasetCreator(\n", + " \"./DataSet_Ando_All\",\n", + " FoldSeed=505,\n", + " createFile=True,\n", + " SavePath=\"./DataSet_Ando_All\",\n", + " Fold=5,\n", + " removeBlackBar=True\n", + ")\n", + "\n", + "Dataset.CreateFolds()\n", + " \n", + "Dataset.mean, Dataset.std = ([30.38144216, 42.03988769, 97.8896116], [40.63141752, 44.26910074, 50.29294373])\n", + "fullDataset = pd.read_csv(Dataset.CVS_File, usecols=[\"name\", \"class\"])\n", + "\n", + "foldfile = np.load(Dataset.CVS_File.parent/\"Folds.npy\", allow_pickle=True)\n", + "folds = np.array_split(foldfile, len(foldfile)/3)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "lastID = 224\n", + "rootFile = Path(\"./DataSet_big/\")\n", + "cNotNVB, cNVB = (0, 0)\n", + "with open(Dataset.CVS_File, \"a\", newline='') as csvfile:\n", + " writerOBJ = csv.writer(csvfile)\n", + " for i, file in enumerate(rootFile.glob(\"**/*.tiff\")):\n", + " id = lastID + i\n", + " if not len (fullDataset.loc[(fullDataset[\"class\"] == file.parent.name) & (fullDataset[\"name\"] == file.name)]):\n", + " tempImg = cv2.imread(str(file), cv2.IMREAD_COLOR)\n", + " tempImg = Dataset._removeBlackBorder(tempImg)\n", + " \n", + " cNotNVB += 1 if file.parent.name == \"NOT_NVB\" else 0\n", + " cNVB += 1 if file.parent.name == \"NVB\" else 0\n", + " numFold = (cNotNVB if file.parent.name == 'NOT_NVB' else cNVB) % 5\n", + " \n", + " writerOBJ.writerow([lastID + i, 0 if file.parent.name == \"NOT_NVB\" else 1 , file.parent.name, \"\", file.name, \"0\", \"0\", \"0\", \"0\", \"0\", \"0\"])\n", + " folds[numFold][2].append(id)\n", + " \n", + " np.save(Dataset.CVS_File.parent.parent/f\"fold_{numFold}/test/{file.parent.name.replace('T', '')}/Img0-{id}.npy\", tempImg)\n", + " \n", + " csvfile.close()\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "folds[1]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "dataset = pd.read_csv(Dataset.CVS_File, usecols=[\"id\", \"label\", \"class\", \"name\"])\n", + "listNames = pd.read_excel(Path(\"./List Review labels.xlsx\", header=0,))\n", + "\n", + "foldNum, th, epoch = (4, 0.50, 104)\n", + "model = M.RARP_NVB_ResNet50_VAN.load_from_checkpoint(Path(f\"./log_X12_VAN_Review/lightning_logs/version_{foldNum}/checkpoints/RARP-epoch={epoch}.ckpt\"))\n", + "model.eval()\n", + "model.to(device)\n", + "\n", + "dumpCVS = Dataset.CVS_File.parent/\"analisis.csv\"\n", + "\n", + "rootFile = Dataset.CVS_File.parent.parent/f\"fold_{foldNum}\"\n", + "\n", + "testtransform = torch.nn.Sequential(\n", + " transforms.Resize(256, antialias=True, interpolation=transforms.InterpolationMode.BICUBIC),\n", + " transforms.CenterCrop(224),\n", + " transforms.Normalize(Dataset.mean, Dataset.std)\n", + ").to(device)\n", + "\n", + "foldDataset = dataset.loc[dataset[\"id\"].isin(folds[foldNum][2])] #[fold][train|eval|test]" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "with torch.no_grad():\n", + " fileMode = \"x\" if not dumpCVS.exists() else \"a\"\n", + " \n", + " with open(dumpCVS, fileMode, newline='') as csvfile: \n", + " writerOBJ = csv.writer(csvfile)\n", + " if fileMode == \"x\":\n", + " writerOBJ.writerow([\"fold\", \"th\", \"name\", \"P(x)\", \"old Label (GT)\", \"new Label (GT)\", f\"prediction label (TH)\", \"prediction label (0.5)\"])\n", + " \n", + " for _, row in foldDataset.iterrows():\n", + " imgPath = rootFile/f\"test/{'NO_NVB' if row['class'] == 'NOT_NVB' else row['class']}/Img0-{row['id']}.npy\"\n", + " rawIMG = defs.load_file_tensor(imgPath).to(device)\n", + " \n", + " rawIMG = testtransform(rawIMG)\n", + " rawIMG = rawIMG.repeat(1, 1, 1, 1)\n", + " \n", + " pred, _, _ = model((rawIMG, rawIMG))\n", + " pred = pred.flatten()\n", + " pred = torch.sigmoid(pred)\n", + " \n", + " newInfo = listNames.loc[listNames[\"列1\"].astype(str)+\".tiff\" == row[\"name\"]]\n", + " newLabel = newInfo[\"再判定\"].to_list()\n", + " \n", + " if len(newLabel) == 0:\n", + " newLabel = None\n", + " else:\n", + " if pd.isna(newInfo[\"再判定\"]).values[0]:\n", + " newLabel = \"*\"\n", + " else:\n", + " newLabel = \"no_nvb\" if newInfo[\"再判定\"].to_list()[0] == \"なし\" else \"nvb\"\n", + " writerOBJ.writerow([foldNum, th, row[\"name\"], pred.item(), \"nvb\" if row[\"label\"] == 1 else \"no_nvb\", newLabel, \"NVB\" if pred > th else \"NO_NVB\", \"NVB\" if pred > 0.5 else \"NO_NVB\", ])\n", + " \n", + " csvfile.close()\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "\n", + "torch.hub.load('facebookresearch/dino:main', 'dino_resnet50')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pyRARP", + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/imageViewer.py b/imageViewer.py new file mode 100644 index 0000000..aec8bd1 --- /dev/null +++ b/imageViewer.py @@ -0,0 +1,132 @@ +import cv2 +import numpy as np +from ultralytics import YOLO as YOLOv8 +import PySimpleGUI as sg + +def RemoveBlackBorder(image, shrink=True): + image = np.array(image) + + copyImg = cv2.cvtColor(image.copy(), cv2.COLOR_BGR2HSV_FULL) + mask = np.zeros(image[:,:,0].shape, dtype=np.uint8) + mask[(copyImg[:,:,1] > 35)] = 255 + copyImg = cv2.cvtColor(copyImg, cv2.COLOR_HSV2RGB_FULL) + resROI = cv2.bitwise_and(copyImg, copyImg, mask=mask) + + image_gray = cv2.cvtColor(resROI, cv2.COLOR_RGB2GRAY) + _, thresh = cv2.threshold(image_gray, 0, 255, cv2.THRESH_BINARY) + kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 15)) + morph = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel) + contours = cv2.findContours(morph, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) + contours = contours[0] if len(contours) == 2 else contours[1] + bigCont = max(contours, key=cv2.contourArea) + x, y, w, h = cv2.boundingRect(bigCont) + sfx, sfy = (w *0.01, h*0.07) if shrink else (0, 0) + crop = image[y +int(sfy) : y + h - int(sfy), x + int(sfx): x + w - int(sfx)] + return crop + +def RemoveBlackBorder2(image): + image = np.array(image) + + copyImg = cv2.cvtColor(image.copy(), cv2.COLOR_BGR2HSV) + h = copyImg[:,:,0] + mask = np.ones(h.shape, dtype=np.uint8) * 255 + th = (25, 175) + mask[(h > th[0]) & (h < th[1])] = 0 + copyImg = cv2.cvtColor(copyImg, cv2.COLOR_HSV2BGR) + resROI = cv2.bitwise_and(copyImg, copyImg, mask=mask) + + image_gray = cv2.cvtColor(resROI, cv2.COLOR_BGR2GRAY) + _, thresh = cv2.threshold(image_gray, 0, 255, cv2.THRESH_BINARY) + kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 15)) + morph = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel) + contours = cv2.findContours(morph, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) + contours = contours[0] if len(contours) == 2 else contours[1] + bigCont = max(contours, key=cv2.contourArea) + x, y, w, h = cv2.boundingRect(bigCont) + crop = image[y : y + h, x: x + w ] + return crop + +def LoadAndVeiwImge (Path:str, YOLO:float = None): + image = np.load(Path) + image = image.astype(np.uint8) + + print(image.shape) + + if YOLO > 0: + YoloModel = YOLOv8(model="RARP_YoloV8_ROI.pt") + res = YoloModel.predict(image, stream=True) + + for r in res: + conf = r.boxes.conf.cpu().numpy() + for i, box in enumerate(r.boxes.xyxy.cpu().numpy()): + if conf[i] > YOLO: + box = box.astype(int) + print (i, box, conf[i]) + #x, y = (box[0], box[1]) + #xw, yh = (box[2], box[3]) + cv2.rectangle(image, (box[0],box[1]), (box[2],box[3]), (0, 255, 150*i), 3) + + cv2.namedWindow("Output", cv2.WINDOW_NORMAL) + cv2.resizeWindow("Output", (1024, 720)) + cv2.imshow("Output", image) + cv2.waitKey(0) + cv2.destroyAllWindows() + +if __name__ == "__main__": + sg.theme('LightBlue') + + layout = [ + [sg.Text('Image Viewer', size=(40, 1), justification='center', font='Helvetica 20',key='-status-')], + [sg.Text('Camera number: ', size=(15, 1)), sg.InputText(default_text='', size=(80, 1),key='-Path-')], + [sg.Text('YOLO Conf.: ', size=(15, 1)), sg.InputText(default_text='0.40', size=(20, 1),key='-YOLO-')], + [sg.Checkbox("RAW Image", default=True, key="-NP_Array_IMG-"), sg.Checkbox("Remove Black Bars Old ver.", default=False, key="-oldVer-")], + [sg.Image(filename='', key='image')], + [ + sg.Button('YOLO', size=(10, 1), font='Helvetica 14',key ='-start-'), + sg.Button('Remove BB', size=(10, 1), font='Helvetica 14',key = '-Remove_BB-'), + sg.Button('View', size=(10, 1), font='Helvetica 14',key = '-verImg-'), + sg.Button('Exit', size=(10, 1), font='Helvetica 14', key='-exit-'), + ] + ] + + window = sg.Window('Image Viewer',layout, location=(100, 100)) + recording = False + + while True: + try: + event, vals = window.read(timeout=20) + match event: + case None | "-exit-": + break + case "-start-": + if vals["-NP_Array_IMG-"]: + vals["-YOLO-"] = 0 if vals["-YOLO-"] == "" else vals["-YOLO-"] + LoadAndVeiwImge(vals["-Path-"], float(vals["-YOLO-"])) + else: + sg.popup_error("Only RAW images are accepted *.npy") + case "-Remove_BB-": + image = np.load(vals["-Path-"]) if vals["-NP_Array_IMG-"] else cv2.imread(vals["-Path-"], cv2.IMREAD_COLOR) + if vals["-oldVer-"] : + image = RemoveBlackBorder(image, False) + else: + image = RemoveBlackBorder2 (image) + cv2.namedWindow("Output", cv2.WINDOW_NORMAL) + cv2.resizeWindow("Output", (1024, 720)) + cv2.imshow("Output", image) + cv2.waitKey(0) + cv2.destroyAllWindows() + case "-verImg-": + image = np.load(vals["-Path-"]) if vals["-NP_Array_IMG-"] else cv2.imread(vals["-Path-"], cv2.IMREAD_COLOR) + cv2.namedWindow("Output", cv2.WINDOW_NORMAL) + cv2.resizeWindow("Output", (1024, 720)) + cv2.imshow("Output", image) + cv2.waitKey(0) + cv2.destroyAllWindows() + + except Exception as e: + print(e) + + + window.close() + + diff --git a/lbp.ipynb b/lbp.ipynb new file mode 100644 index 0000000..e7bad56 --- /dev/null +++ b/lbp.ipynb @@ -0,0 +1,420 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torchvision\n", + "from torch.utils.data import DataLoader\n", + "from torchvision import transforms\n", + "import numpy as np\n", + "from pathlib import Path\n", + "import Models as M\n", + "import Loaders\n", + "import defs\n", + "import lightning as L\n", + "import torchmetrics\n", + "from lightning.pytorch.callbacks import ModelCheckpoint\n", + "from lightning.pytorch.loggers import TensorBoardLogger\n", + "from tqdm.notebook import tqdm\n", + "import warnings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def setup_seed(seed):\n", + " torch.manual_seed(seed)\n", + " torch.cuda.manual_seed_all(seed)\n", + " np.random.seed(seed)\n", + " torch.backends.cudnn.deterministic = True" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "setup_seed(2023)\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "Fold = 4\n", + "numWorkers = 0\n", + "batchSize = 17" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Dataset = Loaders.RARP_DatasetCreator(\n", + " \"./DataSet_Crop1\",\n", + " FoldSeed=505,\n", + " createFile=True,\n", + " SavePath=\"./DataSetCrop1\",\n", + " Fold=5,\n", + " removeBlackBar=False\n", + ")\n", + "cropSize = 256\n", + "\n", + "Dataset.CreateFolds()\n", + "\n", + "checkPtCallback = ModelCheckpoint(monitor='val_acc', save_top_k=10, mode='max')\n", + " \n", + "traintransform = torch.nn.Sequential(\n", + " transforms.Normalize(Dataset.mean, Dataset.std),\n", + " transforms.Resize(cropSize, antialias=True),\n", + " transforms.RandomHorizontalFlip(0.6),\n", + " transforms.RandomAffine(\n", + " degrees=(-5, 5), translate=(0, 0.05), scale=(0.9, 1.1), \n", + " fill=5\n", + " ),\n", + " transforms.RandomResizedCrop((224, 224), scale=(0.35, 1), antialias=True),\n", + ").to(device)\n", + "\n", + "valtransform = torch.nn.Sequential(\n", + " transforms.Resize(256, antialias=True),\n", + " transforms.CenterCrop(224),\n", + " transforms.Normalize(Dataset.mean, Dataset.std)\n", + ").to(device)\n", + "\n", + "testtransform = torch.nn.Sequential(\n", + " transforms.Resize(256, antialias=True),\n", + " transforms.CenterCrop(224),\n", + " transforms.Normalize(Dataset.mean, Dataset.std)\n", + ").to(device)\n", + "\n", + "rootFile = Dataset.CVS_File.parent.parent/f\"fold_{Fold}\"\n", + "\n", + "trainDataset = torchvision.datasets.DatasetFolder(\n", + " str (rootFile/\"train\"),\n", + " loader=defs.load_file_tensor,\n", + " extensions=\"npy\",\n", + " transform=traintransform\n", + ")\n", + "\n", + "valDataset = torchvision.datasets.DatasetFolder(\n", + " str (rootFile/\"val\"),\n", + " loader=defs.load_file_tensor,\n", + " extensions=\"npy\",\n", + " transform=valtransform\n", + ")\n", + "\n", + "testDataset = torchvision.datasets.DatasetFolder(\n", + " str (rootFile/\"test\"),\n", + " loader=defs.load_file_tensor,\n", + " extensions=\"npy\",\n", + " transform=testtransform\n", + ")\n", + "\n", + "Train_DataLoader = DataLoader(\n", + " trainDataset, \n", + " batch_size=batchSize, \n", + " num_workers=numWorkers, \n", + " shuffle=True, \n", + " pin_memory=True)\n", + "Val_DataLoader = DataLoader(\n", + " valDataset, \n", + " batch_size=batchSize, \n", + " num_workers=numWorkers, \n", + " shuffle=False, \n", + " pin_memory=True)\n", + "Test_DataLoader = DataLoader(\n", + " testDataset, \n", + " batch_size=batchSize, \n", + " num_workers=numWorkers, \n", + " shuffle=False, \n", + " pin_memory=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "img, label = next(iter(Train_DataLoader))\n", + "img = img.float().to(device)\n", + "label = label.to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "modelPath = Path(\"./log_restnet18_X6/lightning_logs/version_14/checkpoints/epoch=22-step=92.ckpt\")\n", + "\n", + "model = M.ResNet18_UNet(M.RARP_NVB_ResNet18.load_from_checkpoint(modelPath, strict=False)).to(device)\n", + "model.eval()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p, u = model(img)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "torch.sigmoid(p), u" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "_, axis = plt.subplots(2, 2, figsize=(9, 9))\n", + "\n", + "img = u[0].cpu()\n", + "img = img.detach().numpy().transpose((1, 2, 0))\n", + "img2 = np.clip((Dataset.std * img + Dataset.mean) / 255, 0, 1)\n", + "\n", + "axis[0][0].imshow(img2, )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "listCkpt = [\n", + " Path(\"./log_ResNet50_X2/lightning_logs/version_4/checkpoints/epoch=13-step=28.ckpt\"),\n", + " Path(\"./log_ResNet50_X2/lightning_logs/version_6/checkpoints/epoch=9-step=20.ckpt\"),\n", + " Path(\"./log_ResNet50_X2/lightning_logs/version_11/checkpoints/epoch=8-step=18.ckpt\")\n", + "]\n", + "\n", + "models = [M.RARP_NVB_ResNet50.load_from_checkpoint(ckpt, strict=False) for ckpt in listCkpt]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "models = [m.eval().to(device) for m in models]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p = [torch.sigmoid(m(img)) for m in models]\n", + "torch.cat(p, dim=1), label" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data = torch.cat(p, dim=1)\n", + "test = label.unsqueeze(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data1 = data.mean(dim=1).detach()\n", + "label1 = label.float()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "torchmetrics.Accuracy('binary').to(device)(data1, label1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data = torch.randn(100, 10)\n", + "test = torch.randn(1, 10)\n", + "\n", + "dist = torch.norm(data - test, dim=1, p=None)\n", + "knn = dist.topk(2, largest=False)\n", + "knn" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Any\n", + "\n", + "\n", + "class RARP_Ensemble_ResNet50(L.LightningModule):\n", + " def __init__(self, models:list):\n", + " super().__init__()\n", + " \n", + " self.ListModels = models \n", + " input_p = len(self.ListModels)\n", + " \n", + " self.classifier = torch.nn.Sequential(\n", + " torch.nn.Linear(input_p, input_p + 1),\n", + " torch.nn.ReLU(),\n", + " torch.nn.Linear(input_p + 1, input_p),\n", + " torch.nn.ReLU(),\n", + " torch.nn.Linear(input_p, 1) \n", + " )\n", + " \n", + " #self.classifier = torch.nn.Linear(input_p, 1)\n", + " \n", + " #self.lossFN = torch.nn.CrossEntropyLoss(label_smoothing=0.5) \n", + " self.lossFN = torch.nn.MSELoss()\n", + " self.train_acc = torchmetrics.Accuracy('binary')\n", + " self.val_acc = torchmetrics.Accuracy('binary')\n", + " self.test_acc = torchmetrics.Accuracy('binary')\n", + " self.f1Score = torchmetrics.F1Score('binary')\n", + " self.f1ScoreTest = torchmetrics.F1Score('binary')\n", + "\n", + " def forward(self, data):\n", + " data = data.float()\n", + " with torch.no_grad():\n", + " p = [m(data) for m in self.ListModels]\n", + " p = torch.sigmoid(torch.cat(p, dim=1))\n", + " x = self.classifier(p)\n", + " return x\n", + " \n", + " def _shared_step(self, batch):\n", + " img, label = batch\n", + " label = label.float()\n", + " pred = self.forward(img).flatten()\n", + " loss = self.lossFN(pred, label)\n", + " \n", + " predicted_labels = torch.sigmoid(pred)\n", + " \n", + " return loss, label, predicted_labels\n", + " \n", + " def training_step(self, batch, batch_idx):\n", + " loss, true_labels, predicted_labels = self._shared_step(batch)\n", + "\n", + " self.log(\"train_loss\", loss)\n", + " self.train_acc.update(predicted_labels, true_labels)\n", + " self.log(\"train_acc\", self.train_acc, on_epoch=True, on_step=False)\n", + "\n", + " return loss\n", + " \n", + " def validation_step(self, batch, batch_idx):\n", + " loss, true_labels, predicted_labels = self._shared_step(batch)\n", + " self.log(\"val_loss\", loss)\n", + " self.val_acc.update(predicted_labels, true_labels)\n", + " self.f1Score.update(predicted_labels, true_labels)\n", + " self.log(\"val_acc\", self.val_acc, on_epoch=True, on_step=False, prog_bar=True)\n", + " self.log(\"val_f1\", self.f1Score, on_epoch=True, on_step=False, prog_bar=True)\n", + "\n", + " return loss\n", + "\n", + " def test_step(self, batch, batch_idx):\n", + " loss, true_labels, predicted_labels = self._shared_step(batch)\n", + " self.test_acc.update(predicted_labels, true_labels)\n", + " self.f1ScoreTest.update(predicted_labels, true_labels)\n", + " self.log(\"test_acc\", self.test_acc, on_epoch=True, on_step=False)\n", + " self.log(\"test_f1\", self.f1ScoreTest, on_epoch=True, on_step=False)\n", + "\n", + " def configure_optimizers(self):\n", + " optimizer = torch.optim.Adam(self.classifier.parameters(), lr=1e-4) \n", + " return [optimizer]\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Model = RARP_Ensemble_ResNet50(models)\n", + "LogFileName = \"log_debug\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Model.classifier.parameters" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "warnings.simplefilter(\"ignore\")\n", + "\n", + "trainer = L.Trainer(\n", + " accelerator='gpu', \n", + " devices=1, \n", + " logger=TensorBoardLogger(save_dir=f\"./{LogFileName}\"),\n", + " log_every_n_steps=1, \n", + " callbacks=checkPtCallback,\n", + " max_epochs=50,\n", + ")\n", + "\n", + "trainer.fit(Model, train_dataloaders=Train_DataLoader, val_dataloaders=Val_DataLoader)\n", + " #trainer.callbacks\n", + "trainer.test(Model, dataloaders=Test_DataLoader, ckpt_path=\"best\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "TestRARP", + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/optimizeHP.ipynb b/optimizeHP.ipynb new file mode 100644 index 0000000..f0c7c53 --- /dev/null +++ b/optimizeHP.ipynb @@ -0,0 +1,445 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import Models as M\n", + "import Loaders\n", + "import defs\n", + "import numpy as np\n", + "import lightning.pytorch as pl\n", + "import lightning.pytorch.callbacks as callbk\n", + "import optuna\n", + "from optuna.integration import PyTorchLightningPruningCallback\n", + "from packaging import version\n", + "import torch\n", + "from torch.utils.data import DataLoader\n", + "import torchvision\n", + "from torchvision import transforms" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OK\n" + ] + } + ], + "source": [ + "if version.parse(pl.__version__) < version.parse(\"1.6.0\"):\n", + " raise RuntimeError(\"PyTorch Lightning>=1.6.0 is required for this example.\")\n", + "else:\n", + " print(\"OK\")" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataSet_SB_Ando_Crop_seed_None\\fold_0\n" + ] + } + ], + "source": [ + "def setup_seed(seed):\n", + " torch.manual_seed(seed)\n", + " torch.cuda.manual_seed_all(seed)\n", + " np.random.seed(seed)\n", + " torch.backends.cudnn.deterministic = True\n", + "\n", + "Dataset = Loaders.RARP_DatasetCreator(\n", + " \"./DataSet_AndoCrop\",\n", + " FoldSeed=None,\n", + " createFile=True,\n", + " SavePath=\"./DataSet_SB_Ando_Crop\",\n", + " Fold=5,\n", + " removeBlackBar=False,\n", + ")\n", + "\n", + "Dataset.CreateFolds()\n", + "\n", + "Fold = 0\n", + "\n", + " \n", + "Dataset.mean, Dataset.std = ([30.38144216, 42.03988769, 97.8896116], [40.63141752, 44.26910074, 50.29294373])\n", + "\n", + "setup_seed(2023)\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "InitResize = (256,256)\n", + "ImgResize = (224, 224)\n", + "\n", + "rootFile = (Dataset.CVS_File.parent.parent/f\"fold_{Fold}\")\n", + "print (rootFile)\n", + "\n", + "traintransform = torch.nn.Sequential(\n", + " transforms.Resize(InitResize), \n", + " transforms.RandomCrop(ImgResize),\n", + " transforms.RandomAffine(\n", + " degrees=(-5, 5), scale=(0.9, 1.1), \n", + " fill=5\n", + " ),\n", + " transforms.RandomHorizontalFlip(1.0),\n", + " transforms.Normalize(Dataset.mean, Dataset.std),\n", + ").to(device)\n", + "\n", + "valtransform = torch.nn.Sequential( \n", + " transforms.Resize(ImgResize), \n", + " transforms.Normalize(Dataset.mean, Dataset.std)\n", + ").to(device)\n", + "\n", + "testtransform = torch.nn.Sequential(\n", + " transforms.Resize(ImgResize,antialias=True),\n", + " transforms.Normalize(Dataset.mean, Dataset.std)\n", + ").to(device)\n", + "\n", + "trainDataset = torchvision.datasets.DatasetFolder(\n", + " str (rootFile/\"train\"),\n", + " loader=defs.load_file_tensor,\n", + " extensions=\"npy\",\n", + " transform=traintransform\n", + ")\n", + "\n", + "valDataset = torchvision.datasets.DatasetFolder(\n", + " str (rootFile/\"val\"),\n", + " loader=defs.load_file_tensor,\n", + " extensions=\"npy\",\n", + " transform=valtransform\n", + ")\n", + "\n", + "testDataset = torchvision.datasets.DatasetFolder(\n", + " str (rootFile/\"test\"),\n", + " loader=defs.load_file_tensor,\n", + " extensions=\"npy\",\n", + " transform=testtransform\n", + ") \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "modelSSL = M.RARP_NVB_ResNet50.load_from_checkpoint(\"./log_ResNet50_X10/lightning_logs/version_8/checkpoints/RARP-epoch=5.ckpt\")\n", + "model = M.RARP_NVB_VAN(None, M.TypeLossFunction.BCEWithLogits)\n", + "\n", + "Test_DataLoader = DataLoader(\n", + " testDataset, \n", + " batch_size=8, \n", + " num_workers=0, \n", + " shuffle=False, \n", + " pin_memory=True\n", + ")\n", + "\n", + "Train_DataLoader = DataLoader(\n", + " trainDataset, \n", + " batch_size=8, \n", + " num_workers=0, \n", + " shuffle=True, \n", + " pin_memory=True\n", + ")\n", + "\n", + "Val_DataLoader = DataLoader(\n", + " valDataset, \n", + " batch_size=8, \n", + " num_workers=0, \n", + " shuffle=False, \n", + " pin_memory=True\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "EPOCHS = 150\n", + "L1_ON = True\n", + "L2_ON = False\n", + "\n", + "def objective(trail: optuna.trial.Trial) -> float:\n", + " lr = trail.suggest_float(\"lr\", 1e-4, 1e-2, log=True) \n", + " l1 = trail.suggest_float(\"L1\", 1e-5, 1e-3, log=True) if L1_ON else None\n", + " l2 = trail.suggest_float(\"L2\", 1e-5, 1e-4, log=True) if L2_ON else 0\n", + " #n_layers = trail.suggest_int(\"n_layers\", 1, 4)\n", + " #dropout = trail.suggest_float(\"dropout\", 0.2, 0.5)\n", + " #output_Dims = [\n", + " # trail.suggest_int(\"n_layers_l{}\".format(i), 8, 512, log=True) for i in range(n_layers)\n", + " #]\n", + " \n", + " batchSize = trail.suggest_categorical(\"batch_size\", [8, 16, 32])\n", + " #lossFn = trail.suggest_categorical(\"LossFN\", [\n", + " # M.TypeLossFunction.CrossEntropy,\n", + " # M.TypeLossFunction.BCEWithLogits,\n", + " # M.TypeLossFunction.FocalLoss,\n", + " # M.TypeLossFunction.HingeLoss,\n", + " #])\n", + " Optimizer = trail.suggest_categorical(\"Optimizer\", [\"Adam\", \"Adamax\", \"Nadam\"])\n", + " numWorkers = 8\n", + " \n", + " model = M.RARP_NVB_ResNet50(None, M.TypeLossFunction.BCEWithLogits, config={\"lr\": lr, \"L1\": l1, \"L2\": l2, \"Optimizer\": Optimizer})\n", + " \n", + " Train_DataLoader = DataLoader(\n", + " trainDataset, \n", + " batch_size=batchSize, \n", + " num_workers=numWorkers, \n", + " shuffle=True, \n", + " pin_memory=True,\n", + " persistent_workers=True,\n", + " )\n", + "\n", + " Val_DataLoader = DataLoader(\n", + " valDataset, \n", + " batch_size=batchSize, \n", + " num_workers=numWorkers, \n", + " shuffle=False, \n", + " pin_memory=True,\n", + " persistent_workers=True,\n", + " )\n", + "\n", + " \n", + " \n", + " trainer = pl.Trainer(\n", + " logger=True,\n", + " enable_checkpointing=False,\n", + " max_epochs=EPOCHS,\n", + " accelerator=\"auto\",\n", + " log_every_n_steps=5, \n", + " devices=1,\n", + " callbacks=[PyTorchLightningPruningCallback(trail, monitor=\"val_acc\")],\n", + " )\n", + " \n", + " hyperparameters = dict(\n", + " lr = lr,\n", + " l1 = l1,\n", + " l2 = l2,\n", + " #lossFN = lossFn,\n", + " OptimizerFN = Optimizer,\n", + " #n_layers = n_layers, \n", + " #dropout = dropout, \n", + " #output_dims = output_Dims,\n", + " batch_size = batchSize,\n", + " )\n", + " \n", + " trainer.logger.log_hyperparams(hyperparameters)\n", + " \n", + " trainer.fit(model, train_dataloaders=Train_DataLoader, val_dataloaders=Val_DataLoader)\n", + " \n", + " return trainer.callback_metrics[\"val_acc\"].item()" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [], + "source": [ + "modelSSL.to(device)\n", + "modelSSL.eval()\n", + "\n", + "predictions = []\n", + "labels = []\n", + "\n", + "th = 0.5\n", + "\n", + "with torch.no_grad():\n", + " for data, label in iter(Test_DataLoader):\n", + " data = data.float().to(device)\n", + " label = label.to(device)\n", + " pred = modelSSL(data).flatten()\n", + " predictions.append(torch.sigmoid(pred))\n", + " labels.append(label)\n", + " \n", + "labels = torch.cat(labels)\n", + "predictions = torch.cat(predictions)\n", + "\n", + "PseudoLabels = (labels > th) * 1.0" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([0.3462, 0.4296, 0.3121, 0.3655, 0.4479, 0.4114, 0.4281, 0.5280, 0.8679, 0.7945, 0.5753, 0.7600, 0.9237, 0.6994, 0.4121, 0.5313], device='cuda:0'),\n", + " tensor([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1], device='cuda:0'),\n", + " tensor([0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 1.], device='cuda:0'))" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "predictions, labels, PseudoLabels" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.linear_model import RANSACRegressor\n", + "\n", + "ransac = RANSACRegressor()\n", + "X_inliers = []\n", + "y_inliers = []\n", + "\n", + "for class_idx in np.unique(labels):\n", + " class_mask = labels == class_idx\n", + " if np.sum(class_mask) > 0:\n", + " ransac.fit(predictions[class_mask], labels[class_mask])\n", + " inlier_mask = ransac.inlier_mask_\n", + " X_inliers.append(predictions[class_mask][inlier_mask])\n", + " y_inliers.append(labels[class_mask][inlier_mask])" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ -0], dtype=float32)" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ransac.estimator_.coef_" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "X_inliers = np.vstack(X_inliers)\n", + "y_inliers = np.concatenate(y_inliers)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([[ 0.40963],\n", + " [ 0.48141],\n", + " [ 0.40876],\n", + " [ 0.41222],\n", + " [ 0.58274],\n", + " [ 0.48825],\n", + " [ 0.48407],\n", + " [ 0.62485],\n", + " [ 0.84806],\n", + " [ 0.88766],\n", + " [ 0.59436],\n", + " [ 0.80752],\n", + " [ 0.88708],\n", + " [ 0.79638],\n", + " [ 0.50623],\n", + " [ 0.61157]], dtype=float32),\n", + " array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int64))" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_inliers, y_inliers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%%capture\n", + "pruning = True\n", + "\n", + "pruner = optuna.pruners.SuccessiveHalvingPruner() if pruning else optuna.pruners.NopPruner()\n", + "#Sampler = optuna.samplers.GPSampler(seed=2024)\n", + "Sampler = optuna.samplers.TPESampler()\n", + "#Sampler = optuna.samplers.GridSampler()\n", + "\n", + "\n", + "study = optuna.create_study(direction=\"maximize\", pruner=pruner, sampler=Sampler)\n", + "study.optimize(objective, n_trials=100, timeout=600)\n", + "\n", + "print(\"Number of finished trials: {}\".format(len(study.trials)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\"Best trial:\")\n", + "trial = study.best_trial\n", + "\n", + "print(\" Value: {}\".format(trial.value))\n", + "\n", + "print(\" Params: \")\n", + "for key, value in trial.params.items():\n", + " print(\" {}: {}\".format(key, value))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pyRARP", + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/train-EFold0.yaml b/train-EFold0.yaml new file mode 100644 index 0000000..c1a228b --- /dev/null +++ b/train-EFold0.yaml @@ -0,0 +1,11 @@ +models: + ResNet50: + - ./log_ResNet50_X8/lightning_logs/version_0/checkpoints/RARP-epoch=11.ckpt + ResNet18: + - ./log_restnet18_X8/lightning_logs/version_0/checkpoints/RARP-epoch=9.ckpt + MobileNetV2: + - ./log_MobileNetV2_X8/lightning_logs/version_0/checkpoints/RARP-epoch=22.ckpt + EfficientNetV2: + - ./log_EfficientNetV2_X8/lightning_logs/version_0/checkpoints/RARP-epoch=2.ckpt + DenseNet169: + - ./log_DenseNet169_X8/lightning_logs/version_0/checkpoints/RARP-epoch=6.ckpt diff --git a/train-EFold1.yaml b/train-EFold1.yaml new file mode 100644 index 0000000..8639916 --- /dev/null +++ b/train-EFold1.yaml @@ -0,0 +1,11 @@ +models: + ResNet50: + - ./log_ResNet50_X8/lightning_logs/version_1/checkpoints/RARP-epoch=5.ckpt + ResNet18: + - ./log_restnet18_X8/lightning_logs/version_1/checkpoints/RARP-epoch=23.ckpt + MobileNetV2: + - ./log_MobileNetV2_X8/lightning_logs/version_1/checkpoints/RARP-epoch=48.ckpt + EfficientNetV2: + - ./log_EfficientNetV2_X8/lightning_logs/version_1/checkpoints/RARP-epoch=6.ckpt + DenseNet169: + - ./log_DenseNet169_X8/lightning_logs/version_1/checkpoints/RARP-epoch=14.ckpt diff --git a/train-EFold2.yaml b/train-EFold2.yaml new file mode 100644 index 0000000..32625c3 --- /dev/null +++ b/train-EFold2.yaml @@ -0,0 +1,11 @@ +models: + ResNet50: + - ./log_ResNet50_X8/lightning_logs/version_2/checkpoints/RARP-epoch=14.ckpt + ResNet18: + - ./log_restnet18_X8/lightning_logs/version_2/checkpoints/RARP-epoch=9.ckpt + MobileNetV2: + - ./log_MobileNetV2_X8/lightning_logs/version_2/checkpoints/RARP-epoch=23.ckpt + EfficientNetV2: + - ./log_EfficientNetV2_X8/lightning_logs/version_2/checkpoints/RARP-epoch=3.ckpt + DenseNet169: + - ./log_DenseNet169_X8/lightning_logs/version_2/checkpoints/RARP-epoch=4.ckpt diff --git a/train-EFold3.yaml b/train-EFold3.yaml new file mode 100644 index 0000000..fa5ec3e --- /dev/null +++ b/train-EFold3.yaml @@ -0,0 +1,11 @@ +models: + ResNet50: + - ./log_ResNet50_X8/lightning_logs/version_3/checkpoints/RARP-epoch=9.ckpt + ResNet18: + - ./log_restnet18_X8/lightning_logs/version_3/checkpoints/RARP-epoch=5.ckpt + MobileNetV2: + - ./log_MobileNetV2_X8/lightning_logs/version_3/checkpoints/RARP-epoch=6.ckpt + EfficientNetV2: + - ./log_EfficientNetV2_X8/lightning_logs/version_3/checkpoints/RARP-epoch=5.ckpt + DenseNet169: + - ./log_DenseNet169_X8/lightning_logs/version_3/checkpoints/RARP-epoch=1.ckpt diff --git a/train-EFold4.yaml b/train-EFold4.yaml new file mode 100644 index 0000000..3374299 --- /dev/null +++ b/train-EFold4.yaml @@ -0,0 +1,11 @@ +models: + ResNet50: + - ./log_ResNet50_X8/lightning_logs/version_4/checkpoints/RARP-epoch=17.ckpt + ResNet18: + - ./log_restnet18_X8/lightning_logs/version_4/checkpoints/RARP-epoch=7.ckpt + MobileNetV2: + - ./log_MobileNetV2_X8/lightning_logs/version_4/checkpoints/RARP-epoch=32.ckpt + EfficientNetV2: + - ./log_EfficientNetV2_X8/lightning_logs/version_4/checkpoints/RARP-epoch=20.ckpt + DenseNet169: + - ./log_DenseNet169_X8/lightning_logs/version_4/checkpoints/RARP-epoch=1.ckpt diff --git a/van.py b/van.py new file mode 100644 index 0000000..55daeb1 --- /dev/null +++ b/van.py @@ -0,0 +1,370 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from functools import partial + +from timm.models.layers import DropPath, to_2tuple, trunc_normal_ +from timm.models.registry import register_model +from timm.models.vision_transformer import _cfg +import math + +class Mlp(nn.Module): + def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.): + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = nn.Conv2d(in_features, hidden_features, 1) + self.dwconv = DWConv(hidden_features) + self.act = act_layer() + self.fc2 = nn.Conv2d(hidden_features, out_features, 1) + self.drop = nn.Dropout(drop) + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + elif isinstance(m, nn.Conv2d): + fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + fan_out //= m.groups + m.weight.data.normal_(0, math.sqrt(2.0 / fan_out)) + if m.bias is not None: + m.bias.data.zero_() + + def forward(self, x): + x = self.fc1(x) + x = self.dwconv(x) + x = self.act(x) + x = self.drop(x) + x = self.fc2(x) + x = self.drop(x) + return x + + + + +class LKA(nn.Module): + def __init__(self, dim): + super().__init__() + self.conv0 = nn.Conv2d(dim, dim, 5, padding=2, groups=dim) + self.conv_spatial = nn.Conv2d(dim, dim, 7, stride=1, padding=9, groups=dim, dilation=3) + self.conv1 = nn.Conv2d(dim, dim, 1) + + + def forward(self, x): + u = x.clone() + attn = self.conv0(x) + attn = self.conv_spatial(attn) + attn = self.conv1(attn) + + return u * attn + + +class Attention(nn.Module): + def __init__(self, d_model): + super().__init__() + + self.proj_1 = nn.Conv2d(d_model, d_model, 1) + self.activation = nn.GELU() + self.spatial_gating_unit = LKA(d_model) + self.proj_2 = nn.Conv2d(d_model, d_model, 1) + + def forward(self, x): + shorcut = x.clone() + x = self.proj_1(x) + x = self.activation(x) + x = self.spatial_gating_unit(x) + x = self.proj_2(x) + x = x + shorcut + return x + + +class Block(nn.Module): + def __init__(self, dim, mlp_ratio=4., drop=0.,drop_path=0., act_layer=nn.GELU): + super().__init__() + self.norm1 = nn.BatchNorm2d(dim) + self.attn = Attention(dim) + self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity() + + self.norm2 = nn.BatchNorm2d(dim) + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop) + layer_scale_init_value = 1e-2 + self.layer_scale_1 = nn.Parameter( + layer_scale_init_value * torch.ones((dim)), requires_grad=True) + self.layer_scale_2 = nn.Parameter( + layer_scale_init_value * torch.ones((dim)), requires_grad=True) + + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + elif isinstance(m, nn.Conv2d): + fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + fan_out //= m.groups + m.weight.data.normal_(0, math.sqrt(2.0 / fan_out)) + if m.bias is not None: + m.bias.data.zero_() + + def forward(self, x): + x = x + self.drop_path(self.layer_scale_1.unsqueeze(-1).unsqueeze(-1) * self.attn(self.norm1(x))) + x = x + self.drop_path(self.layer_scale_2.unsqueeze(-1).unsqueeze(-1) * self.mlp(self.norm2(x))) + return x + + +class OverlapPatchEmbed(nn.Module): + """ Image to Patch Embedding + """ + + def __init__(self, img_size=224, patch_size=7, stride=4, in_chans=3, embed_dim=768): + super().__init__() + patch_size = to_2tuple(patch_size) + self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=stride, + padding=(patch_size[0] // 2, patch_size[1] // 2)) + self.norm = nn.BatchNorm2d(embed_dim) + + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + elif isinstance(m, nn.Conv2d): + fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + fan_out //= m.groups + m.weight.data.normal_(0, math.sqrt(2.0 / fan_out)) + if m.bias is not None: + m.bias.data.zero_() + + def forward(self, x): + x = self.proj(x) + _, _, H, W = x.shape + x = self.norm(x) + return x, H, W + + +class VAN(nn.Module): + def __init__(self, img_size=224, in_chans=3, num_classes=1000, embed_dims=[64, 128, 256, 512], + mlp_ratios=[4, 4, 4, 4], drop_rate=0., drop_path_rate=0., norm_layer=nn.LayerNorm, + depths=[3, 4, 6, 3], num_stages=4, flag=False): + super().__init__() + if flag == False: + self.num_classes = num_classes + self.depths = depths + self.num_stages = num_stages + + dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] # stochastic depth decay rule + cur = 0 + + for i in range(num_stages): + patch_embed = OverlapPatchEmbed(img_size=img_size if i == 0 else img_size // (2 ** (i + 1)), + patch_size=7 if i == 0 else 3, + stride=4 if i == 0 else 2, + in_chans=in_chans if i == 0 else embed_dims[i - 1], + embed_dim=embed_dims[i]) + + block = nn.ModuleList([Block( + dim=embed_dims[i], mlp_ratio=mlp_ratios[i], drop=drop_rate, drop_path=dpr[cur + j]) + for j in range(depths[i])]) + norm = norm_layer(embed_dims[i]) + cur += depths[i] + + setattr(self, f"patch_embed{i + 1}", patch_embed) + setattr(self, f"block{i + 1}", block) + setattr(self, f"norm{i + 1}", norm) + + # classification head + self.head = nn.Linear(embed_dims[3], num_classes) if num_classes > 0 else nn.Identity() + + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + elif isinstance(m, nn.Conv2d): + fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + fan_out //= m.groups + m.weight.data.normal_(0, math.sqrt(2.0 / fan_out)) + if m.bias is not None: + m.bias.data.zero_() + + def freeze_patch_emb(self): + self.patch_embed1.requires_grad = False + + @torch.jit.ignore + def no_weight_decay(self): + return {'pos_embed1', 'pos_embed2', 'pos_embed3', 'pos_embed4', 'cls_token'} # has pos_embed may be better + + def get_classifier(self): + return self.head + + def reset_classifier(self, num_classes, global_pool=''): + self.num_classes = num_classes + self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity() + + def forward_features(self, x): + B = x.shape[0] + + for i in range(self.num_stages): + patch_embed = getattr(self, f"patch_embed{i + 1}") + block = getattr(self, f"block{i + 1}") + norm = getattr(self, f"norm{i + 1}") + x, H, W = patch_embed(x) + for blk in block: + x = blk(x) + x = x.flatten(2).transpose(1, 2) + x = norm(x) + if i != self.num_stages - 1: + x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous() + + return x.mean(dim=1) + + def forward(self, x): + x = self.forward_features(x) + x = self.head(x) + + return x + + +class DWConv(nn.Module): + def __init__(self, dim=768): + super(DWConv, self).__init__() + self.dwconv = nn.Conv2d(dim, dim, 3, 1, 1, bias=True, groups=dim) + + def forward(self, x): + x = self.dwconv(x) + return x + + +def _conv_filter(state_dict, patch_size=16): + """ convert patch embedding weight from manual patchify + linear proj to conv""" + out_dict = {} + for k, v in state_dict.items(): + if 'patch_embed.proj.weight' in k: + v = v.reshape((v.shape[0], 3, patch_size, patch_size)) + out_dict[k] = v + + return out_dict + + +model_urls = { + "van_b0": "https://huggingface.co/Visual-Attention-Network/VAN-Tiny-original/resolve/main/van_tiny_754.pth.tar", + "van_b1": "https://huggingface.co/Visual-Attention-Network/VAN-Small-original/resolve/main/van_small_811.pth.tar", + "van_b2": "https://huggingface.co/Visual-Attention-Network/VAN-Base-original/resolve/main/van_base_828.pth.tar", + "van_b3": "https://huggingface.co/Visual-Attention-Network/VAN-Large-original/resolve/main/van_large_839.pth.tar", +} + + +def load_model_weights(model, arch, kwargs): + url = model_urls[arch] + checkpoint = torch.hub.load_state_dict_from_url( + url=url, map_location="cpu", check_hash=True + ) + strict = True + if "num_classes" in kwargs and kwargs["num_classes"] != 1000: + strict = False + del checkpoint["state_dict"]["head.weight"] + del checkpoint["state_dict"]["head.bias"] + model.load_state_dict(checkpoint["state_dict"], strict=strict) + return model + + +@register_model +def van_b0(pretrained=False, **kwargs): + model = VAN( + embed_dims=[32, 64, 160, 256], mlp_ratios=[8, 8, 4, 4], + norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[3, 3, 5, 2], + **kwargs) + model.default_cfg = _cfg() + if pretrained: + model = load_model_weights(model, "van_b0", kwargs) + return model + + +@register_model +def van_b1(pretrained=False, **kwargs) -> VAN: + model = VAN( + embed_dims=[64, 128, 320, 512], mlp_ratios=[8, 8, 4, 4], + norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[2, 2, 4, 2], + **kwargs) + model.default_cfg = _cfg() + if pretrained: + model = load_model_weights(model, "van_b1", kwargs) + return model + +@register_model +def van_b2(pretrained=False, **kwargs): + model = VAN( + embed_dims=[64, 128, 320, 512], mlp_ratios=[8, 8, 4, 4], + norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[3, 3, 12, 3], + **kwargs) + model.default_cfg = _cfg() + if pretrained: + model = load_model_weights(model, "van_b2", kwargs) + return model + +@register_model +def van_b3(pretrained=False, **kwargs): + model = VAN( + embed_dims=[64, 128, 320, 512], mlp_ratios=[8, 8, 4, 4], + norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[3, 5, 27, 3], + **kwargs) + model.default_cfg = _cfg() + if pretrained: + model = load_model_weights(model, "van_b3", kwargs) + return model + +@register_model +def van_b4(pretrained=False, **kwargs): + model = VAN( + embed_dims=[64, 128, 320, 512], mlp_ratios=[8, 8, 4, 4], + norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[3, 6, 40, 3], + **kwargs) + model.default_cfg = _cfg() + if pretrained: + model = load_model_weights(model, "van_b4", kwargs) + return model + + +@register_model +def van_b5(pretrained=False, **kwargs): + model = VAN( + embed_dims=[96, 192, 480, 768], mlp_ratios=[8, 8, 4, 4], + norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[3, 3, 24, 3], + **kwargs) + model.default_cfg = _cfg() + if pretrained: + model = load_model_weights(model, "van_b5", kwargs) + return model + + +@register_model +def van_b6(pretrained=False, **kwargs): + model = VAN( + embed_dims=[96, 192, 384, 768], mlp_ratios=[8, 8, 4, 4], + norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[6,6,90,6], + **kwargs) + model.default_cfg = _cfg() + if pretrained: + model = load_model_weights(model, "van_b6", kwargs) + return model +