Worklog

[bmoore20]

Quickly jot down a few notes of what was accomplished after each work session. This will help keep track of the project's progress. Also include next steps.

[bmoore20]

2.28.21

Accomplished:

• Downloaded Anaconda, created new conda habs environment (skeleton), and added it as Python Interpreter in PyCharm
• Created new issue to finish setup of habs environment (generate requirements.txt file with dependencies)
• Created new JupyterNotebook and followed/experimented with PyTorch's Faces dataset
• Made a new branch feature/habs-dataset
• Wrote skeleton of HABsDataset
• Worked through len and __transformrescale
• Tried to get dataset items working using imutils.paths (original way)
• Think I need to switch over to pathlib.Path because imutils.paths is a 'generator' object and I don' think it will work with indexing

Next steps:

• Get images and their target label using pathlib.Path in HABsDataset's getitem
• Look at TODO statements in HABsTrain.py
• Create requirements.txt file for habs environement and test to make sure original code runs correctly in habs environment -> close Issue #9

[bmoore20]

3.1.21

Accomplished:

• Made a new branch feature/habs-environment
• Created a new file requirements.txt that contains all of the dependencies to run the current HABs programs: HABs_Train.py and HABs_Classify.py
• Completed the setup of the new conda habs environment that I started last night by downloading the dependencies in the environment using pip install -r requirements.txt
• Once the environment was set-up, I ran HABs_Train.py to make sure that the environment was correct
• Received following error: ValueError: Shapes (None, 1) and (None, 3) are incompatible
• Realized that this was because I never transferred the training set of images from my old computer and set-up the correct folder directory for training
• Transferred all of the images (267 Total: 156 clear, 25 bga, 86 turbid) onto my new laptop via thumb-drive and made sure the images were in the correct folder structure (one base folder with three sub-folders labeled "clear", "bga", and "turbid")
• Re-ran HABs_Train.py in habs conda environment with this new set-up and it worked how it is expected to
• Ran HABs_Classify.py in habs conda environment and it worked correctly as well
• Submitted a PR (#11) for feature/habs-environment
  • related to #9

Next steps:

• Keep working through HABs Dataset (create 3 dataset objects for each class?)

[bmoore20]

3.2.21

Accomplished:

• Read up on the differences between conda and pip and when to use conda install vs pip install
• Created environment.yml file that generates a conda environment specific to the HABs project when conda env create -f environment.yml is ran while the user is in the HABs project directory

Next steps:

• Keep working through HABs Dataset (create 3 dataset objects for each class?)

[bmoore20]

3.3.21

Accomplished:

• Added torch and torchvision as dependencies in feature/habs-environment
• Read tutorials about torch's Dataset class in order to understand it better
• Explored different ways to make custom Dataset for HABs because first try was epic fail
• Found a really good example: https://towardsdatascience.com/building-efficient-custom-datasets-in-pytorch-2563b946fd9f
• Totally refactored (threw-out) first implementation of HABs dataset and explored ideas that were in the above tutorial
• HABsDataset is still in HABs_Train.py but when I change the repo's organization it will be moved to utils
• Commented out the rest of the code in HABs_Train.py whose functionality still needs to be changed to match our new version

Next steps:

• Need to totally re-vamp the structure and organization of repo
  • See #4 for more details
  • It is getting to the point where it doesn't even make sense to even try to replace parts of my original code anymore
• Recreate existing Keras model with PyTorch

[bmoore20]

3.4.21

Accomplished:

• Looked at a couple of repos from Papers with Code
  • https://paperswithcode.com/paper/first-order-motion-model-for-image-animation-1
  • https://paperswithcode.com/paper/towards-open-world-object-detection
  • both were helpful with seeing how others organize their repos
• Created a new branch feature/reorg-repo-structure to go with #4
• Made new folders and files (data, hab, model, dataset.py, train.py, utils.py), while deleting old ones (HABs_Train.py, HABs_Classify.py, background_info)
  • most of these files and folders are skeletons right now
• Included requirements.txt and environment.yml from #11 in root project directory (habs)
• Included HABsDataset class from #12 in its own file: habs/hab/dataset.py
• NOTE: Since this new branch includes the new repo structure, along with the new functionality from feature/habs-dataset and feature/habs-environment, it might be easiest to reference this new branch for all of those changes

Next steps:

• Write simple base functionality for train.py
  • Write main that receives users' arguments
  • Outline structure for how to organize the file (loading data, splitting data into train/test sets, loading model (DataLoader), training the model)
• Translate CNN model from Keras to PyTorch

[bmoore20]

3.6.21

Accomplished:

• Read up on purpose and meaning of if __name__ == "__main__" statement
• Read up on python argument parser and the difference between positional arguments and optional arguments
  • Question: For required arguments is it better to make them a positional argument or an optional argument with required=True?
• Wrote the simple base functionality for train.py => main() and train()
  • included argument parser and called train() in main()
  • imported HABsDataset in train()
  • called main() in if __name__ == "__main__"
  • pushed these changes up to feature/reorg-repo-structure
• Tried to simplify import statements by using __init__.py file but failed epically
  • used this technique with Jonathan but forgot specifics on how to do it
  • couldn't find any good examples online to help

Next steps:

• Translate CNN model from Keras to PyTorch
• Write training algorithm for model in hab/train.py's train()
• Start data augmentation process for current image dataset

[bmoore20]

3.7.21

Accomplished:

• Read up on basics of PyTorch
• Read tutorials on CNNs to try to understand them better
• Looked up different parts and terms for CNN
  • conv layer vs fc layer
  • relu activation
  • pooling layer
  • criterion
  • learning rate
• Wrote HABs CNN model with help from https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html
  • is similar to Keras model that I used for my original project from https://www.pyimagesearch.com/2019/01/14/machine-learning-in-python/
  • main differences are the of number of layers (2 vs. 3) and the value of the parameter arguments that are passed in
  • pushed changes up to feature/reorg-repo-structure
• Wrote train() with help from https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html
  • QUESTION: Why are we passing in an argument (input images) to our model if no parameters were specified in init?
  • test is done in train() after training is complete
  • pushed changes up to feature/reorg-repo-structure

Next steps:

• Run train.py to check to make sure that the program actually runs and that there aren't any bugs!
  • haven't tried to run the full restructured program yet
• Compare prediction/performance results from PyTorch CNN model to original Keras CNN model results (baseline)
• Gain a better understanding of what each parameter value is doing for each layer in the CNN
  • become more comfortable with what the CNN is actually doing
• Start data augmentation process for current image dataset

[bmoore20]

3.8.21

Accomplished:

• Posted notes from today's meeting with Ty
• Closed out #11 and #12 because the new functionality in these PRs was included in feature/reorg-repo-structure. Therefore, the code for these features can be reviewed as part of the PR for feature/reorg-repo-structure
• Started working through including Transforms into dataset
  • Referenced https://pytorch.org/tutorials/beginner/data_loading_tutorial.html
  • It looks like there are pre-made datasets and Transforms that will work with the way that my image folders are set up (labels are names of folders) and I am using PIL.Image
  • But I think I still want to make the dataset and Transforms from scratch because I want to learn how to do them because I know in the feature I will eventually be in a situation where I won't be able to use a pre-made one and I will have to create a custom one
  • QUESTION: In my original code, I converted the Image to a np.array after I resized it to (32, 32) before I divided by 255.0. Do I still need to convert to a numpy array still before I divide by 255.0?
  • QUESTION: Will the resize to (32,32) and dividing by 255 (to scale to the range [0,1]) count as two separate transforms?

Next steps:

• Continue to work through adding Transforms to dataset
  • work out examples in jpynb to see what the output of PIL.Images are and what happens when you divide directly on them
  • figure out what format the images need to be in when they are imported into the CNN model
  • look at some example image recognition repos from online
• Implement other suggestions that Ty made for Dataset (can be found in 3.8.21 Meeting Notes in #1)

[bmoore20]

3.9.32

Accomplished:

• Read up on pathlib.Path
• Experimented with pathlib.Path in a Jupyter Notebook in order to figure out how to save each images' path in an array
  • was able to create a Path object with root directory path
  • then called .glob('**/*) to get all of the paths for the files in this directory
  • then added these paths to a list in order to create a list of Path objects (PosixPath) -> one for each image
• Updated HABsDataset to include the code that I did in Jupyter Notebook
• Finalized HABsDataset by creating an array of references to the images in __init__, setting __len__ to be the length of this array, and loading in the actual images in __getitem__ (saves memory by loading them here)
• I think this implementation for HABsDataset could be very close to a final solution
• Pushed these changes up to feature/reorg-repo-structure so it is the most recent version

Next steps:

• Finish working through adding Transforms to dataset
  • determine if image = np.array(image.resize((32, 32))) / 255.0 should be broken into two separate transforms or if it should be kept as one transform
  • work through examples in jpynb to see what the output of PIL.Images are and what happens when you divide directly on them
  • figure out what format the images need to be in when they are imported into the CNN model
  • look at some example image recognition repos from online
• Make a separate directory for true hold-out test set of images (20% of dataset)
  • ex) habs/data/train_images and habs/data/test_images
  • Include correct class label in image name
• Run train.py to check to make sure that the program actually runs and that there aren't any bugs!
  • haven't tried to run the full restructured program yet

[bmoore20]

3.10.21

Accomplished:

• Switched over to using pathlib.Path.suffix to identify if a file is an image in directory path in dataset.py
• Simplified "if" statements in dataset.py using format if x in {x, y, z}
• Worked through supporting 3 different scenarios that HABsDataset has to handle:
  1. Dataset consists of the training images, images need to be in sorted bga, clear, and turbid folders, and dataset needs to return both image and label
  2. Dataset consists of the test images, images need to be in sorted bga, clear, and turbid folders, and dataset needs to return both image and label
  3. Dataset consists of images to be classified, images do not have to be sorted into class folders, and dataset only needs to return image
• In order for HABsDataset to support these various requirements, I created a new mode parameter that has the user specify which mode they want the HABsDataset to be in (default = "train")
  • made a self.mode attribute so this value can be referenced throughout HABsDataset
• Created different directories for the train and test sets in order to make them completely separate (true hold-out test set): habs/data/train _images and habs/data/test_images
• Changed how the train and test datasets were created in train.py in order to align with the above revisions
• Pushed these changes up to feature/reorg-repo-structure so it is up to date

Next steps:

• Need to discuss/brainstorm with @AlephNotation about how the classification part will come into play
  • ex) classifying new images, sorting them into folders, creating report, etc.
  • separate file than train.py? save model and and load it in?
  • what's the best way to organize this?
  • reach out to my HWS professors and see if there is anything that I can change, or features that I can add, to better the user experience while using this classifier based on their experience from using it for the past year
  • we can probably hold off on these two things for a while until after we improve the image dataset through data augmentation and successfully train an accurate ML model
• Finish implementing Transforms for HABsDataset and train.py
• Better understand how the training algorithm is working and answer the question of why we are passing in images to HABsModelCNN even though no parameters were specified in __init()__
• Run train.py, fix any bugs that come up during this process, and compare output to original Keras model results
• Submit PR?

[bmoore20]

3.11.21

• Watched 3Blue1Brown's linear algebra series
  • chapters 1, 2, 3, and 1/2 of 4

[bmoore20]

3.13.21 and 3.14.21

• Rewatched 3B1B LA chapter 4
• Watched 3B1B LA chapter 5
• Went back and took detailed notes on chapters 1-5 in order to really understand conceptually what is going with the relationship between matrices and transformations -> helped make the ideas sink in

[bmoore20]

3.16.21

Accomplished:

• Finished setting up transforms
• Refactored image = np.array(image.resize((32, 32))) / 255.0 by using PyTorch transforms
  • Created new transform class for rescaling the image
  • Used transforms' built-in ToTensor() transform to scale pixel values to be in range [0, 1]
• Composed transforms using transforms.Compose
• Passed in transforms to train_dataset and test_dataset in train.py through HABsDataset transform parameter
• Pushed these changes up to feature/reorg-repo-structure so it is up to date

Next steps:

• Work on model
  • make sure torch.FloatTensor type can be used as inputs for the model -> need to convert back to PIL IMAGE or np.array?
  • Answer the following question: Why are we passing in argument to model if it wasn't specified in __init__?
  • go through model tutorial again and try to get a better understanding of what's going on
  • Run train.py, fix any bugs that come up during this process, and compare output to original Keras model results
  • Submit PR

[bmoore20]

3.17.21

Accomplished:

• Removed date & time pixels from bottom of dataset images
• Did this by creating a new transform class, Crop, in transformations.py
• Tested out implementation in a jupyter notebook
• Then passed this new class into transforms.Compose() before the Rescale() and ToTensor() transforms
• Pushed these changes up to feature/reorg-repo-structure so it is up to date

Next steps:

• Incorporate logger and log statements into code
• Next steps from 3.16.21 ^^

[bmoore20]

3.18.21

Accomplished:

• Read tutorials on how to use python logger
• Created a logger in train.py
• Pushed these changes up to feature/reorg-repo-structure so it is up to date

Next steps:

• Work on model
  • make sure torch.FloatTensor type can be used as inputs for the model -> need to convert back to PIL IMAGE or np.array?
  • Answer the following question: Why are we passing in argument to model if it wasn't specified in __init__?
  • go through model tutorial again and try to get a better understanding of what's going on
  • Run train.py, fix any bugs that come up during this process, and compare output to original Keras model results
  • Submit PR

[bmoore20]

3.19.21

Accomplished:

• Re-looked at HABsModelCNN and how it was incorporated in train.py
  • Realized that I never made an instance of HABsModelCNN and was just straight-up using the class. Fixed this problem.

• Answered the following question: Why are we passing in argument to model if it wasn't specified in __init__?

  • Realized that I needed to create an instance of HABsModelCNN: habs_net = HABsModelCNN()
  • Once I did this, every time I call habs_net(images), the instance's __call__ method is being ran, and the images argument is being passed into this __call__ method:

    
    def _call_impl(self, *input, **kwargs):
    ...
    return result

  call : Callable[..., Any] = _call_impl

  
  ** Thanks to Stephen for helping me understand how `__call__` works and the benefit of it when I was doing PR for Providence 

• Did a once-over on all of the changes that I made up until this point. Acted as a final check before I submitted PR.
• Submitted PR #14 for feature/reorg-repo-structure branch
  • Includes changes for the following Issues: #2, #3, #4, #5, #6, and #9

Next steps:

• Work on model
  • make sure torch.FloatTensor type can be used as inputs for the model -> need to convert back to PIL IMAGE or np.array?
  • go through model tutorial again and try to get a better understanding of what's going on
  • Run train.py, fix any bugs that come up during this process, and compare output to original Keras model results
  • Create Issues for Docker, testing with PyTest, and experimenting to find optimal model for HABsDataset
  • Data augmentation

[bmoore20]

3.21.21

Accomplished:

• Determined that HABsModel takes in the images in Tensor format so the way I have it with converting ToTensor in the last transformation is correct

https://pytorch.org/docs/stable/_modules/torch/nn/modules/conv.html#Conv2d

https://pytorch.org/docs/stable/tensors.html

Next steps:

• Find call and forward methods for nn.Conv2d
• Train HABsModel with training images that are that in local directory by running train.py
• Start debugging errors that come up after trying to run program

[bmoore20]

3.23.21

Accomplished:

• Fixed the changes that Ty requested for #14
• Merged the PR in main because Ty said I could go ahead and merge after I made the specified changes
• Documented the notes from today's meeting in the Roadmap issue
• Closed out all of the issues that were associated with #14
• Created 8 new issues for things that I talked about with Ty today in our meeting (#15, #16, #17, #18, #19, #20, #21, #22)

[bmoore20]

3.25.21

Accomplished:

• Added in the missing doc strings that I did not include in my last PR
• Submitted a PR for these changes

Next steps:

• Rotating file handler
• Black

[bmoore20]

3.27.21

Accomplished:

• Added RotatingFileHandler
• Refactored logging organization
  • pulled repeated steps out into abstraction
  • allows for easier implementation of logger throughout multiple files
  • QUESTION: Why are handlers not being recognized??
• Published new branch feature/rotating-file-handler with these changes to remote repo

Next steps:

• Black

[bmoore20]

3.26.21

• Read Lottery Ticket Hypothesis paper https://arxiv.org/abs/1803.03635

[bmoore20]

3.30.21

• Merged #26
• Fixed handler issue for logger
• Merged #27

Next steps:

• Read and do research about data augmentation and transformations
• Testing
• Seeds
• Black

[bmoore20]

4.2.21

• Watched 3b1b "Gradient Descent" (S3 E2)
• Watched 3b1b "Backpropagation" (S3 E3)
• Watched 3b1b "Essence of Calculus" (Calc. Ch. 1)

[bmoore20]

4.3.21

• Watched 3b1b "Paradox of the Derivative" (Calc. Ch. 2)
• Watched 3b1b " Derivative Formulas" (Calc. Ch. 3)
• Watched 3b1b "Chain Rule and Product Rule" (Calc. Ch. 4)
• Read https://discuss.pytorch.org/t/transform-and-image-data-augmentation/71942

[bmoore20]

4.4.21

Accomplished:

• Read up on data augmentation and transformations
  • read https://arxiv.org/abs/2004.13649
  • started making a list of articles/blogs

Next steps:

• Search for more articles that suggest good/the best transformations to use for data augmentation
• Look for answers on how to apply the transformations -> all together -> choose one or two from a random list -> is any technique proven to be better than another?
• Make a list of possible transforms that we could use from PyTorch
• Make list of questions for Ty
• Finalize list of sources/articles and send them over to Ty
• Read up on if test and classify images should use same transforms as train
• Start implementing modulo into dataset
• Goal is to try to do one logistical ticket and one ml ticket per week or 2 weeks

[bmoore20]

4.6.21 - 4.13.21

Accomplished:

• Read https://www.lesswrong.com/posts/JZZENevaLzLLeC3zn/predictive-coding-has-been-unified-with-backpropagation
• Briefly looked over https://stackoverflow.com/questions/51030782/why-do-we-pack-the-sequences-in-pytorch
• Watched https://www.youtube.com/watch?v=8BdMObVdr1Y
• Watched calculus and linear algebra videos (3b1b, Weights & Biases)
• Watched half of https://www.youtube.com/watch?v=VwVg9jCtqaU
• Researched and looked into Colab
• Capture seed in log
• Switched from argparse to typer

To do:

• Finish watching Machine Learning Zero to Hero

[bmoore20]

4.15.21

Accomplished:

• Threw Error in HABsDataset if transforms object is None.
  • updated types and doc strings to represent changes
• Started to make magnitude_increase an argument for user to pass in.
  • updated doc strings to represent changes
  • realized that feature/spike-augmentation-transforms is not updated with the most recent main that has the typer changes

Next steps:

• Merge main into feature/spike-augmentation-transforms or create a fresh branch for all of the changes that I need to make
  • if make fresh branch, cross-check all of the changes in f/s-a-t to make sure no changes get left out
• Finish making magnitude_increase an argument for user
• Add - %(message)s to logger in feature/capture-seeds
• Capture all of the user arguments in log
  • for now might need to capture variable values that are pre-set since we won't be using user arguments through command line with Colab
• Read articles on how to set up Colab with local environment and mount
• Start trying to set Colab up by putting repo in Google Drive
  • Look into how to write a SYNC SCRIPT that syncs my repo updates to Google Drive

[bmoore20]

4.19.21

Accomplished:

• Finished code for capturing seeds and updating logging, created PR, merged code (#33)
• Finished a bunch of small changes that came up during the data augmentation/transforms spike, created PR, merged code (#34)
• Researched and began process of mounting HABs GitHub repo to Google Drive

[bmoore20]

4.21.21

Accomplished:

• Researched information about how to use device
• Came up with clarifying questions to ask about using device

[bmoore20]

4.22.21

Accomplished:

• Configured all hyperparameters (optimizer, epochs, model, criterion)
  • Made helper functions in utils

Next steps:

• Abstract the training loop and test loop in train.py
  • Pull training and testing functionality out into their own functions (train_utils?)
  • Provide necessary hyperparameters as parameters/arguments (same ones that are passed into train.py)
• Finish device stuff
• Load mount images to Google Drive
• Install necessary requirements into Colab VM
• Run the code and fix errors/bugs that pop up

[bmoore20]

4.24.21

Accomplished:

• Started to abstract the training and test loops from train.py

[bmoore20]

4.25.21

Accomplished:

• Finished abstraction of the training and test loops
• Submitted PR for configurations and abstractions (#39)
• Uploaded train and test images to google drive repo (_habs_google_)

Next steps:

• Finish device stuff and submit PR
• Fix up and organize habs_launchpad
  • Organize imports into one cell at the top
  • Install necessary requirements into Colab VM
  • Copy and paste training code (and other appropriate code -> initiating objects and logs) into Colab cells
• Run the code (train and evaluate model) and fix errors/bugs that pop up

[bmoore20]

4.26.21

Accomplished:

• Finished code for device and made PR
• Fixed up and organized habs_launchpad in Colab based on the bullet points listed above

Next steps:

• Need to pull down code or re-mount google drive so it contains the updated code from the new PRs (abstraction/configuration and device)

[bmoore20]

4.27.21

Accomplished:

• Read blogs and explanations on WHY validation set is needed

Next steps:

• Read more about validation and learn HOW it works
• Read about learn rate optimizers
• Set up Black code-formatter with HABs repo
• Fix up validation set based on Ty's suggestions in PR #39
• Split HABs original dataset up into 3 subsets (train - 60% validation - 20% test - 20%)
• Pull updated code into Colab environment (habs_launchpad)
• Run code!! (and fix errors that come up)

[bmoore20]

4.28.21

Accomplished:

• Read up on how to include the code formatter black and the linter flake8 with a git pre-commit hook
• Implemented the changes for adding black and flake8 to the HABs repo (created PR)

Next steps:

• See above (minus bullet about black)

[bmoore20]

Tomorrow (5.3.21):

• Create validation dataset in train.py
• Create validation dataloader in train.py
• Create a training_lap method in training_helper.py
  • model.train()?
• Create a validation_lap method in training_helper.py
  • model.eval()?
  • No optimizer or back prop
• Write following in train.py

  for epoch in range(epoch):
     train_loss = training_lap(...)
     val_los = validation_lap(...)
     if i % 2000......

• Run in Colab (have to pull it in)

[bmoore20]

5.30.21

• Watched lecture on CNNs from MIT https://www.youtube.com/watch?v=iaSUYvmCekI

[bmoore20]

5.31.21

• Reviewed MIT CNN lecture and took notes
• Batch Normalization https://machinelearningmastery.com/batch-normalization-for-training-of-deep-neural-networks/#:~:text=Batch%20normalization%20is%20a%20technique,required%20to%20train%20deep%20networks
• Learning Rate https://machinelearningmastery.com/understand-the-dynamics-of-learning-rate-on-deep-learning-neural-networks/
• Exploding Gradients https://machinelearningmastery.com/exploding-gradients-in-neural-networks/

[bmoore20]

6.1.21

• When I run the program in Colab with TensorBoard, I get an error non-iterable type None after epoch 1
• When I comment out TensorBoard stuff, whole program completes ... still gettting 0% accuracy
• Need to get TensorBoard stuff working
  • Try moving TensorBoard calls to very bottom of notebook since nothing is writing to it right now
  • Set up a second Colab notebook (no GPU) for TensorBoard
  • Incorporate code for log_dir -> current datetime
  • Get code to write to TensorBoard
• Create ResNet and Blocks

[bmoore20]

Week of 6.22.21 - 6.29.21

Accomplished:

• Ran the ResNet model at least once a day (all Colab could handle), experimenting with different parameters
  • Result logs can be found in https://drive.google.com/drive/u/0/folders/1aTrw2vdnLUtQl4mYsEzkWJf38e15DeeL
  • Only switched # of epochs, batch size and mag inc
  • Learn rate (1e-3), loss (cross entropy) and optimizer (adam) were all kept constant
  • Also ran Original HABs model a few times and got similar results to ResNet
  • Highest accuracy percentage was 50% ... never got higher than that -> not better than probability guess
  • Also switched up Transforms!
  • I ran all of the models with a 100 mag inc (~20,000) except the last run where I switched the mag inc to 1000 -> model didn't even finish one epoch
• Looked into how to incorporate the classifying functionality from my original program into new refactored version
  • printed out results from outputs.data and _, predicted = torch.max(outputs.data, 1)
  • **All of the results were predicted to be 1 (Clear)!! -> this was a "fake" run because I used parameters that would make the run go fast to see if the printing worked ... but NEED to look into seeing if 1 is being predicted for all values in actual runs (ResNet)
• Figured out how to load in a branch from GitHub repo to a Colab notebook, and not just the Main branch
  • Allows me to experiment with different functionalities and test things out in colab without having to merge to Main
  • Made a new Colab notebook habs_experiment.ipynb that runs a BRANCH (feature/experiment) from the HABs GitHub repo
  • This branch prints out tensors/arrays that have the predicted values
  • Maybe eventually add this printing permanently in our logs ... kinda nice to see the predicted values
• Looked to see if there were any available HAB data sets online that we could use
  • Found that there seems to already be programs similar to mine
  • Made me think about scope of project -> all of the images are not uniform
  • Have model make predictions with other objects in the images as well
  • My data is fairly uniform

Next Steps:

• Print out results for all runs and see if 1 (Clear) is being predicted for all values
• Determine why Test is only working on 8 images and NOT 10?!
• Test ResNet model not on dataset to make sure it is behaving properly
• Think about possible next paths:
  1. Need to figure out ways to improve Dataset!!!
     • How many values? Thousands? Millions?
     • Dataset from online?
     • More images from HWS professors?
     • Transfer Learning?!
  2. Alternate to Colab?
  3. What's the endgame? What functionality should I be aiming towards once we get the classification? What do users/professors want?
     • Sort images into folders?
     • Continuous stream?
     • Make easy to use -> Docker!
     • Reach out to professors and see what they prefer ... now's the time

Questions:

• outputs.data -> is data an attribute of nn.Module?
• training loss vs. validation loss?

[bmoore20]

6.29.21

Accomplished:

• Created new branch feature/two-classes
• Made changes to HABsDataset to accommodate two classes (bga and non-algae), instead of three (bga, clear, turbid)
• Created a new Colab notebook habs_two_classes.ipynb
  • clones feature/two-classes branch from HABs GitHub remote repo
  • allows us to experiment with simplifying the problem and using two classes instead of three without having to make changes to our main branch/version
• Created new directory in GoogleDrive for two-class set-up:

  habs_google
        habs_data \
                    two_classes \
                             validation_images \
                                          non_algae\
                                               pic_0
                                               pic_x
                                          bga \
                                               pic_0
                                               pic_x
                             train_images \
                                          non_algae\
                                               pic_0
                                               pic_x
                                          bga \
                                               pic_0
                                               pic_x
                             test_images \ 
                                          non_algae\
                                               pic_0
                                               pic_x
                                          bga \
                                               pic_0
                                               pic_x
                    three_classes \
                             validation_images \
                                          bga \
                                               pic_0
                                               pic_x
                                          clear\
                                               pic_0
                                               pic_x
                                          turbid\
                                               pic_0
                                               pic_x
                             train_images \
                                          bga \
                                               pic_0
                                               pic_x
                                          clear\
                                               pic_0
                                               pic_x
                                          turbid\
                                               pic_0
                                               pic_x
                             test_images \ 
                                          bga \
                                               pic_0
                                               pic_x
                                          clear\
                                               pic_0
                                               pic_x
                                          turbid\
                                               pic_0
                                               pic_x

6.30.21

Accomplished:

• Went back and documented missing meeting notes in #1 for:
  • 6.10.21
  • 6.15.21
  • 6.22.21
  • 6.29.21

7.3.21

Accomplished:

• Started and completed PR #61
  • experimented first with the functionality with the feature/experiment branch in Colab's habs_experiment notebook
  • removed logging completely from training_helper.py
  • made evaluate return a Tuple with 4 values -> [predictions, classifications, total, correct]
  • Merged new branch with Main
  • Started and completed PR #62
  • realized that I forgot the typing for the evaluate method
  • Merged new branch with Main
  • Merged new updates to Main to feature/two-classes branch
  • Used command: git merge origin/main
• Manually updated the train cell in habs_launchpad, habs_experiment, and habs_two_classes with the new log statements

  predictions, classifications, total, correct = evaluate(model, test_loader)
  logger.info(f"Predicted Values: {predictions}")
  logger.info(f"Classifications: {classifications}")

• Fixed a missed change in HABsDataset for going from 3 classes (bga, clear, turbid), down to 2 classes (bga and non-algae)

[bmoore20]

7.4.21

• Update worklog for current week's work

Next Steps:

• Get pictures sorted out in two_classes directory
  • only use OBVIOUS HABs!!
  • make sure there is NO DATA LEAKS!! -> no images are used in both test, val, or train
• Run model with two classes
• Look into and research Pre-training/Transfer Learning
  • Look at Papers with Code
  • Mix-Up & Cut -up
  • HOW to implement!!