Final electron counting commits

Computer Vision_Object Detection/Object_Detection.ipynb

@@ -0,0 +1,22 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

Computer Vision_Object Detection/ReadME.md

@@ -0,0 +1,154 @@
+For Data Generation
+**1.1** 
+Create a blank canvas (2D array of zeros) with a predefined size, I used 256 by 256. The canvas acts as the background for placing the hits so it will be filled with zeroes initially.
+
+
+**1.2**
+Use a collection of preloaded small images(the frames containing the electron hits) representing "electron hits." 
+From here on out, I will use frames to represent these small images.
+Extract the dimensions (height, width) of these images. Assume all hits have uniform dimensions. For the frames in the 200kV_98000electron.tif file, they are 19 by 19 pixels each.
+
+
+**1.3.1**
+Randomly generate a top-left coordinate (x, y) for the placement on the canvas:
+I created a fictitious canvas which overlays the original canvas I want to put the frames on. I will later explain why the fictitious canvas shouldn’t perfectly align with the original canvas.
+
+The goal is to find random top-left corner coordinates (x,y) on the canvas where the frame can be placed. This placement must ensure that the entire frame fits within the canvas without going outside the boundaries. I define the random (x,y) with the lines below.
+
+x = random.randint(1 - width//2, max_x - width//2 - 1), y = random.randint(1 - height//2, max_y - height//2 - 1)
+Width and Height will be that for the frame so 19 in this case. Max_x and Max_y will be that for the original canvas.
+
+So the range for the fictitious canvas will be
+1 - 19//2  to  256 - 19//2 - 1
+1 - 9  to  256 - 9 - 1
+-8 to 246 for the x and I repeat the same for y.
+
+I then randomly select a frame from the 200kV_98000electron.tif file and randomly(according to the range calculated) place them on the fictitious canvas and an ‘image’ will be created. Now this ‘image’ will have the fictitious canvas and the original canvas.
+
+
+**1.3.2**
+Ensure coordinates account for potential cropping at the edges:
+The center of the frame is calculated based on its top-left corner (x, y) and its dimensions (width, height). I just offset the top-left corner by approximately half of the width and height.
+x_center = x + width // 2 —// is floor division.
+y_center = y + height // 2
+
+Suppose x = 10 and y = 20 from my edge case(I mean the top-left corner random picking),
+x_center = 10 + 19 // 2 = 10 + 9 = 19.
+y_center = 20 + 19 // 2 = 20 + 9 = 29.
+So the exact position will be the (19,29) on the original canvas. The ‘image’ is then clipped to retain the original canvas size.
+
+The coordinates for each image are stored with the image as tuples.
+
+
+**1.4**
+Create a function to generate multiple images and store the images and centers as h5 datasets.
+
+
+
+
+
+
+For Training
+2. --Data Preparation
+__Initialize Data Loader:__
+Use the DataLoader class to load data from an HDF5 file containing:
+images: A collection of 2D arrays representing electron hit images.
+centers_training: The hit coordinates in each image.
+__Load Data:__
+Use the load_data method to extract the images and centers arrays from the file.
+
+__Tile Images:__
+Divide each image into smaller square tiles of size tile_size using the tile_image method.
+Ensure tiles are non-overlapping and of uniform size.
+
+__Map Hits to Tiles:__
+Let’s say I pick one 256x256 image
+
+Tile size: 8x8 pixels. This divides the image into 1024 tiles (32 rows × 32 columns) with each tile having a unique index.
+Hit centers: Assume there are only 3 hits with the following coordinates: centers = [(1, 2), (10, 5), (14, 14)]
+For each hit (x1, y1), we determine the tile it belongs to and its local coordinates within the tile.
+
+Hit 1: (1, 2)
+
+Tile Row and Column:
+
+Tile row = y // tile_size = 2 // 8 = 0.
+Tile column = x // tile_size = 1 // 8 = 0.
+tile_index = tile_row * (image_width // tile_size) + tile_col = 0 * (256 // 8) + 0 = 0
+
+
+Local Coordinates:
+
+Local x = x % tile_size = 1 % 8 = 1.
+Local y = y % tile_size = 2 % 8 = 2.
+
+The local coordinates are for the tiles and the ‘global’ coordinates are for the giant(256x256) original image.
+I repeat the same for all the other hits and store that in a dictionary for each tile index.
+
+Tile Indices: Calculated based on the hit's position relative to the overall image.
+Local Coordinates: Allow precise positioning within a specific tile.
+Empty Tiles: If no hits fall in a tile, its list of hits will be empty.
+
+__Process Data__
+Pad tiles with dummy hits (0, 0) to ensure uniformity up to max_hits_per_tile(I used 2 in my case).
+
+__Normalize Data__
+Scale pixel intensities to the range [0, 1].
+Normalize hit coordinates to be relative to the tile dimensions (range [0, 1]).
+
+__Create Datasets__
+Split normalized data into training and validation sets using train_test_split.
+Use TensorFlow’s Dataset API to create batched datasets for:
+Training (train_dataset) and Validation (val_dataset).
+
+NB: Tiles may get mixed up if shuffled across images and reconstruction becomes complex if not difficult.
+
+
+
+3. Call class to load data
+"""
+
+file_path = '/path/to/h5/file'
+
+data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=2)
+images, centers = data_loader.load_data()
+
+train_dataset, val_dataset, train_images, val_images, train_centers, val_centers = create_datasets(data_loader)"""
+
+4. Define a function to visualise the tiles and their corresponding centers/labels for verification.
+
+5. Neural Network input shape should be (tile_size,tile_size,number of channels) and the classes should be max_number_of_hits_per_tile as the tiles are treated as individual images for the Neural Network.
+    Model hyperparameters include:
+    batch size = 500
+    optimizer = Adam
+    loss function = Mean Squared Error. if the number of hits per tile are more than 2, it is recommended to use a matching algorithm.
+    learning rate = 0.001 (use lr scheduler with the following arguments:- monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=5e-6)
+
+
+6. Training was done on 2 gpus(A100) which took appoximately 37 mins for 50 epochs.
+
+7. 
+8. 
+
+9. __Model Performance Assessment__
+   For each tile in the predictions:
+   compare the predictions to the top left corner of the tile and if it the prediction is not equal to the top left corner, it is a valid prediction.This is done to ignore the padding.Next this coordinate should be greater or .1 pixel relative to the top left corner of the tile.This is a valid predicted hit. Valid doesn't mean True or accurate.This is also done to ignore predictions for paddings that were not neccessarily (0,0) but were close to (0,0).
+   For each tile in the groundtruth:
+   compare the coordinates to the top left corner of the tile and if the coordinate is greater than the top left corner, it is a valid groundtruth.
+
+   For the filtered predictions:
+   find the euclidean distance between the groundtruth and the prediction and compare that to a preset pixel distance. If the eucliean distance within the preset pixel distance(denormalize with tile size or how coordinates were normalized), the prediction is a True Positive. If all the groundtruths in the tile have a matched hit and a prediction is without a matched truth, the unmatched prediction is considered a False Positive.
+
+10. __For reconstruction of original image:__
+    Create a an empty canvas.
+    since the images used were square images, the number of tiles per row is just the squareroot of the total number of tiles per image. 
+    Pick an index in the tiles for an image:
+    for the row on which the tile goes, do a floor division of the index with the number of tiles per row.
+    for the column on which the tile goes, do a modulo computation of the index with the number of tiles per row.
+    On the empty canvas,place these tiles according to the row and column numbers and use a stride of the tile size.
+
+
+
+
+
+