diff --git a/environment.yml b/environment.yml index 9beec7ea..ed8c0da9 100644 --- a/environment.yml +++ b/environment.yml @@ -4,14 +4,8 @@ channels: - anaconda dependencies: - python=3.9 - - matplotlib - - numpy - - scipy - - pandas - - fsspec - - pyyaml - - requests - - aiohttp - - intake - - intake-xarray - - jupyter \ No newline at end of file + - jupyter + - pip + - pip: + - -r requirements.txt + - git+https://github.com/ots22/intake-xarray@feature/exif \ No newline at end of file diff --git a/examples/README.md b/examples/README.md index 6dc17e23..f201e769 100644 --- a/examples/README.md +++ b/examples/README.md @@ -5,9 +5,9 @@ This directory contains: To run any of the notebooks in this directory locally, do the following, from the top level of this repo: -1. Install scivision: `pip install -v -e .` -2. Create the environment for the notebooks: `conda env create -f environment.yml` -3. Activate it: `conda activate scivision` +1. Create the environment for the notebooks: `conda env create -f environment.yml` +2. Activate it: `conda activate scivision` +3. Install scivision: `pip install -e .` 4. Open the notebook in `/examples` with `jupyter notebook` **Visit the [Scivision Gallery](https://github.com/scivision-gallery) to see more examples and use-cases.** diff --git a/examples/scivision-core-functionality.ipynb b/examples/scivision-core-functionality.ipynb index 62a55ca0..f8a765db 100644 --- a/examples/scivision-core-functionality.ipynb +++ b/examples/scivision-core-functionality.ipynb @@ -8,23 +8,17 @@ "\n", "In this notebook, we will:\n", "\n", - "1. Demonstrate using the scivision [Python API](https://scivision.readthedocs.io/en/latest/api.html) to load a pretrained (ImageNet) model, which we previously added to the scivision catalog with the name \"scivision-test-plugin\", as per [this guide](https://scivision.readthedocs.io/en/latest/contributing.html#extending-the-scivision-catalog)\n", + "1. Demonstrate using the scivision [Python API](https://scivision.readthedocs.io/en/latest/api.html) to load several pretrained image classification models\n", "2. Use the scivision catalog to find a matching dataset, which the model can be run on\n", - "3. Run the model on the data, performing simple model inference" + "3. Run the model on the data, performing simple model inference\n", + "4. Use the scivision catalog to find another model that can be run on the same dataset" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Note: The model repository follows the strcuture specified in [this template](https://scivision.readthedocs.io/en/latest/model_repository_template.html), including a `scivision` [model config file](https://github.com/alan-turing-institute/scivision-test-plugin/blob/main/.scivision/model.yml)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We first import some things from scivision: `default_catalog` is a scivision **catalog** that will let us discover models and datasets, and `load_pretrained_model` provides a convenient way to load and run a model." + "First let's import some things from scivision: `default_catalog` is a scivision **catalog** that will let us discover models and datasets, and `load_pretrained_model` provides a convenient way to load and run a model." ] }, { @@ -44,7 +38,7 @@ "\n", "A scivision catalog is a collection of **models** and **datasources**.\n", "\n", - "For this example, we want to find datasources compatible with \"scivision-test-plugin\". But first, let's first let's use the catalog to retrive the \"scivision-test-plugin\" repository url, take a look at the other models in the *default catalog* (the built-in catalog, distributed as part of scivision) and see how this catalog is structured." + "For this example, we want to find datasources compatible with the model catalog entry \"scivision_classifier\". But first, let's use the catalog to retrive the \"scivision_classifier\" repository url and take a look at the data contained in the *default catalog* (the built-in catalog, distributed as part of scivision) and see how this is structured." ] }, { @@ -55,7 +49,7 @@ { "data": { "text/plain": [ - "AnyUrl('https://github.com/alan-turing-institute/scivision-test-plugin', scheme='https', host='github.com', tld='com', host_type='domain', path='/alan-turing-institute/scivision-test-plugin')" + "AnyUrl('https://github.com/alan-turing-institute/scivision_classifier', scheme='https', host='github.com', tld='com', host_type='domain', path='/alan-turing-institute/scivision_classifier')" ] }, "execution_count": 2, @@ -66,8 +60,8 @@ "source": [ "# Get the model repo url\n", "models_catalog = default_catalog.models.to_dataframe()\n", - "stp_repo = models_catalog[models_catalog.name == \"scivision-test-plugin\"].url.item()\n", - "stp_repo # Why not paste the repo link into your browser and see how it looks?" + "model_repo = models_catalog[models_catalog.name == \"scivision_classifier\"].url.item()\n", + "model_repo # Why not paste the repo link into your browser and see how it looks?" ] }, { @@ -110,116 +104,34 @@ " \n", " \n", " \n", - " 0\n", - " model-000\n", - " None\n", - " (TaskEnum.object_detection, TaskEnum.segmentat...\n", - " https://github.com/stardist/stardist\n", - " git+https://github.com/stardist/stardist.git@main\n", - " image\n", - " True\n", - " True\n", - " (epfl,)\n", - " (2D, 3D, optical-microscopy, xray, microtomogr...\n", - " \n", - " \n", - " 1\n", - " model-001\n", + " 8\n", + " scivision_classifier\n", " None\n", - " (TaskEnum.segmentation, TaskEnum.thresholding,...\n", - " https://github.com/danforthcenter/plantcv\n", - " git+https://github.com/danforthcenter/plantcv@...\n", - " image\n", - " True\n", - " True\n", - " (danforthcenter,)\n", - " (2D, hyperspectral, multispectral, near-infrar...\n", - " \n", - " \n", - " 2\n", - " model-002\n", - " None\n", - " (TaskEnum.segmentation,)\n", - " https://github.com/MarniTausen/Greenotyper\n", - " git+https://github.com/MarniTausen/Greenotyper...\n", - " image\n", - " True\n", - " True\n", - " (MarniTausen,)\n", - " (2D, multispectral, plant-phenotyping, climate...\n", - " \n", - " \n", - " 3\n", - " model-003\n", - " None\n", - " (TaskEnum.segmentation,)\n", - " https://github.com/alan-turing-institute/cv-al...\n", - " git+https://github.com/alan-turing-institute/c...\n", - " image\n", - " True\n", - " True\n", - " (alan-turing-institute,)\n", - " (dummy,)\n", - " \n", - " \n", - " 4\n", - " scivision-test-plugin\n", - " None\n", - " (TaskEnum.object_detection,)\n", + " (TaskEnum.classificiation,)\n", " https://github.com/alan-turing-institute/scivi...\n", " git+https://github.com/alan-turing-institute/s...\n", " image\n", " True\n", " False\n", " (alan-turing-institute,)\n", - " (dummy,)\n", + " (classification, 2D, image)\n", " \n", " \n", "\n", "" ], "text/plain": [ - " name description \\\n", - "0 model-000 None \n", - "1 model-001 None \n", - "2 model-002 None \n", - "3 model-003 None \n", - "4 scivision-test-plugin None \n", - "\n", - " tasks \\\n", - "0 (TaskEnum.object_detection, TaskEnum.segmentat... \n", - "1 (TaskEnum.segmentation, TaskEnum.thresholding,... \n", - "2 (TaskEnum.segmentation,) \n", - "3 (TaskEnum.segmentation,) \n", - "4 (TaskEnum.object_detection,) \n", + " name description tasks \\\n", + "8 scivision_classifier None (TaskEnum.classificiation,) \n", "\n", " url \\\n", - "0 https://github.com/stardist/stardist \n", - "1 https://github.com/danforthcenter/plantcv \n", - "2 https://github.com/MarniTausen/Greenotyper \n", - "3 https://github.com/alan-turing-institute/cv-al... \n", - "4 https://github.com/alan-turing-institute/scivi... \n", + "8 https://github.com/alan-turing-institute/scivi... \n", "\n", " pkg_url format pretrained \\\n", - "0 git+https://github.com/stardist/stardist.git@main image True \n", - "1 git+https://github.com/danforthcenter/plantcv@... image True \n", - "2 git+https://github.com/MarniTausen/Greenotyper... image True \n", - "3 git+https://github.com/alan-turing-institute/c... image True \n", - "4 git+https://github.com/alan-turing-institute/s... image True \n", - "\n", - " labels_required institution \\\n", - "0 True (epfl,) \n", - "1 True (danforthcenter,) \n", - "2 True (MarniTausen,) \n", - "3 True (alan-turing-institute,) \n", - "4 False (alan-turing-institute,) \n", + "8 git+https://github.com/alan-turing-institute/s... image True \n", "\n", - " tags \n", - "0 (2D, 3D, optical-microscopy, xray, microtomogr... \n", - "1 (2D, hyperspectral, multispectral, near-infrar... \n", - "2 (2D, multispectral, plant-phenotyping, climate... \n", - "3 (dummy,) \n", - "4 (dummy,) " + " labels_required institution tags \n", + "8 False (alan-turing-institute,) (classification, 2D, image) " ] }, "execution_count": 3, @@ -228,8 +140,8 @@ } ], "source": [ - "# Inspecting models in the default catalog\n", - "default_catalog.models.to_dataframe().head()" + "# Inspecting model entry and its metadata in the default catalog\n", + "models_catalog[models_catalog.name == \"scivision_classifier\"]" ] }, { @@ -238,16 +150,54 @@ "source": [ "## Loading the model\n", "\n", - "Next, let's load the \"scivision-test-plugin\" model using the scivision python API, specifically the `load_pretrained_model` function:" + "Some model entries in the scivision catalog contain a single loadable model. Here, let's load the \"scivision_classifier\" entry, which contains each of the models in the [image-classifiers](https://pypi.org/project/image-classifiers/) package. We can do this with the `load_pretrained_model` function. We'll load 2 models (\"resnet18\" and \"densenet121\"), making sure to set the `allow_install` arg to True the first time `load_pretrained_model` is called (note the \"model\" arg is not mandatory and will have a default value for any model catalog entries that have more than one model - for model catalog entries with a single model, this need not be set):" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting scivision_classifier\n", + " Cloning https://github.com/alan-turing-institute/scivision_classifier (to revision main) to /private/var/folders/kf/72snt1z56h56smb3y7c0dxpr9rwb6q/T/pip-install-rxpk_viw/scivision-classifier_19d0d355635f407e9fe031ef64533cc0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " Running command git clone --filter=blob:none --quiet https://github.com/alan-turing-institute/scivision_classifier /private/var/folders/kf/72snt1z56h56smb3y7c0dxpr9rwb6q/T/pip-install-rxpk_viw/scivision-classifier_19d0d355635f407e9fe031ef64533cc0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Resolved https://github.com/alan-turing-institute/scivision_classifier to commit 9ae8cd11232ffd1bddcbcb0a7bbf1172028570ef\n", + " Preparing metadata (setup.py): started\n", + " Preparing metadata (setup.py): finished with status 'done'\n", + "Building wheels for collected packages: scivision_classifier\n", + " Building wheel for scivision_classifier (setup.py): started\n", + " Building wheel for scivision_classifier (setup.py): finished with status 'done'\n", + " Created wheel for scivision_classifier: filename=scivision_classifier-0.0.1-py3-none-any.whl size=3883 sha256=b12a86b66e85c0d4b8debda47ca5cda62221951bf8ba5eba8526222fa3d32ac3\n", + " Stored in directory: /private/var/folders/kf/72snt1z56h56smb3y7c0dxpr9rwb6q/T/pip-ephem-wheel-cache-h25btjdh/wheels/af/27/f9/5c32ecec2f2682373da54294d060008ca1d046e18d74187784\n", + "Successfully built scivision_classifier\n", + "Installing collected packages: scivision_classifier\n", + " Attempting uninstall: scivision_classifier\n", + " Found existing installation: scivision-classifier 0.0.1\n", + " Uninstalling scivision-classifier-0.0.1:\n", + " Successfully uninstalled scivision-classifier-0.0.1\n", + "Successfully installed scivision_classifier-0.0.1\n" + ] + } + ], "source": [ - "model = load_pretrained_model(stp_repo, allow_install=True)" + "resnet_model = load_pretrained_model(model_repo, allow_install=True, model='resnet18')\n", + "densenet_model = load_pretrained_model(model_repo, model='densenet121')" ] }, { @@ -263,9 +213,9 @@ "data": { "text/plain": [ "scivision.PretrainedModel( \n", - " module='scivision_test_plugin', \n", - " model='ImageNetModel', \n", - " source='https://github.com/alan-turing-institute/scivision-test-plugin.git' \n", + " module='scivision_classifier', \n", + " model='resnet18', \n", + " source='https://github.com/alan-turing-institute/scivision_classifier' \n", " pipe='DataPipe(input=, output=)' \n", ")" ] @@ -276,29 +226,29 @@ } ], "source": [ - "# let's explore the model object\n", - "model" + "# let's explore one of the model objects\n", + "resnet_model" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Later, we'll use this ImageNet model to make predictions on image data found in the scivision catalog." + "Later, we'll use these models to make predictions on image data found in the scivision catalog." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Query the default scivision catalog" + "## Query the default scivision data catalog" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now let's use the `default_catalog` to identify datasources in the catalog that are compatible with the model (based on `tasks`, `format` and `labels_provided`/`labels_required`)." + "Now let's use the `default_catalog` to identify datasources in the catalog that are compatible with our models (based on `tasks`, `format` and `labels_provided`/`labels_required`)." ] }, { @@ -342,34 +292,22 @@ " \n", " \n", " \n", - " 0\n", - " data-000\n", + " 2\n", + " data-002\n", " None\n", - " (TaskEnum.object_detection, TaskEnum.segmentat...\n", - " (optical-microscopy,)\n", - " https://github.com/stardist/stardist/releases/...\n", + " (TaskEnum.classificiation,)\n", + " (oceanography,)\n", + " https://github.com/scotthosking/intake-plankto...\n", " image\n", " True\n", - " (epfl,)\n", - " (help-needed, 3D, cell, cell-counting, biology...\n", - " \n", - " \n", - " 1\n", - " data-001\n", - " None\n", - " (TaskEnum.segmentation, TaskEnum.thresholding,...\n", - " (multispectral, hyperspectral)\n", - " https://gitlab.au.dk/AUENG-Vision/OPPD/-/archi...\n", - " image\n", - " True\n", - " (Aarhus University,)\n", - " (help-needed, 2D, plant-phenotyping, agricultu...\n", + " (CEFAS,)\n", + " (help-needed, 2D)\n", " \n", " \n", " 3\n", " data-003\n", " Koala\n", - " (TaskEnum.object_detection,)\n", + " (TaskEnum.object_detection, TaskEnum.classific...\n", " (computer-vision,)\n", " https://github.com/alan-turing-institute/scivi...\n", " image\n", @@ -377,35 +315,70 @@ " (Wikipedia by Erik Veland,)\n", " (demo,)\n", " \n", + " \n", + " 4\n", + " data-004\n", + " Sample dataset of Plankton required to demonst...\n", + " (TaskEnum.classificiation,)\n", + " (computer-vision,)\n", + " https://raw.githubusercontent.com/alan-turing-...\n", + " image\n", + " True\n", + " (Centre for Environment, Fisheries and Aquacul...\n", + " (2D, plankton, ecology, environmental-science)\n", + " \n", + " \n", + " 5\n", + " data-005\n", + " Sample dataset of satellite imagery required t...\n", + " (TaskEnum.classificiation, TaskEnum.segmentation)\n", + " (computer-vision, earth-observation, ecology)\n", + " https://github.com/MartinSJRogers/VEdge_Detect...\n", + " image\n", + " False\n", + " (Cambridge University,)\n", + " (2D, satellite, remote-sensing, ecology, envir...\n", + " \n", " \n", "\n", "" ], "text/plain": [ - " name description tasks \\\n", - "0 data-000 None (TaskEnum.object_detection, TaskEnum.segmentat... \n", - "1 data-001 None (TaskEnum.segmentation, TaskEnum.thresholding,... \n", - "3 data-003 Koala (TaskEnum.object_detection,) \n", + " name description \\\n", + "2 data-002 None \n", + "3 data-003 Koala \n", + "4 data-004 Sample dataset of Plankton required to demonst... \n", + "5 data-005 Sample dataset of satellite imagery required t... \n", "\n", - " domains \\\n", - "0 (optical-microscopy,) \n", - "1 (multispectral, hyperspectral) \n", - "3 (computer-vision,) \n", + " tasks \\\n", + "2 (TaskEnum.classificiation,) \n", + "3 (TaskEnum.object_detection, TaskEnum.classific... \n", + "4 (TaskEnum.classificiation,) \n", + "5 (TaskEnum.classificiation, TaskEnum.segmentation) \n", + "\n", + " domains \\\n", + "2 (oceanography,) \n", + "3 (computer-vision,) \n", + "4 (computer-vision,) \n", + "5 (computer-vision, earth-observation, ecology) \n", "\n", " url format labels_provided \\\n", - "0 https://github.com/stardist/stardist/releases/... image True \n", - "1 https://gitlab.au.dk/AUENG-Vision/OPPD/-/archi... image True \n", + "2 https://github.com/scotthosking/intake-plankto... image True \n", "3 https://github.com/alan-turing-institute/scivi... image True \n", + "4 https://raw.githubusercontent.com/alan-turing-... image True \n", + "5 https://github.com/MartinSJRogers/VEdge_Detect... image False \n", "\n", - " institution \\\n", - "0 (epfl,) \n", - "1 (Aarhus University,) \n", - "3 (Wikipedia by Erik Veland,) \n", + " institution \\\n", + "2 (CEFAS,) \n", + "3 (Wikipedia by Erik Veland,) \n", + "4 (Centre for Environment, Fisheries and Aquacul... \n", + "5 (Cambridge University,) \n", "\n", " tags \n", - "0 (help-needed, 3D, cell, cell-counting, biology... \n", - "1 (help-needed, 2D, plant-phenotyping, agricultu... \n", - "3 (demo,) " + "2 (help-needed, 2D) \n", + "3 (demo,) \n", + "4 (2D, plankton, ecology, environmental-science) \n", + "5 (2D, satellite, remote-sensing, ecology, envir... " ] }, "execution_count": 6, @@ -414,7 +387,7 @@ } ], "source": [ - "compatible_datasources = default_catalog.compatible_datasources(\"scivision-test-plugin\").to_dataframe()\n", + "compatible_datasources = default_catalog.compatible_datasources(\"scivision_classifier\").to_dataframe()\n", "compatible_datasources" ] }, @@ -422,7 +395,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's use `data-003`, a single image dataset (of a baby Koala!)" + "Let's use `data-003`, an image dataset containing a single image of a Koala." ] }, { @@ -471,7 +444,7 @@ " 3\n", " data-003\n", " Koala\n", - " (TaskEnum.object_detection,)\n", + " (TaskEnum.object_detection, TaskEnum.classific...\n", " (computer-vision,)\n", " https://github.com/alan-turing-institute/scivi...\n", " image\n", @@ -484,14 +457,14 @@ "" ], "text/plain": [ - " name description tasks domains \\\n", - "3 data-003 Koala (TaskEnum.object_detection,) (computer-vision,) \n", + " name description tasks \\\n", + "3 data-003 Koala (TaskEnum.object_detection, TaskEnum.classific... \n", "\n", - " url format labels_provided \\\n", - "3 https://github.com/alan-turing-institute/scivi... image True \n", + " domains url \\\n", + "3 (computer-vision,) https://github.com/alan-turing-institute/scivi... \n", "\n", - " institution tags \n", - "3 (Wikipedia by Erik Veland,) (demo,) " + " format labels_provided institution tags \n", + "3 image True (Wikipedia by Erik Veland,) (demo,) " ] }, "execution_count": 7, @@ -572,7 +545,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Clicking the `path` link to the location of this data config file online (in the dataset repo) reveals that there is one data source called `test_image`, and that the `intake_xarray.image.ImageSource` is being used. We can retrive the test image data in an image format which the model will accept, like so:" + "Clicking the `path` link to the location of this data config file online (in the dataset repo) reveals that there is one data source called `test_image`, and that the `intake_xarray.image.ImageSource` \"intake driver\" is being used. We can retrive the test image data in an image format which the model will accept, like so:" ] }, { @@ -584,8 +557,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "/opt/anaconda3/lib/python3.7/site-packages/xarray/core/dataset.py:2178: FutureWarning: None value for 'chunks' is deprecated. It will raise an error in the future. Use instead '{}'\n", - " category=FutureWarning,\n" + "/opt/anaconda3/envs/scivision/lib/python3.9/site-packages/xarray/core/dataset.py:2172: FutureWarning: None value for 'chunks' is deprecated. It will raise an error in the future. Use instead '{}'\n", + " warnings.warn(\n" ] }, { @@ -634,7 +607,7 @@ "}\n", "\n", ".xr-wrap {\n", - " display: block;\n", + " display: block !important;\n", " min-width: 300px;\n", " max-width: 700px;\n", "}\n", @@ -947,23 +920,45 @@ "Coordinates:\n", " * y (y) int64 0 1 2 3 4 5 6 7 8 ... 231 232 233 234 235 236 237 238 239\n", " * x (x) int64 0 1 2 3 4 5 6 7 8 ... 253 254 255 256 257 258 259 260 261\n", - " * channel (channel) int64 0 1 2" ], "text/plain": [ "\n", @@ -1022,7 +1017,7 @@ } ], "source": [ - "test_image = data_config.test_image().to_dask() # The xarray.DataArray is one format accepted by the ImageNet model\n", + "test_image = data_config.test_image().to_dask() # The xarray.DataArray is one format accepted by the our models\n", "test_image" ] }, @@ -1050,7 +1045,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 13, @@ -1059,7 +1054,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1091,7 +1086,7 @@ { "data": { "text/plain": [ - "'koala : 99.80%'" + "'koala : 99.78%'" ] }, "execution_count": 14, @@ -1100,20 +1095,331 @@ } ], "source": [ - "model.predict(test_image)" + "resnet_model.predict(test_image)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'koala : 99.73%'" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "densenet_model.predict(test_image)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you can see, the models have given predictions for the test image, with a confidence score. Check out the code in the [model repo](https://github.com/alan-turing-institute/scivision_classifier) to see how this was determined!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "As you can see, this model has given a prediction of the test image, with a confidence score. Check out the code in the model repo to see how this was determined!" + "## Query the default scivision model catalog\n", + "\n", + "Using our test Koala image dataset, let's search the scivision default catalog for other models that can be used with it:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
namedescriptiontasksurlpkg_urlformatpretrainedlabels_requiredinstitutiontags
0model-000None(TaskEnum.object_detection, TaskEnum.segmentat...https://github.com/stardist/stardistgit+https://github.com/stardist/stardist.git@mainimageTrueTrue(epfl,)(2D, 3D, optical-microscopy, xray, microtomogr...
1model-001None(TaskEnum.segmentation, TaskEnum.thresholding,...https://github.com/danforthcenter/plantcvgit+https://github.com/danforthcenter/plantcv@...imageTrueTrue(danforthcenter,)(2D, hyperspectral, multispectral, near-infrar...
4scivision-test-pluginNone(TaskEnum.object_detection,)https://github.com/alan-turing-institute/scivi...git+https://github.com/alan-turing-institute/s...imageTrueFalse(alan-turing-institute,)(dummy,)
5mapreader-plantautomated detection of plant patches in images...(TaskEnum.classificiation, TaskEnum.object_det...https://github.com/alan-turing-institute/mapre...git+https://github.com/alan-turing-institute/m...imageTrueFalse(alan-turing-institute,)(2D, plant, phenotype, rgb, biology, agriculture)
6resnet50-plantktonautomated classification of plankton images co...(TaskEnum.classificiation,)https://github.com/alan-turing-institute/plank...git+https://github.com/alan-turing-institute/p...imageTrueFalse(alan-turing-institute, cefas, plankton-analyt...(2D, plankton, ecology, environmental-science)
8scivision_classifierNone(TaskEnum.classificiation,)https://github.com/alan-turing-institute/scivi...git+https://github.com/alan-turing-institute/s...imageTrueFalse(alan-turing-institute,)(classification, 2D, image)
9scivision_huggingfaceNone(TaskEnum.classificiation,)https://github.com/alan-turing-institute/scivi...git+https://github.com/alan-turing-institute/s...imageTrueFalse(alan-turing-institute,)(classification, 2D, image)
\n", + "
" + ], + "text/plain": [ + " name description \\\n", + "0 model-000 None \n", + "1 model-001 None \n", + "4 scivision-test-plugin None \n", + "5 mapreader-plant automated detection of plant patches in images... \n", + "6 resnet50-plantkton automated classification of plankton images co... \n", + "8 scivision_classifier None \n", + "9 scivision_huggingface None \n", + "\n", + " tasks \\\n", + "0 (TaskEnum.object_detection, TaskEnum.segmentat... \n", + "1 (TaskEnum.segmentation, TaskEnum.thresholding,... \n", + "4 (TaskEnum.object_detection,) \n", + "5 (TaskEnum.classificiation, TaskEnum.object_det... \n", + "6 (TaskEnum.classificiation,) \n", + "8 (TaskEnum.classificiation,) \n", + "9 (TaskEnum.classificiation,) \n", + "\n", + " url \\\n", + "0 https://github.com/stardist/stardist \n", + "1 https://github.com/danforthcenter/plantcv \n", + "4 https://github.com/alan-turing-institute/scivi... \n", + "5 https://github.com/alan-turing-institute/mapre... \n", + "6 https://github.com/alan-turing-institute/plank... \n", + "8 https://github.com/alan-turing-institute/scivi... \n", + "9 https://github.com/alan-turing-institute/scivi... \n", + "\n", + " pkg_url format pretrained \\\n", + "0 git+https://github.com/stardist/stardist.git@main image True \n", + "1 git+https://github.com/danforthcenter/plantcv@... image True \n", + "4 git+https://github.com/alan-turing-institute/s... image True \n", + "5 git+https://github.com/alan-turing-institute/m... image True \n", + "6 git+https://github.com/alan-turing-institute/p... image True \n", + "8 git+https://github.com/alan-turing-institute/s... image True \n", + "9 git+https://github.com/alan-turing-institute/s... image True \n", + "\n", + " labels_required institution \\\n", + "0 True (epfl,) \n", + "1 True (danforthcenter,) \n", + "4 False (alan-turing-institute,) \n", + "5 False (alan-turing-institute,) \n", + "6 False (alan-turing-institute, cefas, plankton-analyt... \n", + "8 False (alan-turing-institute,) \n", + "9 False (alan-turing-institute,) \n", + "\n", + " tags \n", + "0 (2D, 3D, optical-microscopy, xray, microtomogr... \n", + "1 (2D, hyperspectral, multispectral, near-infrar... \n", + "4 (dummy,) \n", + "5 (2D, plant, phenotype, rgb, biology, agriculture) \n", + "6 (2D, plankton, ecology, environmental-science) \n", + "8 (classification, 2D, image) \n", + "9 (classification, 2D, image) " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "compatible_models = default_catalog.compatible_models(\"data-003\").to_dataframe()\n", + "compatible_models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `scivision_huggingface` catalog entry can be used to load some of the most popular image classification models from [Hugging Face](https://huggingface.co/models?pipeline_tag=image-classification&sort=downloads). See the list of included models in the [model repo](https://github.com/alan-turing-institute/scivision_huggingface). As before, let's load one of the named models and run it on our test image:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting scivision_huggingface\n", + " Cloning https://github.com/alan-turing-institute/scivision_huggingface (to revision main) to /private/var/folders/kf/72snt1z56h56smb3y7c0dxpr9rwb6q/T/pip-install-2e3d9ms4/scivision-huggingface_b64d98ce9a5c4bf08b45917d70b30ecf\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " Running command git clone --filter=blob:none --quiet https://github.com/alan-turing-institute/scivision_huggingface /private/var/folders/kf/72snt1z56h56smb3y7c0dxpr9rwb6q/T/pip-install-2e3d9ms4/scivision-huggingface_b64d98ce9a5c4bf08b45917d70b30ecf\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Resolved https://github.com/alan-turing-institute/scivision_huggingface to commit 16df12f6872876b1b22ea45a3a2f33dd42091087\n", + " Preparing metadata (setup.py): started\n", + " Preparing metadata (setup.py): finished with status 'done'\n", + "Building wheels for collected packages: scivision_huggingface\n", + " Building wheel for scivision_huggingface (setup.py): started\n", + " Building wheel for scivision_huggingface (setup.py): finished with status 'done'\n", + " Created wheel for scivision_huggingface: filename=scivision_huggingface-0.0.1-py3-none-any.whl size=3817 sha256=6cc49b09ae48bed70862bcda01bf83899539eeb1e7da07ba0579f432fcbeef4e\n", + " Stored in directory: /private/var/folders/kf/72snt1z56h56smb3y7c0dxpr9rwb6q/T/pip-ephem-wheel-cache-7y7ve25i/wheels/58/43/19/be5a260399f14abe94dbcffed3df890b92e52dc026f56e3ec2\n", + "Successfully built scivision_huggingface\n", + "Installing collected packages: scivision_huggingface\n", + " Attempting uninstall: scivision_huggingface\n", + " Found existing installation: scivision-huggingface 0.0.1\n", + " Uninstalling scivision-huggingface-0.0.1:\n", + " Successfully uninstalled scivision-huggingface-0.0.1\n", + "Successfully installed scivision_huggingface-0.0.1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/scivision/lib/python3.9/site-packages/torch/functional.py:568: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at /Users/distiller/project/pytorch/aten/src/ATen/native/TensorShape.cpp:2228.)\n", + " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n" + ] + } + ], + "source": [ + "huggingface_repo = models_catalog[models_catalog.name == \"scivision_huggingface\"].url.item()\n", + "microsoft_model = load_pretrained_model(huggingface_repo, allow_install=True, model='microsoft_swin_tiny_patch4_window7_224')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Predicted class: koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus'" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "microsoft_model.predict(test_image)" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1127,7 +1433,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.9.12" } }, "nbformat": 4, diff --git a/requirements.txt b/requirements.txt index 1ba40e31..ab3dbe65 100644 --- a/requirements.txt +++ b/requirements.txt @@ -9,3 +9,4 @@ aiohttp intake intake-xarray pydantic +exifread \ No newline at end of file diff --git a/setup.py b/setup.py index bc1bf4e5..da5494b4 100644 --- a/setup.py +++ b/setup.py @@ -13,9 +13,13 @@ if len(stripped) > 0: requirements.append(stripped) +requirements.append( + 'intake-xarray @ git+https://github.com/ots22/intake-xarray@feature/exif', +) + setup( name="scivision", - version="0.2.5", + version="0.2.6", description="scivision", author="The Alan Turing Institute", author_email="scivision@turing.ac.uk",