devolearn / devolearn Goto Github PK

The list __all__ currently looks like:

__all__ = ["lineage_populaton_model",
            "embryo_generator_model",
            "embryo_segmentor",
            "tests"]

But we want it to look like the one shown below:

__all__ = [
    "lineage_populaton_model",
    "embryo_generator_model",
    "embryo_segmentor",
    "tests"
]

After cloning the repo, running python setup.py test throws a warning as follows:

 DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working

Only the lineage_population_model runs on a GPU optionally, need to add CUDA support on all models so that the users can use with models with:

model = example_model_class(device = "cuda")

more info can be found here

While the unit tests do cover the output types, they do not check if the outputs themselves are correct/incorrect.

To do:

• Use some loss function w.r.t ideal outputs and make sure the losses are low enough
• Make sure the output dtype matches the original (int, float32, float64)

There are some unnecessary empty lines starting from line 16 to line 19 in test.py

Someone has to add link(s) to the documentation within the function comments.

It is fine to add only one link to only one function to make a PR. We do not require for you to add all the links for all the functions.

Please see the example below:

I'll be referring to line 58 in the lineage_population_model.py

The snippet there currently looks like this:

    def predict(self, image_path):

        """
        input{
            image path <str>
        }
        output{
            dictionary containing the cell population values <dict>
        }

But we want somehting like:

    def predict(self, image_path):

        """
        reference{
            https://github.com/DevoLearn/devolearn#predicting-populations-of-cells-within-the-c-elegans-embryo
        } 
        input{
            image path <str>
        }
        output{
            dictionary containing the cell population values <dict>
        }

the models in devolearn have different architectures, and different purposes. But it would be great if all of the models come under one single base class like:

class InferenceEngine():
    def __init__self(model, checkpoint, preprocess, deprocess, device = 'cuda'):
        self.model = model
        self.model.load_state_dict(torch.load(checkpoint))
        self.model.to(device)

    def inference(self, x):
        x = self.preprocess(x)
        pred = self.model(x)
        return self.deprocess(pred)

    ...other methods...

    def __repr__(self):
        return self.model

the qualty of the generated images from the GAN can be improved with a larger architecture and possibly a larger output size

This issue would be a tracker/conversation space for devolearn's core long term goals.

Here are some of the key goals to work on:

• every model should be a subclass of devolearn.base_inference_engine.InferenceEngine
• InferenceEngine would contain some predefined (but overrideable) methods to:
  • Download model checkpoints from github source
  • Preprocess images for inference
  • Postprocess predictions for readability/saving
• devolearn.IoPipeline would contain some standardized media tools for reading and writng videos/images (might use decord/imageio for videos and cv2 for images)
• a docker based fastAPI endpoint could be created (only after the above objectives are complete). This would help us deploy the models into servers/webapps/GUIs

The picture attached below is the layout of how we want to see it ⬇️

If you have any suggestions/ideas, feel free to discuss below :)

cc: @balicea @ujjwalll

The embryo_segmentor() class has torch.nn.module as it's superclass for no clear reason.

The current description on line 11 looks like:

description="Accelerate data driven research on embryos with deep learning models",

But we want it to be like:

description="Accelerate data driven research in developmental biology with deep learning models",

Streamlit seems to be an amazing option for deploying python backends with a clean GUI. We should definitely explore possibilities of building a GUI with streamlit for devolearn

DevoLearn should migrate to Github Actions because building on travis-ci.org has ceased since June 15th, 2021.

Currently devolearn uses a relatively simple testing suite i.e python3 setup.py test. But a much cleaner alternative would be to use pytest for testing and codecov for coverage reports.

Why use coverage reports ?
They help us see how much of the code is being tested after each push, this'll help us find the pieces of code that are important but remain untested.

Why pytest ?
From my own personal experience, python3 setup.py test crashes without an error message when the user tries to access a CUDA device (GPU) on the github actions runtime. This error would've been impossible to fix if I hadn't moved to using pytest (which showed me the proper error message).

@Mayukhdeb please add hacktoberfest topic to the repo in order to make this repo eligible for hacktober fest 2020.
Here are the updated rules: https://hacktoberfest.digitalocean.com/hacktoberfest-update
To validate PRs after October 3, 2020 this topic must be included in repository.

@Mayukhdeb In main.yml file whenever it was testing with python versions ,it was testing with previous versions of python 3.8 and 3.7 ,and most these versions are almost deprecated and most of the libraries which are installed through requirements.txt are latest version, which are not compatible with old version , this is causing some issues when we are testing .It needs to be changed ,I think so, and these should updated for new python version

For now, devolearn works with tqdm.tqdm and not tqdm.notebook, but that's not suitable for jupyter notebook environments

should make something like notebook_mode = True for the functions that use tqdm

Currently devolearn uses cv2 to load and run inference on images/videos. There are faster and cleaner alternatives like decord and imageio which can be used instead.

1. Devolearn requires torch==1.7, but I think it would also work with the latest versions of torch. Using the latets version of torch would make the installation much faster on google colab notebooks because the latest version of torch is already installed there.
2. The URL for the weights to the embryo segmentation model is most likely broken, throws an HTTP error.
3. arg mode = 'cpu' should be replaced with device = 'cpu'
4. optionally, we can also let the user decide the GPU ID like device = 'cuda:0'
5. move the run tests cell to the bottom

Note that this is a beginner friendly issue, all the changes are to be done on this notebook. Feel free to reply to this if you're willing to take this up.

The images in the devolearn readme would look better if they're all approximately of the same width.

The current model only allows us to predict on images by providing a path. We can extend the functionality and flexibility of out module by allowing numpy arrays as arguments to predict.

After uploading the test package and installing on a virtual env/google colab, the relative paths of the downloaded models are not directing to the package directory

Docstrings make our code much more usable and adds useful information which can be useful when debugging. Check out this link if you want to know more and generate docstrings for devolearn.

Devolearn was written with Pytorch 1.7.0. but it might as well work on most of the more the other Pytorch versions (like the one on colab). If that is true, then we might not need this long reinstallation on google colab every time we do pip install devolearn

Use of parameter 'mode' in documentation whereas 'device' used in code. Inconsistent naming of parameters in code.