updates

index.ipynb

@@ -0,0 +1,58 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Anomaly Detection in Camera Trap Images - Implementation\n",
+    "This is an index file for the implementation part of my bachelor thesis 'Anomaly Detection in Camera Trap Images'."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Approach 1: Lapse Frame Differencing\n",
+    " - *approach1a_basic_frame_differencing.ipynb*: Implementation.\n",
+    " - *approach1b_histograms.ipynb*: Discarded similar approach using histogram distribution to compare Lapse and Motion images.\n",
+    "\n",
+    "## Approach 2: Median Frame Differencing\n",
+    " - *approach2_background_estimation.ipynb*: Implementation.\n",
+    "\n",
+    "## Approach 3: Bag of Visual Words\n",
+    " - *approach3_local_features.ipynb*: Visualizations and evaluation of single trainings.\n",
+    " - *approach3_boxplot.ipynb*: Boxplot to compare multiple vocabularies generated using random prototypes.\n",
+    "\n",
+    "## Approach 4: Autoencoder\n",
+    " - *approach4_autoencoder.ipynb*: Visualizations and evaluation of single trainings.\n",
+    " - *approach4_boxplot.ipynb*: Boxplot to compare multiple trainings."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.10.4 ('pytorch-gpu')",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.10.4"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "17cd5c528a3345b75540c61f907eece919c031d57a2ca1e5653325af249173c9"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

py/ImageUtils.py

