Better google colab integration

[sawradip]

Problem

Several of the notebooks in the Openvino notebooks repository have a dependency on external data and utility functions. For instance, some notebooks import data from the utils and data folders, which are not always present in remote environments like Google Colab(Muhc more accesible then Binder, I feel).

sys.path.append("../utils")
import notebook_utils as utils

This makes it difficult for users to run the notebooks without manually copying the require directory into the notebook.

Solution

There are a few potential solutions to this problem:

Add the utility functions to the notebook: This would eliminate the dependency on external data and utilities, but might lead to code duplication. However, the contribution guide explicitly states that "a small amount of duplication is okay if it improves the user experience."
Store images and model files in a separate directory: Instead of relying on external data, we could store required files in a directory within the repository. In case the files are not available, the notebook could download them automatically.
Provide a fallback option: If the required external data is not available, the notebook could fall back to an alternative data source.

Additional Considerations

It's important to keep in mind that users may be running these notebooks in environments other than Google Colab, so any solutions should be applicable to a variety of environments.

As per the contribution guide, adding a small amount of duplication is acceptable if it improves the user experience.

All related files, with the exception of Open Model Zoo models, should be saved to the notebook subdirectory, even if that means that there is a small amount of duplication.

[sawradip]

@eaidova Any comments?

[eaidova]

@sawradip thank you for your feedback. We are working in a similar direction... (but not as fast as you assume due to limited resources) Currently, google collab is not our target integration platform, which is the reason why we do not expect convenience for execution notebooks in this way right now

[sawradip]

@eaidova Thank you so much for responding. If it is okay, can you share your plans, what kind of support are you thinking of.

I am interested to work on this enhancement, and I recently did something similar on skorch-dev/skorch#928

[sawradip]

@adrianboguszewski @eaidova I actually want to work on this issue. Do you guys have plan to do this for now? or later?

Some extra questions,

1. If this is not in plan now, can I work on issues from Notebook Roadmap, specially Add Text-to-Speech Notebook using ForwardTacotron WaveRNN is something I feel I could try.

2. If I had some notebook idea that is not already in issues, do I add a PR, or discuss in some forum ( I couldn't find such link in the Contributing Guide )

[adrianboguszewski]

@sawradip, we think adding support for Colab would be great and this is something what is missing :) However, it seems to be complicated topic, so I recommend to open a discussion and start with something easy.

1. ForwardTacotron is quite old and we should remove it from the roadmap.
2. I think it's better to open a discussion in this repository before you start working. Then please assign me and @eaidova

[sawradip]

Waiting for you feedback: #850

[eaidova]

@sawradip I very much appreciate your enthusiasm and willingness to contribute, but I think migration on google colab is difficult architecture work requires a lot of our actions, proper planning, and discussion. As we say in my native country, let's not run ahead of the locomotive :)
At the same time, I'm working on reorganization repo content to remove numeric values and better notebooks grouping (for better search and modularity to simplify dependencies installing), it can be painful for changes what you want bring because, if my changes will be merged before your in some time you need to do it twice because folders structure will be changed, so let's postpone this discussion after we discuss it internally, ok?

I see several things which we need to take into account:

1. independence of notebooks execution:
   • data localization
   • requirements localization
   • utilities handlering
2. preinstalled dependencies

Let's start from the last point in 1, because it is less painful for us right now. There are 2 ways how to resolve it:

1. copy utilities functions to notebooks directly, but it lead to massive code duplication and not good from maintenance point of view (e.g. just imagine that we will have 40 notebooks with downloading files and in each notebook we will copy this function and if we will need to change it behavior, we need to update it 40 times)
2. make it an installable package which can be easily installed in any environment to obtain this functionality. Please consider this way. We can use github actions for publish this package on pypi and provide way to build it from source from repo (or even without publishing use pip install git+... command). I think it should help to resolve problem with usage utilities and in the same time avoid code duplication

[eaidova]

another thing is preinstalled requirements, could you please investigate diff between notebooks requirements and colab. I want mention that google colab should be not only way for running notebooks, because some of them can be targeted on special hardware e.g. (iGPU, which is not available in colab), so we can not always rely only on preinstalled packages
for example, this StackOverflow thred discuss how to understand in which environment running notebook https://stackoverflow.com/questions/53581278/test-if-notebook-is-running-on-google-colab
We can have separate set of requirements and install them only if colab, but we need to be an able to test that this solution is robust and always compatible with colab reqirements

[sawradip]

@eaidova Thank you for the feedback. And if we are going to have change in the folder structure, then it is really good idea to wait a bit.

I just wanted to ask, if the approach I proposed in Discussion #850 was appropriate.

If we use that, the issue you pointed out,

1. copy utilities functions to notebooks directly, but it lead to massive code duplication and not good from maintenance point of view (e.g. just imagine that we will have 40 notebooks with downloading files and in each notebook we will copy this function and if we will need to change it behavior, we need to update it 40 times)

It will be solved as once we clone the repository and change the notebook's working directory with %cd , the function can be imported normally, as we are currently doing from local directory. So, we won't have code duplication.

That is also another awesome idea, if we want to do things in an alternate way.

2. make it an installable package which can be easily installed in any environment to obtain this functionality. Please consider this way. We can use github actions for publish this package on pypi and provide way to build it from source from repo (or even without publishing use pip install git+... command). I think it should help to resolve problem with usage utilities and in the same time avoid code duplication.

And as the Stack-overflow question you mentioned,

for example, this Stack-overflow thread discuss how to understand in which environment running notebook https://stackoverflow.com/questions/53581278/test-if-notebook-is-running-on-google-colab

We can make the Colab-dependent blocks run only if we are in Google Colab environment using something like,

if 'google.colab' in str(get_ipython()):
    # Run colab specific  funtions
else:
    pass

Otherwise avoiding those. in that way notebook will run as intended in Google Colab, as well as run normally in other environments.

Coincidentally, that is exactly what I did in skorch-dev/skorch#928, making the notebooks compatible in both Colab and other environments.

I completely understand that changes will be decided in the internal discussion, and you might choose some other approach that is more appropriate for the community, and I totally respect that.

Additionally, the requirements.txt files are also in little unorganized state. I created an issue #851 on that. So, we should update the notebooks after the folders structures are finalized as well as internal decisions are taken.

Thank you.