@@ -49,6 +49,7 @@ def save_image(image, filename: str, title: str, colorbar=False, size=(8, 5), **
         colorbar (bool, optional): Display colorbars. Defaults to False.
         size (tuple, optional): plt size (width, height). Defaults to (8, 5).
     """
+    plt.ioff()
     plt.figure(figsize=size)
     plt.imshow(image, **imshowargs)
     plt.title(title)

py/PlotUtils.py

@@ -5,6 +5,8 @@ def plot_roc_curve(test_labels: list, test_df: list, title: str, figsize=(8, 8),
     fpr, tpr, thresholds = roc_curve(test_labels, test_df)
     auc_score = auc(fpr, tpr)
 
+    if not show:
+        plt.ioff()
     plt.figure(figsize=figsize)
     plt.plot(fpr, tpr, lw=1)
     plt.fill_between(fpr, tpr, label=f"AUC = {auc_score:.4f}", alpha=0.5)
@@ -22,12 +24,14 @@ def plot_roc_curve(test_labels: list, test_df: list, title: str, figsize=(8, 8),
         plt.show()
     return fpr, tpr, thresholds, auc_score
 
-def get_percentiles(fpr, tpr, thresholds, percentiles=[0.9, 0.95, 0.98, 0.99]):
+def get_percentiles(fpr, tpr, thresholds, percentiles=[0.9, 0.95, 0.98, 0.99], verbose = True):
+    assert percentiles == sorted(percentiles)
     tnrs = []
     for percentile in percentiles:
         for i, tp in enumerate(tpr):
             if tp >= percentile:
                 tnrs.append(1 - fpr[i]) # append tnr
-                print(f"{percentile} percentile : TPR = {tp:.4f}, FPR = {fpr[i]:.4f} <-> TNR = {(1 - fpr[i]):.4f} @ thresh {thresholds[i]}")
+                if verbose:
+                    print(f"{percentile} percentile : TPR = {tp:.4f}, FPR = {fpr[i]:.4f} <-> TNR = {(1 - fpr[i]):.4f} @ thresh {thresholds[i]}")
                 break
     return tnrs

py/Session.py

@@ -108,7 +108,7 @@ class Session:
             print("Saving...")
             self.save_scans()
     
-    def check_lapse_duplicates(self) -> bool:
+    def check_lapse_duplicates(self):
         total = 0
         total_duplicates = 0
         total_multiples = 0

resize_session.ipynb

@@ -9,7 +9,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [
     {
@@ -107,13 +107,6 @@
    "source": [
     "copy_session(session, \"ResizedSessions256_NoBackup\", size=(256, 256), truncate_y=(40, 40))"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

train_autoencoder.py

@@ -15,9 +15,10 @@ from torchvision.utils import save_image
 from torchinfo import summary
 
 from py.PyTorchData import create_dataloader, model_output_to_image
+from py.Dataset import Dataset
 from py.Autoencoder2 import Autoencoder
 
-def train_autoencoder(model: Autoencoder, train_dataloader: DataLoader, name: str, device: str = "cpu", num_epochs=100, criterion = nn.MSELoss(), lr: float = 1e-3, weight_decay: float = 1e-5, noise: bool = False, sparse: bool = False, reg_rate: float = 1e-4):
+def train_autoencoder(model: Autoencoder, train_dataloader: DataLoader, name: str, device: str = "cpu", num_epochs=100, criterion = nn.MSELoss(), lr: float = 1e-3, weight_decay: float = 1e-5, noise: bool = False, sparse: bool = False, reg_rate: float = 1e-4, noise_var: float = 0.015):
     model = model.to(device)
     print(f"Using {device} device")
     optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=weight_decay)
@@ -34,7 +35,7 @@ def train_autoencoder(model: Autoencoder, train_dataloader: DataLoader, name: st
             img = Variable(img).to(device)
             input = img
             if noise:
-                input = input + (0.015 ** 0.5) * torch.randn(img.size(), device=device)
+                input = input + (noise_var ** 0.5) * torch.randn(img.size(), device=device)
             # ===================forward=====================
             latent = model.encoder(input)
             output = model.decoder(latent)
@@ -59,7 +60,7 @@ def train_autoencoder(model: Autoencoder, train_dataloader: DataLoader, name: st
             f.write(f"{dsp_epoch},{total_loss},{total_reg_loss}\n")
         
         # output image
-        if epoch % 2 == 0:
+        if epoch % 10 == 0:
             pic = model_output_to_image(output.cpu().data)
             save_image(pic, f"./ae_train_NoBackup/{name}/image_{dsp_epoch:03d}.png")
         
@@ -73,7 +74,8 @@ def train_autoencoder(model: Autoencoder, train_dataloader: DataLoader, name: st
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Autoencoder train script")
     parser.add_argument("name", type=str, help="Name of the training session (name of the save folder)")
-    parser.add_argument("img_folder", type=str, help="Path to directory containing train images (may contain subfolders)")
+    parser.add_argument("dataset_folder", type=str, help="Path to dataset folder containing sessions")
+    parser.add_argument("session", type=str, help="Session name")
     parser.add_argument("--device", type=str, help="PyTorch device to train on (cpu or cuda)", default="cpu")
     parser.add_argument("--epochs", type=int, help="Number of epochs", default=100)
     parser.add_argument("--batch_size", type=int, help="Batch size (>=1)", default=32)
@@ -83,20 +85,24 @@ if __name__ == "__main__":
     parser.add_argument("--latent", type=int, help="Number of latent features", default=512)
     parser.add_argument("--image_transforms", action="store_true", help="Truncate and resize images (only enable if the input images have not been truncated resized to the target size already)")
     parser.add_argument("--noise", action="store_true", help="Add Gaussian noise to model input")
+    parser.add_argument("--noise_var", type=float, help="Noise variance", default=0.015)
     parser.add_argument("--sparse", action="store_true", help="Add L1 penalty to latent features")
 
     args = parser.parse_args()
 
+    ds = Dataset(args.dataset_folder)
+    session = ds.create_session(args.session)
+
     if args.image_transforms:
         print("Image transforms enabled: Images will be truncated and resized.")
     else:
         print("Image transforms disabled: Images are expected to be of the right size.")
 
-    torch.manual_seed(10810)
-    np.random.seed(10810)
-    random.seed(10810)
+    # torch.manual_seed(10810)
+    # np.random.seed(10810)
+    # random.seed(10810)
     
-    data_loader = create_dataloader(args.img_folder, batch_size=args.batch_size, skip_transforms=not args.image_transforms)
+    data_loader = create_dataloader(session.get_lapse_folder(), batch_size=args.batch_size, skip_transforms=not args.image_transforms)
     model = Autoencoder(dropout=args.dropout, latent_features=args.latent)
     print("Model:")
     summary(model, (args.batch_size, 3, 256, 256))
@@ -108,4 +114,4 @@ if __name__ == "__main__":
         print("Adding Gaussian noise to model input")
     if args.sparse:
         print("Adding L1 penalty to latent features (sparse)")
-    train_autoencoder(model, data_loader, args.name, device=args.device, num_epochs=args.epochs, lr=args.lr, noise=args.noise, sparse=args.sparse, reg_rate=args.reg_rate)
+    train_autoencoder(model, data_loader, args.name, device=args.device, num_epochs=args.epochs, lr=args.lr, noise=args.noise, sparse=args.sparse, reg_rate=args.reg_rate, noise_var=args.noise_var)