From b77088730c7ac5819f61e6a89e9338c1dfa40d84 Mon Sep 17 00:00:00 2001 From: Daochen Zha Date: Mon, 12 Jul 2021 10:10:24 -0500 Subject: [PATCH] First commit --- .gitignore | 115 +++ CONTRIBUTING.md | 32 + LICENSE.md | 7 + README.md | 140 ++- autovideo/__init__.py | 4 + autovideo/base/supervised_base.py | 85 ++ autovideo/common/column_parser.py | 397 ++++++++ autovideo/common/construct_predictions.py | 261 ++++++ autovideo/common/dataset_to_dataframe.py | 86 ++ autovideo/common/dataset_utils.py | 52 ++ autovideo/common/denormalize.py | 555 +++++++++++ .../common/extract_columns_semantic_types.py | 141 +++ autovideo/common/utils.py | 192 ++++ autovideo/recognition/R2p1D/mean.py | 17 + autovideo/recognition/R2p1D/model.py | 127 +++ .../recognition/R2p1D/models/__init__.py | 0 .../recognition/R2p1D/models/densenet.py | 185 ++++ .../R2p1D/models/pre_act_resnet.py | 105 +++ autovideo/recognition/R2p1D/models/resnet.py | 234 +++++ .../recognition/R2p1D/models/resnet2p1d.py | 286 ++++++ autovideo/recognition/R2p1D/models/resnext.py | 74 ++ .../recognition/R2p1D/models/wide_resnet.py | 26 + autovideo/recognition/R2p1D/opts.py | 295 ++++++ autovideo/recognition/R2p1D/utils.py | 97 ++ autovideo/recognition/c3d_primitive.py | 400 ++++++++ autovideo/recognition/eco_full_primitive.py | 393 ++++++++ autovideo/recognition/eco_primitive.py | 861 ++++++++++++++++++ autovideo/recognition/eco_utils/__init__.py | 2 + autovideo/recognition/eco_utils/eco/ECO.yaml | 256 ++++++ .../recognition/eco_utils/eco/__init__.py | 0 .../eco_utils/eco/layer_factory.py | 134 +++ .../recognition/eco_utils/eco/pytorch_load.py | 95 ++ .../eco_utils/eco_full/ECOFull.yaml | 676 ++++++++++++++ .../eco_utils/eco_full/__init__.py | 0 .../eco_utils/eco_full/layer_factory.py | 136 +++ .../eco_utils/eco_full/pytorch_load.py | 95 ++ autovideo/recognition/i3d_primitive.py | 771 ++++++++++++++++ autovideo/recognition/r2p1d_primitive.py | 588 ++++++++++++ autovideo/recognition/r3d_primitive.py | 582 ++++++++++++ autovideo/recognition/tsm_primitive.py | 645 +++++++++++++ autovideo/recognition/tsn_primitive.py | 551 +++++++++++ autovideo/searcher/__init__.py | 1 + autovideo/searcher/base.py | 20 + autovideo/searcher/ray_searcher.py | 70 ++ autovideo/utils/__init__.py | 5 + autovideo/utils/axolotl_utils.py | 117 +++ autovideo/utils/d3m_utils.py | 129 +++ autovideo/utils/dataset.py | 142 +++ autovideo/utils/frames_utils.py | 65 ++ autovideo/utils/logging_utils.py | 23 + autovideo/utils/models/densenet.py | 151 +++ autovideo/utils/models/pre_act_resnet.py | 226 +++++ autovideo/utils/models/resnet.py | 233 +++++ autovideo/utils/models/resnext.py | 176 ++++ autovideo/utils/models/wide_resnet.py | 163 ++++ autovideo/utils/training_utils.py | 106 +++ autovideo/utils/transforms.py | 368 ++++++++ datasets/put_datasets_here | 0 docs/autovideo_logo.png | Bin 0 -> 28454 bytes docs/benchmark.md | 23 + docs/demo.gif | Bin 0 -> 2036789 bytes docs/overview.jpg | Bin 0 -> 178838 bytes entry_points.ini | 17 + examples/fit.py | 62 ++ examples/fit_produce.py | 68 ++ examples/produce.py | 60 ++ examples/recogonize.py | 43 + examples/search.py | 69 ++ setup.py | 56 ++ weights/put_weights_here | 0 70 files changed, 12090 insertions(+), 1 deletion(-) create mode 100644 .gitignore create mode 100644 CONTRIBUTING.md create mode 100644 LICENSE.md create mode 100644 autovideo/__init__.py create mode 100644 autovideo/base/supervised_base.py create mode 100644 autovideo/common/column_parser.py create mode 100644 autovideo/common/construct_predictions.py create mode 100644 autovideo/common/dataset_to_dataframe.py create mode 100644 autovideo/common/dataset_utils.py create mode 100644 autovideo/common/denormalize.py create mode 100644 autovideo/common/extract_columns_semantic_types.py create mode 100644 autovideo/common/utils.py create mode 100644 autovideo/recognition/R2p1D/mean.py create mode 100644 autovideo/recognition/R2p1D/model.py create mode 100644 autovideo/recognition/R2p1D/models/__init__.py create mode 100644 autovideo/recognition/R2p1D/models/densenet.py create mode 100644 autovideo/recognition/R2p1D/models/pre_act_resnet.py create mode 100644 autovideo/recognition/R2p1D/models/resnet.py create mode 100644 autovideo/recognition/R2p1D/models/resnet2p1d.py create mode 100644 autovideo/recognition/R2p1D/models/resnext.py create mode 100644 autovideo/recognition/R2p1D/models/wide_resnet.py create mode 100644 autovideo/recognition/R2p1D/opts.py create mode 100644 autovideo/recognition/R2p1D/utils.py create mode 100644 autovideo/recognition/c3d_primitive.py create mode 100644 autovideo/recognition/eco_full_primitive.py create mode 100644 autovideo/recognition/eco_primitive.py create mode 100644 autovideo/recognition/eco_utils/__init__.py create mode 100644 autovideo/recognition/eco_utils/eco/ECO.yaml create mode 100644 autovideo/recognition/eco_utils/eco/__init__.py create mode 100644 autovideo/recognition/eco_utils/eco/layer_factory.py create mode 100644 autovideo/recognition/eco_utils/eco/pytorch_load.py create mode 100644 autovideo/recognition/eco_utils/eco_full/ECOFull.yaml create mode 100644 autovideo/recognition/eco_utils/eco_full/__init__.py create mode 100644 autovideo/recognition/eco_utils/eco_full/layer_factory.py create mode 100644 autovideo/recognition/eco_utils/eco_full/pytorch_load.py create mode 100644 autovideo/recognition/i3d_primitive.py create mode 100644 autovideo/recognition/r2p1d_primitive.py create mode 100644 autovideo/recognition/r3d_primitive.py create mode 100644 autovideo/recognition/tsm_primitive.py create mode 100644 autovideo/recognition/tsn_primitive.py create mode 100644 autovideo/searcher/__init__.py create mode 100644 autovideo/searcher/base.py create mode 100644 autovideo/searcher/ray_searcher.py create mode 100644 autovideo/utils/__init__.py create mode 100644 autovideo/utils/axolotl_utils.py create mode 100644 autovideo/utils/d3m_utils.py create mode 100644 autovideo/utils/dataset.py create mode 100644 autovideo/utils/frames_utils.py create mode 100644 autovideo/utils/logging_utils.py create mode 100644 autovideo/utils/models/densenet.py create mode 100644 autovideo/utils/models/pre_act_resnet.py create mode 100644 autovideo/utils/models/resnet.py create mode 100644 autovideo/utils/models/resnext.py create mode 100644 autovideo/utils/models/wide_resnet.py create mode 100644 autovideo/utils/training_utils.py create mode 100644 autovideo/utils/transforms.py create mode 100644 datasets/put_datasets_here create mode 100644 docs/autovideo_logo.png create mode 100644 docs/benchmark.md create mode 100644 docs/demo.gif create mode 100644 docs/overview.jpg create mode 100644 entry_points.ini create mode 100644 examples/fit.py create mode 100644 examples/fit_produce.py create mode 100644 examples/produce.py create mode 100644 examples/recogonize.py create mode 100644 examples/search.py create mode 100644 setup.py create mode 100644 weights/put_weights_here diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..694daa6 --- /dev/null +++ b/.gitignore @@ -0,0 +1,115 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +tests/.asv + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ +docs/d3m.rst +docs/d3m.*.rst + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mypy +.mypy_cache/ + +# site +public/ + +.idea/ +tmp/ + +*.swp +*.swo +.DS_Store +pipeline.json +log.txt +fitted_pipeline diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..1026668 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,32 @@ +# Contibuting Guide +Contribution to this project is greatly appreciated! If you find any bugs or have any feedback, please create an issue or send a pull request to fix the bug. If you want to contribute codes for new features, please follow this guide. We currently have several plans. Please create an issue or contact us through emails if you have other suggestions. + +## Roadmaps +* **Skeleton-based action recogonition.** We plan to include more action recogonition algorithms such as skeleton-based methods +* **Object dectection.** We plan to inlcude obeject dectection primitives + +## How to Create a Pull Request + +If this your first time to contribute to a project, kindly follow the following instructions. You may find [Creating a pull request](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/creating-a-pull-request) helpful. Mainly, you need to take the following steps to send a pull request: + +* Click **Fork** in the upper-right corner of the project main page to create a new branch in your local Github. +* Clone the repo from your local repo in your Github. +* Make changes in your computer. +* Commit and push your local changes to your local repo. +* Send a pull request to merge your local branch to the branches in RLCard project. + +## How to Create a New Primitive + +AutoVideo uses general pipeline languages. Each module is wrapped as a primitive. Since most of the tasks are supervised, we have provided a supervised base primitive in [autovideo/base/supervised_base.py](autovideo/base/supervised_base.py). Of course, we can also include unsupervised primitives, which are supported in D3M. Please don't hesitate to contact us if you need a guide. To create a supervised primitive, you generally need to follow the steps below: + +* Create a new file and inherit the classes in [autovideo/base/supervised_base.py](autovideo/base/supervised_base.py). +* Create hyperparameters in `SupervisedHyperparamsBase`. +* Put the important variables that you want them to be saved and reused into `SupervisedParamsBase`. Be default, we assume you will save the model class. +* Implement the functions in `SupervisedPrimitiveBase`, such as `fit`, `produce`, etc. +* Register the primitive in [entry_points.ini](entry_points.ini). +* Reinstall Autovideo with `pip3 install -e .`. +* Run `python3 -m d3m index search` and make sure that your primitive is in the list. +* Then you can use your primitive! You can play with the [pipeline](autovideo/utils/d3m_utils.py#L61) and add your primitive to the pipeline. + +Note that there are many more details that are not mentioned in the above steps. You may refer to the example of [TSN](autovideo/recognition/tsn_primitive.py) to learn more. + diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 0000000..ffe269b --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,7 @@ +Copyright (c) 2021 DATA Lab at Texas A&M University + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/README.md b/README.md index 6383bc8..60054e5 100644 --- a/README.md +++ b/README.md @@ -1 +1,139 @@ -# autovideo +# AutoVideo: An Automated Video Action Recognition System +Logo + +AutoVideo is a system for automated video analysis. It is developed based on [D3M](https://gitlab.com/datadrivendiscovery/d3m) infrastructure, which describes machine learning with generic pipeline languages. Currently, it focuses on video action recognition, supporting various state-of-the-art video action recognition algorithms. It also supports automated model selection and hyperparameter tuning. AutoVideo is developed by [DATA Lab](http://faculty.cs.tamu.edu/xiahu/) at Texas A&M University. + +There are some other video analysis libraries out there, but this one is designed to be highly modular. AutoVideo is highly extendible thanks to the pipeline language, where each model is wrapped as a primitive with some hyperparameters. This allows us to easily support other algorithms for other video analysis tasks, which will be our future efforts. It is also convenient to search models and hyperparameters with the pipeline language. + +Demo + +An overview of the library is shown as below. Each module in AutoVideo is wrapped as a primitive with some hyperparameters. A pipeline consists of a series of primitives from pre-processing to action recognition. AutoVideo is equipped with tuners to search models and hyperparameters. We welcome contributions to enrich AutoVideo with more primitives. You can find instructions in [Contributing Guide](./CONTRIBUTING.md). + +Overview + +## Cite this work +If you find this repo useful, you may cite: + +## Installation +Make sure that you have **Python 3.6** and **pip** installed. First, install `torch` and `torchvision` with +``` +pip3 install torch +pip3 install torchvision +``` +To use the automated searching, you need to install ray-tune with +``` +pip install 'ray[tune]' +``` +We recommend installing the stable version of `autovideo` with `pip`: +``` +pip3 install autovideo +``` +Alternatively, you can clone the latest version with +``` +git clone https://github.com/datamllab/autovideo.git +``` +Then install with +``` +cd autovideo +pip3 install -e . +``` + +## Toy Examples +To try the examples, you may download `hmdb6` dataset, which is a subset of `hmdb51` with only 51 classes. All the datasets can be downloaded from [Google Drive](https://drive.google.com/drive/folders/13oVPMyoBgNwEAsE_Ad3XVI1W5cNqfvrq). Then, you may unzip a dataset and put it in [datasets](datasets/). +### Fitting and saving a pipeline +``` +python3 examples/fit.py +``` +Some important hyperparameters are as follows. +* `--alg`: the supported algorithm. Currently we support `tsn`, `tsm`, `i3d`, `eco`, `eco_full`, `c3d`, `r2p1d`, and `r3d`. +* `--pretrained`: whether loading pre-trained weights and fine-tuning. +* `--gpu`: which gpu device tp use. Empty string for CPU. +* `--data_dir`: the directory of the dataset +* `--log_dir`: the path for sainge the log +* `--save_dir`: the path for saving the fitted pipeline + +### Loading a fitted pipeline and producing predictions +After fitting a pipeline, you can load a pipeline and make predictions. +``` +python3 examples/produce.py +``` +Some important hyperparameters are as follows. +* `--gpu`: which gpu device tp use. Empty string for CPU. +* `--data_dir`: the directory of the dataset +* `--log_dir`: the path for sainge the log +* `--load_dir`: the path for loading the fitted pipeline + +### Loading a fitted pipeline and recogonizing actions +After fitting a pipeline, you can also make predicitons on a single video. As a demo, you may download the fitted pipeline and the demo video from [Google Drive](https://drive.google.com/drive/folders/1j4iGUQG3m_TXbQ8mQnaR_teg1w0I2x60). Then, you can use the following command to recogonize the action in the video: +``` +python3 examples/recogonize.py +``` +Some important hyperparameters are as follows. +* `--gpu`: which gpu device tp use. Empty string for CPU. +* `--video_path`: the path of video file +* `--log_dir`: the path for sainge the log +* `--load_dir`: the path for loading the fitted pipeline + +### Fitting and producing a pipeline +Alternatively, you can do `fit` and `produce` without saving the model with +``` +python3 examples/fit_produce.py +``` +Some important hyperparameters are as follows. +* `--alg`: the supported algorithm. +* `--pretrained`: whether loading pre-trained weights and fine-tuning. +* `--gpu`: which gpu device tp use. Empty string for CPU. +* `--data_dir`: the directory of the dataset +* `--log_dir`: the path for sainge the log + +### Automated searching +In addition to running them by yourself, we also support automated model selection and hyperparameter tuning: +``` +python3 examples/search.py +``` +Some important hyperparameters are as follows. +* `--alg`: the searching algorithm. Currently, we support `random` and `hyperopt`. +* `--num_samples`: the number of samples to be tried +* `--gpu`: which gpu device tp use. Empty string for CPU. +* `--data_dir`: the directory of the dataset + +## Supported Algorithms + +| Algorithms | Primitive Path | Paper | +| :--------: | :----------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------- | +| TSN | [autovideo/recognition/tsn_primitive.py](autovideo/recognition/tsn_primitive.py) | [Temporal Segment Networks: Towards Good Practices for Deep Action Recognition](https://arxiv.org/abs/1608.00859) | +| TSM | [autovideo/recognition/tsm_primitive.py](autovideo/recognition/tsm_primitive.py) | [TSM: Temporal Shift Module for Efficient Video Understanding](https://arxiv.org/abs/1811.08383) | +| R2P1D | [autovideo/recognition/r2p1d_primitive.py](autovideo/recognition/r2p1d_primitive.py) | [A Closer Look at Spatiotemporal Convolutions for Action Recognition](https://arxiv.org/abs/1711.11248) | +| R3D | [autovideo/recognition/r3d_primitive.py](autovideo/recognition/r3d_primitive.py) | [Learning spatio-temporal features with 3d residual networks for action recognition](https://arxiv.org/abs/1708.07632) | +| C3D | [autovideo/recognition/c3d_primitive.py](autovideo/recognition/c3d_primitive.py) | [Learning Spatiotemporal Features with 3D Convolutional Networks](https://arxiv.org/abs/1412.0767) | +| ECO-Lite | [autovideo/recognition/eco_primitive.py](autovideo/recognition/eco_primitive.py) | [ECO: Efficient Convolutional Network for Online Video Understanding](https://arxiv.org/abs/1804.09066) | +| ECO-Full | [autovideo/recognition/eco_full_primitive.py](autovideo/recognition/eco_full_primitive.py) | [ECO: Efficient Convolutional Network for Online Video Understanding](https://arxiv.org/abs/1804.09066) | +| I3D | [autovideo/recognition/i3d_primitive.py](autovideo/recognition/i3d_primitive.py) | [Quo Vadis, Action Recognition? A New Model and the Kinetics Dataset](https://arxiv.org/abs/1705.07750) | + +## Advanced Usage +Beyond the above examples, you can also customize the configurations. + +### Configuring the hypereparamters +Each model in AutoVideo is wrapped as a primitive, which contains some hyperparameters. An example of TSN is [here](autovideo/recognition/tsn_primitive.py#L31-78). All the hyperparameters can be specified when building the pipeline by passing a `config` dictionary. See [examples/fit.py](examples/fit.py#L40-42). + +### Configuring the search space +The tuner will search the best hyperparamter combinations within a search sapce to improve the performance. The search space can be defined with ray-tune. See [examples/search.py](examples/search.py#L42-47). + +## Preparing datasets and benchmarking +The datasets must follow d3m format, which consists of a csv file and a media folder. The csv file should have three columns to specify the instance indices, video file names and labels. An example is as below +``` +d3mIndex,video,label +0,Aussie_Brunette_Brushing_Hair_II_brush_hair_u_nm_np1_ri_med_3.avi,0 +1,brush_my_hair_without_wearing_the_glasses_brush_hair_u_nm_np1_fr_goo_2.avi,0 +2,Brushing_my_waist_lenth_hair_brush_hair_u_nm_np1_ba_goo_0.avi,0 +3,brushing_raychel_s_hair_brush_hair_u_cm_np2_ri_goo_2.avi,0 +4,Brushing_Her_Hair__[_NEW_AUDIO_]_UPDATED!!!!_brush_hair_h_cm_np1_le_goo_1.avi,0 +5,Haarek_mmen_brush_hair_h_cm_np1_fr_goo_0.avi,0 +6,Haarek_mmen_brush_hair_h_cm_np1_fr_goo_1.avi,0 +7,Prelinger_HabitPat1954_brush_hair_h_nm_np1_fr_med_26.avi,0 +8,brushing_hair_2_brush_hair_h_nm_np1_ba_med_2.avi,0 +``` +The media folder should contain video files. You may refer to our example hmdb6 dataset in [Google Drive](https://drive.google.com/drive/folders/13oVPMyoBgNwEAsE_Ad3XVI1W5cNqfvrq). We have also prepared hmdb51 and ucf101 in the Google Drive for benchmarking. Please read [benchmark](docs/benchmark.md) for more details. For some of the algorithms (C3D, R2P1D and R3D), if you want to load the pre-trained weights and fine-tune, you need to download the weights from [Google Drive](https://drive.google.com/drive/folders/1fABdnH-l92q2RbA8hfQnUPZOYoTZCR-Q) and put it to [weights](weights). + +## Acknowledgement +We gratefully acknowledge the Data Driven Discovery of Models (D3M) program of the Defense Advanced Research Projects Agency (DARPA). diff --git a/autovideo/__init__.py b/autovideo/__init__.py new file mode 100644 index 0000000..78b8944 --- /dev/null +++ b/autovideo/__init__.py @@ -0,0 +1,4 @@ +name = "autovideo" +__version__ = "0.0.1" + +from .utils import build_pipeline, extract_frames, fit, produce, fit_produce, produce_by_path, compute_accuracy_with_preds diff --git a/autovideo/base/supervised_base.py b/autovideo/base/supervised_base.py new file mode 100644 index 0000000..10884f7 --- /dev/null +++ b/autovideo/base/supervised_base.py @@ -0,0 +1,85 @@ +import os +import abc +import typing +from urllib.parse import urlparse + +import torch + +from d3m import container +from d3m.primitive_interfaces.base import * +from d3m.metadata import hyperparams, params + +__all__ = ('SupervisedParamsBase', 'SupervisedHyperparamsBase', 'SupervisedPrimitiveBase',) + +class SupervisedParamsBase(params.Params): + model: typing.Optional[typing.Any] + +class SupervisedHyperparamsBase(hyperparams.Hyperparams): + load_pretrained = hyperparams.UniformBool( + default=False, + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Controls whether loading pre-trained model" + ) + +class SupervisedPrimitiveBase(PrimitiveBase[Inputs, Outputs, Params, Hyperparams]): + """ A base for supervised learning for video racognition + """ + def __init__(self, *, hyperparams: Hyperparams) -> None: + super().__init__(hyperparams=hyperparams) + + self.tmp_dir = 'tmp' + if not os.path.exists(self.tmp_dir): + os.makedirs(self.tmp_dir) + + # Use GPU if available + if torch.cuda.is_available(): + print("--> Running on the GPU") + self.device = torch.device("cuda:0") + else: + self.device = torch.device("cpu") + print("--> Running on the CPU") + + def get_params(self) -> Params: + return SupervisedParamsBase( + model = self.model, + ) + + def set_params(self, *, params: Params) -> None: + self.model = params['model'] + + def fit(self, *, timeout: float = None, iterations: int = None) -> CallResult[None]: + """ + Fit the model with training data. Check whether we need fine-tune + """ + self._init_model(pretrained = self.hyperparams['load_pretrained']) + self._fit(timeout=timeout, iterations=iterations) + + return CallResult(None) + + def set_training_data(self, *, inputs: Inputs, outputs: Outputs) -> None: + self._inputs = inputs + self._outputs = outputs + try: + self._media_dir = urlparse(self._inputs.metadata.query_column(0)['location_base_uris'][0]).path + except KeyError: + pass + + @abc.abstractmethod + def _fit(self, *, timeout: float = None, iterations: int = None): + """ + Training + """ + + @abc.abstractmethod + def _init_model(self, pretrained): + """ + Initialize the model. Loading the weights if pretrained is True + """ + + @abc.abstractmethod + def produce(self, *, inputs: container.DataFrame, timeout: float = None, iterations: int = None) -> CallResult[container.DataFrame]: + """ + make the predictions + """ + + diff --git a/autovideo/common/column_parser.py b/autovideo/common/column_parser.py new file mode 100644 index 0000000..8316080 --- /dev/null +++ b/autovideo/common/column_parser.py @@ -0,0 +1,397 @@ +import hashlib +import os +import typing + +import numpy # type: ignore + +from d3m import container, utils as d3m_utils +from d3m.base import utils as base_utils +from d3m.metadata import base as metadata_base, hyperparams +from d3m.primitive_interfaces import base, transformer + +from autovideo.common import utils + +__all__ = ('ColumnParserPrimitive',) + +Inputs = container.DataFrame +Outputs = container.DataFrame + + +class Hyperparams(hyperparams.Hyperparams): + parse_semantic_types = hyperparams.Set( + elements=hyperparams.Enumeration( + values=[ + 'http://schema.org/Boolean', 'https://metadata.datadrivendiscovery.org/types/CategoricalData', + 'http://schema.org/Integer', 'http://schema.org/Float', + 'https://metadata.datadrivendiscovery.org/types/FloatVector', 'http://schema.org/DateTime', + ], + # Default is ignored. + # TODO: Remove default. See: https://gitlab.com/datadrivendiscovery/d3m/issues/141 + default='http://schema.org/Boolean', + ), + default=( + 'http://schema.org/Boolean', 'https://metadata.datadrivendiscovery.org/types/CategoricalData', + 'http://schema.org/Integer', 'http://schema.org/Float', + 'https://metadata.datadrivendiscovery.org/types/FloatVector', 'http://schema.org/DateTime', + ), + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="A set of semantic types to parse. One can provide a subset of supported semantic types to limit what the primitive parses.", + ) + use_columns = hyperparams.Set( + elements=hyperparams.Hyperparameter[int](-1), + default=(), + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="A set of column indices to force primitive to operate on. If any specified column cannot be parsed, it is skipped.", + ) + exclude_columns = hyperparams.Set( + elements=hyperparams.Hyperparameter[int](-1), + default=(), + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="A set of column indices to not operate on. Applicable only if \"use_columns\" is not provided.", + ) + return_result = hyperparams.Enumeration( + values=['append', 'replace', 'new'], + default='replace', + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Should parsed columns be appended, should they replace original columns, or should only parsed columns be returned?", + ) + add_index_columns = hyperparams.UniformBool( + default=True, + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Also include primary index columns if input data has them. Applicable only if \"return_result\" is set to \"new\".", + ) + parse_categorical_target_columns = hyperparams.UniformBool( + default=False, + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Should it parse also categorical target columns?", + ) + replace_index_columns = hyperparams.UniformBool( + default=True, + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Replace primary index columns even if otherwise appending columns. Applicable only if \"return_result\" is set to \"append\".", + ) + fuzzy_time_parsing = hyperparams.UniformBool( + default=True, + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Use fuzzy time parsing.", + ) + + +class ColumnParserPrimitive(transformer.TransformerPrimitiveBase[Inputs, Outputs, Hyperparams]): + """ + A primitive which parses strings into their parsed values. + + It goes over all columns (by default, controlled by ``use_columns``, ``exclude_columns``) + and checks those with structural type ``str`` if they have a semantic type suggesting + that they are a boolean value, categorical, integer, float, or time (by default, + controlled by ``parse_semantic_types``). Categorical values are converted with + hash encoding. + + What is returned is controlled by ``return_result`` and ``add_index_columns``. + """ + + metadata = metadata_base.PrimitiveMetadata( + { + 'id': 'd510cb7a-1782-4f51-b44c-58f0236e47c7', + 'version': '0.6.0', + 'name': "Parses strings into their types", + 'python_path': 'd3m.primitives.autovideo.common.column_parser', + 'source': { + 'name': 'TAMU DATALAB - Zaid Pervaiz Bhat', + 'contact': 'mailto:mitar.commonprimitives@tnode.com', + 'uris': [ + 'https://gitlab.com/datadrivendiscovery/common-primitives/blob/master/common_primitives/column_parser.py', + 'https://gitlab.com/datadrivendiscovery/common-primitives.git', + ], + }, + 'installation': [{ + 'type': metadata_base.PrimitiveInstallationType.PIP, + 'package_uri': 'git+https://gitlab.com/datadrivendiscovery/common-primitives.git@{git_commit}#egg=common_primitives'.format( + git_commit=d3m_utils.current_git_commit(os.path.dirname(__file__)), + ), + }], + 'algorithm_types': [ + metadata_base.PrimitiveAlgorithmType.DATA_CONVERSION, + ], + 'primitive_family': metadata_base.PrimitiveFamily.DATA_TRANSFORMATION, + }, + ) + + def produce(self, *, inputs: Inputs, timeout: float = None, iterations: int = None) -> base.CallResult[Outputs]: + columns_to_use, output_columns = self._produce_columns(inputs) + + if self.hyperparams['replace_index_columns'] and self.hyperparams['return_result'] == 'append': + assert len(columns_to_use) == len(output_columns) + + index_columns = inputs.metadata.get_index_columns() + + index_columns_to_use = [] + other_columns_to_use = [] + index_output_columns = [] + other_output_columns = [] + for column_to_use, output_column in zip(columns_to_use, output_columns): + if column_to_use in index_columns: + index_columns_to_use.append(column_to_use) + index_output_columns.append(output_column) + else: + other_columns_to_use.append(column_to_use) + other_output_columns.append(output_column) + + outputs = base_utils.combine_columns(inputs, index_columns_to_use, index_output_columns, return_result='replace', add_index_columns=self.hyperparams['add_index_columns']) + outputs = base_utils.combine_columns(outputs, other_columns_to_use, other_output_columns, return_result='append', add_index_columns=self.hyperparams['add_index_columns']) + else: + outputs = base_utils.combine_columns(inputs, columns_to_use, output_columns, return_result=self.hyperparams['return_result'], add_index_columns=self.hyperparams['add_index_columns']) + + return base.CallResult(outputs) + + def _can_use_column(self, inputs_metadata: metadata_base.DataMetadata, column_index: int) -> bool: + column_metadata = inputs_metadata.query((metadata_base.ALL_ELEMENTS, column_index)) + + # We produce only on columns which have not yet been parsed (are strings). + if column_metadata['structural_type'] != str: + return False + + semantic_types = column_metadata.get('semantic_types', []) + + for semantic_type in self.hyperparams['parse_semantic_types']: + if semantic_type not in semantic_types: + continue + + if semantic_type == 'https://metadata.datadrivendiscovery.org/types/CategoricalData': + # Skip parsing if a column is categorical, but also a target column. + if not self.hyperparams['parse_categorical_target_columns'] and 'https://metadata.datadrivendiscovery.org/types/Target' in semantic_types: + continue + + return True + + return False + + def _produce_columns(self, inputs: Inputs) -> typing.Tuple[typing.List[int], typing.List[Outputs]]: + # The logic of parsing values tries to mirror also the logic of detecting + # values in "SimpleProfilerPrimitive". One should keep them in sync. + + columns_to_use = self._get_columns(inputs.metadata) + + # We check against this list again, because there might be multiple matching semantic types + # (which is not really valid). + parse_semantic_types = self.hyperparams['parse_semantic_types'] + + output_columns = [] + + for column_index in columns_to_use: + column_metadata = inputs.metadata.query((metadata_base.ALL_ELEMENTS, column_index)) + semantic_types = column_metadata.get('semantic_types', []) + if column_metadata['structural_type'] == str: + if 'http://schema.org/Boolean' in parse_semantic_types and 'http://schema.org/Boolean' in semantic_types: + output_columns.append(self._parse_boolean_data(inputs, column_index)) + + elif 'https://metadata.datadrivendiscovery.org/types/CategoricalData' in parse_semantic_types and \ + 'https://metadata.datadrivendiscovery.org/types/CategoricalData' in semantic_types and \ + (self.hyperparams['parse_categorical_target_columns'] or 'https://metadata.datadrivendiscovery.org/types/Target' not in semantic_types): + output_columns.append(self._parse_categorical_data(inputs, column_index)) + + elif 'http://schema.org/Integer' in parse_semantic_types and 'http://schema.org/Integer' in semantic_types: + # For primary key we know all values have to exist so we can assume they can always be represented as integers. + if 'https://metadata.datadrivendiscovery.org/types/PrimaryKey' in semantic_types: + integer_required = True + else: + integer_required = False + + output_columns.append(self._parse_integer(inputs, column_index, integer_required)) + + elif 'http://schema.org/Float' in parse_semantic_types and 'http://schema.org/Float' in semantic_types: + output_columns.append(self._parse_float_data(inputs, column_index)) + + elif 'https://metadata.datadrivendiscovery.org/types/FloatVector' in parse_semantic_types and 'https://metadata.datadrivendiscovery.org/types/FloatVector' in semantic_types: + output_columns.append(self._parse_float_vector_data(inputs, column_index)) + + elif 'http://schema.org/DateTime' in parse_semantic_types and 'http://schema.org/DateTime' in semantic_types: + output_columns.append(self._parse_time_data(inputs, column_index, self.hyperparams['fuzzy_time_parsing'])) + + else: + assert False, column_index + + assert len(output_columns) == len(columns_to_use) + + return columns_to_use, output_columns + + def _produce_columns_metadata(self, inputs_metadata: metadata_base.DataMetadata) -> typing.Tuple[typing.List[int], typing.List[metadata_base.DataMetadata]]: + columns_to_use = self._get_columns(inputs_metadata) + + # We check against this list again, because there might be multiple matching semantic types + # (which is not really valid). + parse_semantic_types = self.hyperparams['parse_semantic_types'] + + output_columns = [] + + for column_index in columns_to_use: + column_metadata = inputs_metadata.query((metadata_base.ALL_ELEMENTS, column_index)) + semantic_types = column_metadata.get('semantic_types', []) + if column_metadata['structural_type'] == str: + if 'http://schema.org/Boolean' in parse_semantic_types and 'http://schema.org/Boolean' in semantic_types: + output_columns.append(self._parse_boolean_metadata(inputs_metadata, column_index)) + + elif 'https://metadata.datadrivendiscovery.org/types/CategoricalData' in parse_semantic_types and \ + 'https://metadata.datadrivendiscovery.org/types/CategoricalData' in semantic_types and \ + (self.hyperparams['parse_categorical_target_columns'] or 'https://metadata.datadrivendiscovery.org/types/Target' not in semantic_types): + output_columns.append(self._parse_categorical_metadata(inputs_metadata, column_index)) + + elif 'http://schema.org/Integer' in parse_semantic_types and 'http://schema.org/Integer' in semantic_types: + output_columns.append(self._parse_integer_metadata(inputs_metadata, column_index)) + + elif 'http://schema.org/Float' in parse_semantic_types and 'http://schema.org/Float' in semantic_types: + output_columns.append(self._parse_float_metadata(inputs_metadata, column_index)) + + elif 'https://metadata.datadrivendiscovery.org/types/FloatVector' in parse_semantic_types and 'https://metadata.datadrivendiscovery.org/types/FloatVector' in semantic_types: + output_columns.append(self._parse_float_vector_metadata(inputs_metadata, column_index)) + + elif 'http://schema.org/DateTime' in parse_semantic_types and 'http://schema.org/DateTime' in semantic_types: + output_columns.append(self._parse_time_metadata(inputs_metadata, column_index)) + + else: + assert False, column_index + + assert len(output_columns) == len(columns_to_use) + + return columns_to_use, output_columns + + def _get_columns(self, inputs_metadata: metadata_base.DataMetadata) -> typing.List[int]: + def can_use_column(column_index: int) -> bool: + return self._can_use_column(inputs_metadata, column_index) + + columns_to_use, columns_not_to_use = base_utils.get_columns_to_use(inputs_metadata, self.hyperparams['use_columns'], self.hyperparams['exclude_columns'], can_use_column) + + # We are OK if no columns ended up being parsed. + # "base_utils.combine_columns" will throw an error if it cannot work with this. + + if self.hyperparams['use_columns'] and columns_not_to_use: + self.logger.warning("Not all specified columns can parsed. Skipping columns: %(columns)s", { + 'columns': columns_not_to_use, + }) + + return columns_to_use + + @classmethod + def _parse_boolean_data(cls, inputs: Inputs, column_index: metadata_base.SimpleSelectorSegment) -> Outputs: + return cls._parse_categorical_data(inputs, column_index) + + @classmethod + def _parse_boolean_metadata(cls, inputs_metadata: metadata_base.DataMetadata, column_index: metadata_base.SimpleSelectorSegment) -> metadata_base.DataMetadata: + return cls._parse_categorical_metadata(inputs_metadata, column_index) + + @classmethod + def _parse_categorical_data(cls, inputs: Inputs, column_index: metadata_base.SimpleSelectorSegment) -> Outputs: + values_map: typing.Dict[str, int] = {} + for value in inputs.iloc[:, column_index]: + value = value.strip() + if value not in values_map: + value_hash = hashlib.sha256(value.encode('utf8')) + values_map[value] = int.from_bytes(value_hash.digest()[0:8], byteorder='little') ^ int.from_bytes(value_hash.digest()[8:16], byteorder='little') ^ \ + int.from_bytes(value_hash.digest()[16:24], byteorder='little') ^ int.from_bytes(value_hash.digest()[24:32], byteorder='little') + + outputs = container.DataFrame({inputs.columns[column_index]: [values_map[value.strip()] for value in inputs.iloc[:, column_index]]}, generate_metadata=False) + outputs.metadata = cls._parse_categorical_metadata(inputs.metadata, column_index) + + return outputs + + @classmethod + def _parse_categorical_metadata(cls, inputs_metadata: metadata_base.DataMetadata, column_index: metadata_base.SimpleSelectorSegment) -> metadata_base.DataMetadata: + outputs_metadata = inputs_metadata.select_columns([column_index]) + return outputs_metadata.update_column(0, {'structural_type': int}) + + @classmethod + def _str_to_int(cls, value: str) -> typing.Union[float, int]: + try: + return int(value.strip()) + except ValueError: + try: + # Maybe it is an int represented as a float. Let's try this. This can get rid of non-integer + # part of the value, but the integer was requested through a semantic type, so this is probably OK. + return int(float(value.strip())) + except ValueError: + # No luck, use NaN to represent a missing value. + return float('nan') + + @classmethod + def _parse_integer(cls, inputs: Inputs, column_index: metadata_base.SimpleSelectorSegment, + integer_required: bool) -> container.DataFrame: + outputs = container.DataFrame({inputs.columns[column_index]: [cls._str_to_int(value) for value in inputs.iloc[:, column_index]]}, generate_metadata=False) + + if outputs.dtypes.iloc[0].kind == 'f': + structural_type: type = float + elif outputs.dtypes.iloc[0].kind in ['i', 'u']: + structural_type = int + else: + assert False, outputs.dtypes.iloc[0] + + if structural_type is float and integer_required: + raise ValueError("Not all values in a column can be parsed into integers, but only integers were expected.") + + outputs.metadata = inputs.metadata.select_columns([column_index]) + outputs.metadata = outputs.metadata.update_column(0, {'structural_type': structural_type}) + + return outputs + + @classmethod + def _parse_integer_metadata(cls, inputs_metadata: metadata_base.DataMetadata, column_index: metadata_base.SimpleSelectorSegment) -> metadata_base.DataMetadata: + outputs_metadata = inputs_metadata.select_columns([column_index]) + # Without data we assume we can parse everything into integers. This might not be true and + # we might end up parsing into floats if we have to represent missing (or invalid) values. + return outputs_metadata.update_column(0, {'structural_type': int}) + + @classmethod + def _str_to_float(cls, value: str) -> float: + try: + return float(value.strip()) + except ValueError: + return float('nan') + + @classmethod + def _parse_float_data(cls, inputs: Inputs, column_index: metadata_base.SimpleSelectorSegment) -> Outputs: + outputs = container.DataFrame({inputs.columns[column_index]: [cls._str_to_float(value) for value in inputs.iloc[:, column_index]]}, generate_metadata=False) + outputs.metadata = cls._parse_float_metadata(inputs.metadata, column_index) + + return outputs + + @classmethod + def _parse_float_metadata(cls, inputs_metadata: metadata_base.DataMetadata, column_index: metadata_base.SimpleSelectorSegment) -> metadata_base.DataMetadata: + outputs_metadata = inputs_metadata.select_columns([column_index]) + return outputs_metadata.update_column(0, {'structural_type': float}) + + @classmethod + def _parse_float_vector_data(cls, inputs: Inputs, column_index: metadata_base.SimpleSelectorSegment) -> Outputs: + # We are pretty strict here because we are assuming this was generated programmatically. + outputs = container.DataFrame( + { + inputs.columns[column_index]: [ + container.ndarray([cls._str_to_float(value) for value in values.split(',')]) + for values in inputs.iloc[:, column_index] + ], + }, + generate_metadata=False, + ) + outputs.metadata = cls._parse_float_metadata(inputs.metadata, column_index) + # We have to automatically generate metadata to set ndarray dimension(s). + outputs.metadata = outputs.metadata.generate(outputs) + + return outputs + + @classmethod + def _parse_float_vector_metadata(cls, inputs_metadata: metadata_base.DataMetadata, column_index: metadata_base.SimpleSelectorSegment) -> metadata_base.DataMetadata: + outputs_metadata = inputs_metadata.select_columns([column_index]) + # We cannot know the dimension of the ndarray without data. + outputs_metadata = outputs_metadata.update_column(0, {'structural_type': container.ndarray}) + outputs_metadata = outputs_metadata.update((metadata_base.ALL_ELEMENTS, 0, metadata_base.ALL_ELEMENTS), {'structural_type': numpy.float64}) + return outputs_metadata + + @classmethod + def _parse_time_data(cls, inputs: Inputs, column_index: metadata_base.SimpleSelectorSegment, fuzzy: bool) -> Outputs: + outputs = container.DataFrame({inputs.columns[column_index]: [utils.parse_datetime_to_float(value, fuzzy=fuzzy) for value in inputs.iloc[:, column_index]]}, generate_metadata=False) + outputs.metadata = cls._parse_time_metadata(inputs.metadata, column_index) + + return outputs + + @classmethod + def _parse_time_metadata(cls, inputs_metadata: metadata_base.DataMetadata, column_index: metadata_base.SimpleSelectorSegment) -> metadata_base.DataMetadata: + outputs_metadata = inputs_metadata.select_columns([column_index]) + return outputs_metadata.update_column(0, {'structural_type': float}) diff --git a/autovideo/common/construct_predictions.py b/autovideo/common/construct_predictions.py new file mode 100644 index 0000000..ee18ee3 --- /dev/null +++ b/autovideo/common/construct_predictions.py @@ -0,0 +1,261 @@ +import os +import typing + +from d3m import container, utils as d3m_utils +from d3m.metadata import base as metadata_base, hyperparams +from d3m.primitive_interfaces import base, transformer +from d3m.contrib.primitives import compute_scores + + + +__all__ = ('ConstructPredictionsPrimitive',) + +Inputs = container.DataFrame +Outputs = container.DataFrame + + +class Hyperparams(hyperparams.Hyperparams): + use_columns = hyperparams.Set( + elements=hyperparams.Hyperparameter[int](-1), + default=(), + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="A set of column indices to force primitive to operate on. If metadata reconstruction happens, this is used for reference columns." + " If any specified column is not a primary index or a predicted target, it is skipped.", + ) + exclude_columns = hyperparams.Set( + elements=hyperparams.Hyperparameter[int](-1), + default=(), + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="A set of column indices to not operate on. If metadata reconstruction happens, this is used for reference columns. Applicable only if \"use_columns\" is not provided.", + ) + + +class ConstructPredictionsPrimitive(transformer.TransformerPrimitiveBase[Inputs, Outputs, Hyperparams]): + """ + A primitive which takes as input a DataFrame and outputs a DataFrame in Lincoln Labs predictions + format: first column is a d3mIndex column (and other primary index columns, e.g., for object detection + problem), and then predicted targets, each in its column, followed by optional confidence column(s). + + It supports both input columns annotated with semantic types (``https://metadata.datadrivendiscovery.org/types/PrimaryKey``, + ``https://metadata.datadrivendiscovery.org/types/PrimaryMultiKey``, ``https://metadata.datadrivendiscovery.org/types/PredictedTarget``, + ``https://metadata.datadrivendiscovery.org/types/Confidence``), or trying to reconstruct metadata. + This is why the primitive takes also additional input of a reference DataFrame which should + have metadata to help reconstruct missing metadata. If metadata is missing, the primitive + assumes that all ``inputs`` columns are predicted targets, without confidence column(s). + """ + + metadata = metadata_base.PrimitiveMetadata( + { + 'id': '8d38b340-f83f-4877-baaa-162f8e551736', + 'version': '0.3.0', + 'name': "Construct pipeline predictions output", + 'python_path': 'd3m.primitives.autovideo.common.construct_predictions', + 'source': { + 'name': 'TAMU DATALAB - Zaid Pervaiz Bhat', + 'contact': 'mailto:mitar.commonprimitives@tnode.com', + 'uris': [ + 'https://gitlab.com/datadrivendiscovery/common-primitives/blob/master/common_primitives/construct_predictions.py', + 'https://gitlab.com/datadrivendiscovery/common-primitives.git', + ], + }, + 'installation': [{ + 'type': metadata_base.PrimitiveInstallationType.PIP, + 'package_uri': 'git+https://gitlab.com/datadrivendiscovery/common-primitives.git@{git_commit}#egg=common_primitives'.format( + git_commit=d3m_utils.current_git_commit(os.path.dirname(__file__)), + ), + }], + 'algorithm_types': [ + metadata_base.PrimitiveAlgorithmType.DATA_CONVERSION, + ], + 'primitive_family': metadata_base.PrimitiveFamily.DATA_TRANSFORMATION, + }, + ) + + def produce(self, *, inputs: Inputs, reference: Inputs, timeout: float = None, iterations: int = None) -> base.CallResult[Outputs]: # type: ignore + index_columns = inputs.metadata.get_index_columns() + target_columns = inputs.metadata.list_columns_with_semantic_types(('https://metadata.datadrivendiscovery.org/types/PredictedTarget',)) + + # Target columns cannot be also index columns. This should not really happen, + # but it could happen with buggy primitives. + target_columns = [target_column for target_column in target_columns if target_column not in index_columns] + + if index_columns and target_columns: + outputs = self._produce_using_semantic_types(inputs, index_columns, target_columns) + else: + outputs = self._produce_reconstruct(inputs, reference, index_columns, target_columns) + + outputs = compute_scores.ComputeScoresPrimitive._encode_columns(outputs) + + # Generally we do not care about column names in DataFrame itself (but use names of columns from metadata), + # but in this case setting column names makes it easier to assure that "to_csv" call produces correct output. + # See: https://gitlab.com/datadrivendiscovery/d3m/issues/147 + column_names = [] + for column_index in range(len(outputs.columns)): + column_names.append(outputs.metadata.query_column(column_index).get('name', outputs.columns[column_index])) + outputs.columns = column_names + + return base.CallResult(outputs) + + def _filter_index_columns(self, inputs_metadata: metadata_base.DataMetadata, index_columns: typing.Sequence[int]) -> typing.Sequence[int]: + if self.hyperparams['use_columns']: + index_columns = [index_column_index for index_column_index in index_columns if index_column_index in self.hyperparams['use_columns']] + if not index_columns: + raise ValueError("No index columns listed in \"use_columns\" hyper-parameter, but index columns are required.") + + else: + index_columns = [index_column_index for index_column_index in index_columns if index_column_index not in self.hyperparams['exclude_columns']] + if not index_columns: + raise ValueError("All index columns listed in \"exclude_columns\" hyper-parameter, but index columns are required.") + + names = [] + for index_column in index_columns: + index_metadata = inputs_metadata.query_column(index_column) + # We do not care about empty strings for names either. + if index_metadata.get('name', None): + names.append(index_metadata['name']) + + if 'd3mIndex' not in names: + raise ValueError("\"d3mIndex\" index column is missing.") + + names_set = set(names) + if len(names) != len(names_set): + duplicate_names = names + for name in names_set: + # Removes just the first occurrence. + duplicate_names.remove(name) + + self.logger.warning("Duplicate names for index columns: %(duplicate_names)s", { + 'duplicate_names': list(set(duplicate_names)), + }) + + return index_columns + + def _get_columns(self, inputs_metadata: metadata_base.DataMetadata, index_columns: typing.Sequence[int], target_columns: typing.Sequence[int]) -> typing.List[int]: + assert index_columns + assert target_columns + + index_columns = self._filter_index_columns(inputs_metadata, index_columns) + + if self.hyperparams['use_columns']: + target_columns = [target_column_index for target_column_index in target_columns if target_column_index in self.hyperparams['use_columns']] + if not target_columns: + raise ValueError("No target columns listed in \"use_columns\" hyper-parameter, but target columns are required.") + + else: + target_columns = [target_column_index for target_column_index in target_columns if target_column_index not in self.hyperparams['exclude_columns']] + if not target_columns: + raise ValueError("All target columns listed in \"exclude_columns\" hyper-parameter, but target columns are required.") + + assert index_columns + assert target_columns + + return list(index_columns) + list(target_columns) + + def _get_confidence_columns(self, inputs_metadata: metadata_base.DataMetadata) -> typing.List[int]: + confidence_columns = inputs_metadata.list_columns_with_semantic_types(('https://metadata.datadrivendiscovery.org/types/Confidence',)) + + if self.hyperparams['use_columns']: + confidence_columns = [confidence_column_index for confidence_column_index in confidence_columns if confidence_column_index in self.hyperparams['use_columns']] + else: + confidence_columns = [confidence_column_index for confidence_column_index in confidence_columns if confidence_column_index not in self.hyperparams['exclude_columns']] + + return confidence_columns + + def _produce_using_semantic_types(self, inputs: Inputs, index_columns: typing.Sequence[int], + target_columns: typing.Sequence[int]) -> Outputs: + confidence_columns = self._get_confidence_columns(inputs.metadata) + + output_columns = self._get_columns(inputs.metadata, index_columns, target_columns) + confidence_columns + + # "get_index_columns" makes sure that "d3mIndex" is always listed first. + # And "select_columns" selects columns in order listed, which then + # always puts "d3mIndex" first. + outputs = inputs.select_columns(output_columns) + + if confidence_columns: + outputs.metadata = self._update_confidence_columns(outputs.metadata, confidence_columns) + + return outputs + + def _update_confidence_columns(self, inputs_metadata: metadata_base.DataMetadata, confidence_columns: typing.Sequence[int]) -> metadata_base.DataMetadata: + output_columns_length = inputs_metadata.query((metadata_base.ALL_ELEMENTS,))['dimension']['length'] + + outputs_metadata = inputs_metadata + + # All confidence columns have to be named "confidence". + for column_index in range(output_columns_length - len(confidence_columns), output_columns_length): + outputs_metadata = outputs_metadata.update((metadata_base.ALL_ELEMENTS, column_index), { + 'name': 'confidence', + }) + + return outputs_metadata + + def _produce_reconstruct(self, inputs: Inputs, reference: Inputs, index_columns: typing.Sequence[int], target_columns: typing.Sequence[int]) -> Outputs: + if not index_columns: + reference_index_columns = reference.metadata.get_index_columns() + + if not reference_index_columns: + raise ValueError("Cannot find an index column in reference data, but index column is required.") + + filtered_index_columns = self._filter_index_columns(reference.metadata, reference_index_columns) + index = reference.select_columns(filtered_index_columns) + else: + filtered_index_columns = self._filter_index_columns(inputs.metadata, index_columns) + index = inputs.select_columns(filtered_index_columns) + + if not target_columns: + if index_columns: + raise ValueError("No target columns in input data, but index column(s) present.") + + # We assume all inputs are targets. + targets = inputs + + # We make sure at least basic metadata is generated correctly, so we regenerate metadata. + targets.metadata = targets.metadata.generate(targets) + + # We set target column names from the reference. We set semantic types. + targets.metadata = self._update_targets_metadata(targets.metadata, self._get_target_names(reference.metadata)) + + else: + targets = inputs.select_columns(target_columns) + + return index.append_columns(targets) + + def multi_produce(self, *, produce_methods: typing.Sequence[str], inputs: Inputs, reference: Inputs, timeout: float = None, iterations: int = None) -> base.MultiCallResult: # type: ignore + return self._multi_produce(produce_methods=produce_methods, timeout=timeout, iterations=iterations, inputs=inputs, reference=reference) + + def fit_multi_produce(self, *, produce_methods: typing.Sequence[str], inputs: Inputs, reference: Inputs, timeout: float = None, iterations: int = None) -> base.MultiCallResult: # type: ignore + return self._fit_multi_produce(produce_methods=produce_methods, timeout=timeout, iterations=iterations, inputs=inputs, reference=reference) + + def _get_target_names(self, metadata: metadata_base.DataMetadata) -> typing.List[typing.Union[str, None]]: + target_names = [] + + for column_index in metadata.list_columns_with_semantic_types(('https://metadata.datadrivendiscovery.org/types/TrueTarget',)): + column_metadata = metadata.query((metadata_base.ALL_ELEMENTS, column_index)) + + target_names.append(column_metadata.get('name', None)) + + return target_names + + def _update_targets_metadata(self, metadata: metadata_base.DataMetadata, target_names: typing.Sequence[typing.Union[str, None]]) -> metadata_base.DataMetadata: + targets_length = metadata.query((metadata_base.ALL_ELEMENTS,))['dimension']['length'] + + if targets_length != len(target_names): + raise ValueError("Not an expected number of target columns to apply names for. Expected {target_names}, provided {targets_length}.".format( + target_names=len(target_names), + targets_length=targets_length, + )) + + for column_index, target_name in enumerate(target_names): + metadata = metadata.add_semantic_type((metadata_base.ALL_ELEMENTS, column_index), 'https://metadata.datadrivendiscovery.org/types/Target') + metadata = metadata.add_semantic_type((metadata_base.ALL_ELEMENTS, column_index), 'https://metadata.datadrivendiscovery.org/types/PredictedTarget') + + # We do not have it, let's skip it and hope for the best. + if target_name is None: + continue + + metadata = metadata.update_column(column_index, { + 'name': target_name, + }) + + return metadata diff --git a/autovideo/common/dataset_to_dataframe.py b/autovideo/common/dataset_to_dataframe.py new file mode 100644 index 0000000..44f7861 --- /dev/null +++ b/autovideo/common/dataset_to_dataframe.py @@ -0,0 +1,86 @@ +import os +import typing + +from d3m import container, utils as d3m_utils +from d3m.base import utils as base_utils +from d3m.metadata import base as metadata_base, hyperparams +from d3m.primitive_interfaces import base, transformer + + + +__all__ = ('DatasetToDataFramePrimitive',) + +Inputs = container.Dataset +Outputs = container.DataFrame + + +class Hyperparams(hyperparams.Hyperparams): + dataframe_resource = hyperparams.Hyperparameter[typing.Union[str, None]]( + default=None, + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Resource ID of a DataFrame to extract if there are multiple tabular resources inside a Dataset and none is a dataset entry point.", + ) + + +class DatasetToDataFramePrimitive(transformer.TransformerPrimitiveBase[Inputs, Outputs, Hyperparams]): + """ + A primitive which extracts a DataFrame out of a Dataset. + """ + + metadata = metadata_base.PrimitiveMetadata( + { + 'id': '4b42ce1e-9b98-4a25-b68e-fad13311eb65', + 'version': '0.3.0', + 'name': "Extract a DataFrame from a Dataset", + 'python_path': 'd3m.primitives.autovideo.common.dataset_to_dataframe', + 'source': { + 'name': 'TAMU DATALAB - Zaid Pervaiz Bhat', + 'contact': 'mailto:mitar.commonprimitives@tnode.com', + 'uris': [ + 'https://gitlab.com/datadrivendiscovery/common-primitives/blob/master/common_primitives/dataset_to_dataframe.py', + 'https://gitlab.com/datadrivendiscovery/common-primitives.git', + ], + }, + 'installation': [{ + 'type': metadata_base.PrimitiveInstallationType.PIP, + 'package_uri': 'git+https://gitlab.com/datadrivendiscovery/common-primitives.git@{git_commit}#egg=common_primitives'.format( + git_commit=d3m_utils.current_git_commit(os.path.dirname(__file__)), + ), + }], + 'algorithm_types': [ + metadata_base.PrimitiveAlgorithmType.DATA_CONVERSION, + ], + 'primitive_family': metadata_base.PrimitiveFamily.DATA_TRANSFORMATION, + }, + ) + + def produce(self, *, inputs: Inputs, timeout: float = None, iterations: int = None) -> base.CallResult[Outputs]: + dataframe_resource_id, dataframe = base_utils.get_tabular_resource(inputs, self.hyperparams['dataframe_resource']) #Converts to dataframe + dataframe.metadata = self._update_metadata(inputs.metadata, dataframe_resource_id) + + assert isinstance(dataframe, container.DataFrame), type(dataframe) + + return base.CallResult(dataframe) + + def _update_metadata(self, metadata: metadata_base.DataMetadata, resource_id: metadata_base.SelectorSegment) -> metadata_base.DataMetadata: + resource_metadata = dict(metadata.query((resource_id,))) + + if 'structural_type' not in resource_metadata or not issubclass(resource_metadata['structural_type'], container.DataFrame): + raise TypeError("The Dataset resource is not a DataFrame, but \"{type}\".".format( + type=resource_metadata.get('structural_type', None), + )) + + resource_metadata.update( + { + 'schema': metadata_base.CONTAINER_SCHEMA_VERSION, + }, + ) + + new_metadata = metadata_base.DataMetadata(resource_metadata) + + new_metadata = metadata.copy_to(new_metadata, (resource_id,)) + + # Resource is not anymore an entry point. + new_metadata = new_metadata.remove_semantic_type((), 'https://metadata.datadrivendiscovery.org/types/DatasetEntryPoint') + + return new_metadata diff --git a/autovideo/common/dataset_utils.py b/autovideo/common/dataset_utils.py new file mode 100644 index 0000000..3dd3cdc --- /dev/null +++ b/autovideo/common/dataset_utils.py @@ -0,0 +1,52 @@ +import collections +import typing + +from d3m import container + + +def sample_rows( + dataset: container.Dataset, main_resource_id: str, main_resource_indices_to_keep: typing.Set[int], + relations_graph: typing.Dict[str, typing.List[typing.Tuple[str, bool, int, int, typing.Dict]]], *, + delete_recursive: bool = False, +) -> container.Dataset: + # We store rows as sets, but later on we sort them when we select rows. + row_indices_to_keep_sets: typing.Dict[str, typing.Set[int]] = collections.defaultdict(set) + row_indices_to_keep_sets[main_resource_id] = main_resource_indices_to_keep + + # If "delete_recursive" is set to "False", we do not populate "row_indices_to_keep_sets" + # with other resources, making "select_rows" simply keep them. + if delete_recursive: + # We sort to be deterministic. + for main_resource_row_index in sorted(row_indices_to_keep_sets[main_resource_id]): + queue = [] + queue.append((main_resource_id, [main_resource_row_index])) + while queue: + current_resource_id, current_row_indices = queue.pop(0) + current_resource = dataset[current_resource_id] + + for edge_resource_id, edge_direction, edge_from_index, edge_to_index, custom_state in relations_graph[current_resource_id]: + # All rows from the main resource we want are already there. + # TODO: What to do if we get a reference to the row in the main resource which is not part of this sample? + # This means that probably the sample is invalid. We should not be generating such samples which do not + # preserve reference loops and their consistency. Otherwise it is not really possible to denormalize + # such Dataset properly: a reference is referencing a row in the main resource which does not exist. + if edge_resource_id == main_resource_id: + continue + + edge_resource = dataset[edge_resource_id] + + to_column_values = edge_resource.iloc[:, edge_to_index] + for from_column_value in current_resource.iloc[current_row_indices, edge_from_index]: + # We assume here that "index" corresponds to the default index with row indices. + rows_with_value = edge_resource.index[to_column_values == from_column_value] + # We sort to be deterministic. + new_rows_list = sorted(set(rows_with_value) - row_indices_to_keep_sets[edge_resource_id]) + row_indices_to_keep_sets[edge_resource_id].update(new_rows_list) + queue.append((edge_resource_id, new_rows_list)) + + # We sort indices to get deterministic outputs from sets (which do not have deterministic order). + # We also do not want to change the row order but keep the original row order. + # Sorting by row indices values assure that. + row_indices_to_keep = {resource_id: sorted(indices) for resource_id, indices in row_indices_to_keep_sets.items()} + + return dataset.select_rows(row_indices_to_keep) diff --git a/autovideo/common/denormalize.py b/autovideo/common/denormalize.py new file mode 100644 index 0000000..8ee0d27 --- /dev/null +++ b/autovideo/common/denormalize.py @@ -0,0 +1,555 @@ +import os +import typing +import itertools + +import numpy # type: ignore +import pandas # type: ignore + +from d3m import container, exceptions, utils as d3m_utils +from d3m.base import utils as base_utils +from d3m.metadata import base as metadata_base, hyperparams +from d3m.primitive_interfaces import base, transformer + + + +__all__ = ('DenormalizePrimitive',) + +Inputs = container.Dataset +Outputs = container.Dataset + + +class Hyperparams(hyperparams.Hyperparams): + starting_resource = hyperparams.Hyperparameter[typing.Union[str, None]]( + default=None, + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="From which resource to start denormalizing. If \"None\" then it starts from the dataset entry point.", + ) + recursive = hyperparams.UniformBool( + default=True, + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Denormalize recursively?", + ) + many_to_many = hyperparams.UniformBool( + default=False, + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Denormalize also many-to-many relations?", + ) + discard_not_joined_tabular_resources = hyperparams.UniformBool( + default=False, + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Should tabular resources which were not joined be discarded?", + ) + + +# TODO: Implement support for M2M relations. +# TODO: Consider the case where there are loops in foreign keys. +# TODO: Add all column names together to "other names" metadata for column. +# TODO: Consider denormalizing deep-first instead of current iterative approach. +# It seems it might be better because when one table is referencing the second one twice, +# which might reference other tables further, then currently we first join the second table +# and then have to repeat joining other tables twice. But we could first join other tables +# once to the second table, and then just do the join with already joined second table. +# Not sure how to behave in "recursive == False" case then. +# TODO: Add a test where main table has a foreign key twice to same table (for example, person 1 and person 2 to table of persons). +class DenormalizePrimitive(transformer.TransformerPrimitiveBase[Inputs, Outputs, Hyperparams]): + """ + A primitive which converts a Dataset with multiple tabular resources into a Dataset with only one tabular resource, + based on known relations between tabular resources. Any resource which can be joined is joined (thus the resource + itself is removed), and other resources are by default discarded (controlled by ``discard_resources`` hyper-parameter). + + If hyper-parameter ``recursive`` is set to ``True``, the primitive will join tables recursively. For example, + if table 1 (main table) has a foreign key that points to table 2, and table 2 has a foreign key that points to table 3, + then after table 2 is jointed into table 1, table 1 will have a foreign key that points to table 3. So now the + primitive continues to join table 3 into the main table. + """ + + __author__ = 'Mingjie Sun ' + metadata = metadata_base.PrimitiveMetadata( + { + 'id': 'f31f8c1f-d1c5-43e5-a4b2-2ae4a761ef2e', + 'version': '0.2.0', + 'name': "Denormalize datasets", + 'python_path': 'd3m.primitives.autovideo.common.denormalize', + 'source': { + 'name':'TAMU DATALAB - Zaid Pervaiz Bhat', + 'contact': 'mailto:sunmj15@gmail.com', + 'uris': [ + 'https://gitlab.com/datadrivendiscovery/common-primitives/blob/master/common_primitives/denormalize.py', + 'https://gitlab.com/datadrivendiscovery/common-primitives.git', + ], + }, + 'installation': [{ + 'type': metadata_base.PrimitiveInstallationType.PIP, + 'package_uri': 'git+https://gitlab.com/datadrivendiscovery/common-primitives.git@{git_commit}#egg=common_primitives'.format( + git_commit=d3m_utils.current_git_commit(os.path.dirname(__file__)), + ), + }], + 'algorithm_types': [ + metadata_base.PrimitiveAlgorithmType.DATA_DENORMALIZATION, + ], + 'primitive_family': metadata_base.PrimitiveFamily.DATA_TRANSFORMATION, + }, + ) + + def __init__(self, *, hyperparams: Hyperparams) -> None: + super().__init__(hyperparams=hyperparams) + + def produce(self, *, inputs: Inputs, timeout: float = None, iterations: int = None) -> base.CallResult[Outputs]: + # If only one tabular resource is in the dataset, we do not have anything to do. + tabular_resource_ids = [dataset_resource_id for dataset_resource_id, dataset_resource in inputs.items() if isinstance(dataset_resource, container.DataFrame)] + if len(tabular_resource_ids) == 1: + return base.CallResult(inputs) + # We could set "pick_one" to "False" because we already checked for that, but we leave it + # as "True" because then error messages are more meaningful for this case. + main_resource_id, main_resource = base_utils.get_tabular_resource(inputs, self.hyperparams['starting_resource']) + + # Graph is the adjacency representation for the relations graph. + graph = inputs.get_relations_graph() + + resources = dict(inputs) + metadata = inputs.metadata + all_resources_joined = set() + + while self._has_forward_edges(graph, main_resource_id): + # "resources" and "graph" are modified in-place. + metadata, resources_joined = self._denormalize(resources, metadata, main_resource_id, graph) + + all_resources_joined.update(resources_joined) + + if not self.hyperparams['recursive']: + break + + # Do we discard all other tabular resources (including joined ones)? + if self.hyperparams['discard_not_joined_tabular_resources']: + resources_to_remove = [] + for resource_id, resource in resources.items(): + if resource_id == main_resource_id: + continue + if not isinstance(resource, container.DataFrame): + continue + resources_to_remove.append(resource_id) + + # Discard only joined tabular resources and which no other resource depends on. + else: + # We deal only with tabular resources here. + dependent_upon_resources = self._get_dependent_upon_resources(graph) + resources_to_remove = [resource_id for resource_id in sorted(all_resources_joined - dependent_upon_resources) if resource_id != main_resource_id] + + for resource_id in resources_to_remove: + assert resource_id != main_resource_id + + del resources[resource_id] + metadata = metadata.remove((resource_id,), recursive=True) + + metadata = metadata.update((), { + 'dimension': { + 'length': len(resources), + }, + }) + + return base.CallResult(container.Dataset(resources, metadata)) + + def _has_forward_edges(self, graph: typing.Dict[str, typing.List[typing.Tuple[str, bool, int, int, typing.Dict]]], resource_id: str) -> bool: + # We check first to not create a list in "graph" when accessing it. + if resource_id not in graph: + return False + + for edge_resource_id, edge_direction, edge_from_index, edge_to_index, custom_state in graph[resource_id]: + if edge_direction: + return True + + return False + + def _has_edges_to_process(self, graph: typing.Dict[str, typing.List[typing.Tuple[str, bool, int, int, typing.Dict]]], resource_id: str) -> bool: + # We check first to not create a list in "graph" when accessing it. + if resource_id not in graph: + return False + + for edge_resource_id, edge_direction, edge_from_index, edge_to_index, custom_state in graph[resource_id]: + if custom_state.get('process', False): + return True + + return False + + def _denormalize(self, resources: typing.Dict, metadata: metadata_base.DataMetadata, main_resource_id: str, + graph: typing.Dict[str, typing.List[typing.Tuple[str, bool, int, int, typing.Dict]]]) -> typing.Tuple[metadata_base.DataMetadata, typing.Set[str]]: + """ + Finds all tables which are pointed to by the main resource and join them into the main table. + + ``resources`` and ``graph`` are modified in-place. + """ + + resources_joined: typing.Set[str] = set() + main_resource = resources[main_resource_id] + + # Should not really happen. + if main_resource_id not in graph: + return metadata, resources_joined + + # We mark all current edges to be processed. We might be adding more edges to the list, + # but we want to do for this call only those which existed at the beginning. + for edge_resource_id, edge_direction, edge_from_index, edge_to_index, custom_state in graph[main_resource_id]: + custom_state['process'] = True + + while self._has_edges_to_process(graph, main_resource_id): + edge_resource_id, edge_direction, edge_from_index, edge_to_index, custom_state = graph[main_resource_id][0] + + if not custom_state.get('process', False): + continue + del custom_state['process'] + + if not edge_direction: + # For now we just remove this relation. + # TODO: Support M2M relations. + + # We remove the relation we would have joined, backward. + self._remove_graph_edge(graph, main_resource_id, edge_resource_id, False, edge_from_index, edge_to_index) + + # We remove the relation we would have joined, forward. + self._remove_graph_edge(graph, edge_resource_id, main_resource_id, True, edge_to_index, edge_from_index) + + continue + + if main_resource_id == edge_resource_id: + # TODO: Implement. + raise NotImplementedError("Support for loops is not implemented yet.") + + # Calling "_join" updates column indices in "graph" and "metadata" + # and also removes the current joined edge from "graph" + main_resource, metadata = self._join( + main_resource_id, main_resource, edge_from_index, + edge_resource_id, resources[edge_resource_id], edge_to_index, + metadata, graph, + ) + + resources_joined.add(edge_resource_id) + + resources[main_resource_id] = main_resource + + return metadata, resources_joined + + def _row_of_missing_values(self, resource: container.DataFrame, metadata: metadata_base.DataMetadata, resource_id: str) -> typing.List[typing.Any]: + row = [] + for column_index, dtype in enumerate(resource.dtypes): + if dtype.kind in ['b', 'i', 'u', 'f', 'c']: + row.append(numpy.nan) + elif dtype.kind == 'O' and issubclass(metadata.query_column_field(column_index, 'structural_type', at=(resource_id,)), str): + row.append('') + else: + row.append(None) + + return row + + def _join(self, main_resource_id: str, main_resource: container.DataFrame, main_column_index: int, foreign_resource_id: str, + foreign_resource: container.DataFrame, foreign_column_index: int, metadata: metadata_base.DataMetadata, + graph: typing.Dict[str, typing.List[typing.Tuple[str, bool, int, int, typing.Dict]]]) -> typing.Tuple[container.DataFrame, metadata_base.DataMetadata]: + if main_resource_id == foreign_resource_id: + # TODO: Implement. + raise NotImplementedError("Support for loops is not implemented yet.") + + # We use this information later on. + one_to_one_relation = foreign_resource.iloc[:, foreign_column_index].sort_values().equals(main_resource.iloc[:, main_column_index].sort_values()) + + foreign_indexer = pandas.Index(foreign_resource.iloc[:, foreign_column_index]).get_indexer(main_resource.iloc[:, main_column_index]) + # "get_indexer" sets all unresolved values to -1. + unresolved_rows = foreign_indexer == -1 + + # We store dtypes so that we can later on compare. + foreign_resource_dtypes = foreign_resource.dtypes + + # -1 is converted into the last row, but we set it to row of missing values if it exists. + resolved_foreign_resource = foreign_resource.take(foreign_indexer).reset_index(drop=True) + if unresolved_rows.any(): + # Set all unresolved rows to a row of missing values. + resolved_foreign_resource.iloc[unresolved_rows, :] = self._row_of_missing_values(foreign_resource, metadata, foreign_resource_id) + + # And store final dtypes so that we can later on compare. + resolved_foreign_resource_dtypes = resolved_foreign_resource.dtypes + + # This makes a copy so that we can modify metadata in-place. + metadata = metadata.update( + (metadata_base.ALL_ELEMENTS,), + {}, + ) + + # TODO: Move this to metadata API. + # We reorder metadata for rows. + for element_metadata_entry in [ + metadata._current_metadata.all_elements, + metadata._current_metadata.elements[foreign_resource_id], + ]: + if element_metadata_entry is None: + continue + + elements = element_metadata_entry.elements + new_elements_evolver = d3m_utils.EMPTY_PMAP.evolver() + for i, row_index in enumerate(foreign_indexer): + if row_index == -1: + continue + + if row_index in elements: + new_elements_evolver.set(i, elements[row_index]) + element_metadata_entry.elements = new_elements_evolver.persistent() + element_metadata_entry.is_elements_empty = not element_metadata_entry.elements + element_metadata_entry.update_is_empty() + + assert resolved_foreign_resource.shape[1] > 0 + + main_resource = pandas.concat([ + main_resource.iloc[:, 0:main_column_index], + resolved_foreign_resource, + main_resource.iloc[:, main_column_index + 1:], + ], axis=1) + + old_semantic_types = metadata.query_column(main_column_index, at=(main_resource_id,)).get('semantic_types', []) + + # First we remove metadata for the existing column. + # This makes a copy so that we can modify metadata in-place. + metadata = metadata.remove_column(main_column_index, at=(main_resource_id,), recursive=True) + + # TODO: Move this to metadata API. + # Move columns and make space for foreign metadata to be inserted. + # We iterate over a list so that we can change dict while iterating. + for element_metadata_entry in itertools.chain( + [metadata._current_metadata.all_elements.all_elements if metadata._current_metadata.all_elements is not None else None], + metadata._current_metadata.all_elements.elements.values() if metadata._current_metadata.all_elements is not None else iter([None]), + [metadata._current_metadata.elements[main_resource_id].all_elements], + metadata._current_metadata.elements[main_resource_id].elements.values(), + ): + if element_metadata_entry is None: + continue + + new_elements_evolver = element_metadata_entry.elements.evolver() + for element_index in element_metadata_entry.elements.keys(reverse=True): + # We removed metadata for "main_column_index". + assert element_index != main_column_index + + element_index = typing.cast(int, element_index) + + if main_column_index < element_index: + metadata_dict = new_elements_evolver[element_index] + new_elements_evolver.remove(element_index) + new_elements_evolver.set(element_index + resolved_foreign_resource.shape[1] - 1, metadata_dict) + element_metadata_entry.elements = new_elements_evolver.persistent() + element_metadata_entry.is_elements_empty = not element_metadata_entry.elements + element_metadata_entry.update_is_empty() + + # And copy over metadata for new (replaced) columns in place of the existing column. + for column_index in range(resolved_foreign_resource.shape[1]): + # To go over "ALL_ELEMENTS" and all rows. + for element in metadata.get_elements((foreign_resource_id,)): + metadata = metadata.copy_to( + metadata, + [foreign_resource_id, element, metadata_base.ALL_ELEMENTS], + [main_resource_id, element, main_column_index + column_index], + ignore_all_elements=True, + ) + metadata = metadata.copy_to( + metadata, + [foreign_resource_id, element, column_index], + [main_resource_id, element, main_column_index + column_index], + ignore_all_elements=True, + ) + + # Update metadata for new (replaced) columns. + for column_index in range(main_column_index, main_column_index + resolved_foreign_resource.shape[1]): + # We copy semantic types describing the role of the column from the original column to all new (replaced) columns. + # TODO: Do not hard-code this list here but maybe extract it from "definitions.json"? + for semantic_type in [ + 'https://metadata.datadrivendiscovery.org/types/Attribute', + 'https://metadata.datadrivendiscovery.org/types/Boundary', + 'https://metadata.datadrivendiscovery.org/types/BoundingPolygon', + 'https://metadata.datadrivendiscovery.org/types/Interval', + 'https://metadata.datadrivendiscovery.org/types/IntervalEnd', + 'https://metadata.datadrivendiscovery.org/types/IntervalStart', + 'https://metadata.datadrivendiscovery.org/types/InstanceWeight', + 'https://metadata.datadrivendiscovery.org/types/PrivilegedData', + 'https://metadata.datadrivendiscovery.org/types/RedactedPrivilegedData', + 'https://metadata.datadrivendiscovery.org/types/RedactedTarget', + 'https://metadata.datadrivendiscovery.org/types/SuggestedPrivilegedData', + 'https://metadata.datadrivendiscovery.org/types/SuggestedTarget', + 'https://metadata.datadrivendiscovery.org/types/Target', + 'https://metadata.datadrivendiscovery.org/types/PredictedTarget', + 'https://metadata.datadrivendiscovery.org/types/TrueTarget', + 'https://metadata.datadrivendiscovery.org/types/Score', + 'https://metadata.datadrivendiscovery.org/types/Confidence', + 'https://metadata.datadrivendiscovery.org/types/Time', + 'https://metadata.datadrivendiscovery.org/types/Location', + ]: + if semantic_type in old_semantic_types: + metadata = metadata.add_semantic_type((main_resource_id, metadata_base.ALL_ELEMENTS, column_index), semantic_type) + + is_column_unique = main_resource.iloc[:, column_index].is_unique + column_semantic_types = metadata.query_column(column_index, at=(main_resource_id,)).get('semantic_types', []) + was_column_unique = 'https://metadata.datadrivendiscovery.org/types/PrimaryKey' in column_semantic_types \ + or 'https://metadata.datadrivendiscovery.org/types/UniqueKey' in column_semantic_types + + # Foreign keys can reference same foreign row multiple times, so values in this column might not be even + # unique anymore, nor they are a primary key at all. So we remove the semantic type marking a column as such. + # We re-set semantic type for any real primary key later on. + metadata = metadata.remove_semantic_type((main_resource_id, metadata_base.ALL_ELEMENTS, column_index), 'https://metadata.datadrivendiscovery.org/types/PrimaryKey') + metadata = metadata.remove_semantic_type((main_resource_id, metadata_base.ALL_ELEMENTS, column_index), 'https://metadata.datadrivendiscovery.org/types/PrimaryMultiKey') + metadata = metadata.remove_semantic_type((main_resource_id, metadata_base.ALL_ELEMENTS, column_index), 'https://metadata.datadrivendiscovery.org/types/UniqueKey') + + # We re-set semantic type for column which was and is still unique. + if was_column_unique and is_column_unique: + metadata = metadata.add_semantic_type((main_resource_id, metadata_base.ALL_ELEMENTS, column_index), 'https://metadata.datadrivendiscovery.org/types/UniqueKey') + + old_dtype = foreign_resource_dtypes.iloc[column_index - main_column_index] + new_dtype = resolved_foreign_resource_dtypes.iloc[column_index - main_column_index] + if old_dtype is not new_dtype: + # Not a nice way to convert a dtype to Python type, but it works. + old_type = type(numpy.zeros(1, old_dtype).tolist()[0]) + new_type = type(numpy.zeros(1, new_dtype).tolist()[0]) + if old_type is not new_type: + # Type changed, we have to update metadata about the structural type. + metadata = metadata.update((main_resource_id, metadata_base.ALL_ELEMENTS, column_index), { + 'structural_type': new_type, + }) + + # If the original column was a primary key, we should re-set it back. + if 'https://metadata.datadrivendiscovery.org/types/PrimaryKey' in old_semantic_types and (one_to_one_relation or not unresolved_rows.any()): + if main_resource.iloc[:, main_column_index].is_unique: + metadata = metadata.add_semantic_type((main_resource_id, metadata_base.ALL_ELEMENTS, main_column_index), 'https://metadata.datadrivendiscovery.org/types/PrimaryKey') + # Removing "UniqueKey" if it was set before, "PrimaryKey" surpasses it. + metadata = metadata.remove_semantic_type((main_resource_id, metadata_base.ALL_ELEMENTS, main_column_index), 'https://metadata.datadrivendiscovery.org/types/UniqueKey') + else: + metadata = metadata.add_semantic_type((main_resource_id, metadata_base.ALL_ELEMENTS, main_column_index), 'https://metadata.datadrivendiscovery.org/types/PrimaryMultiKey') + elif 'https://metadata.datadrivendiscovery.org/types/PrimaryMultiKey' in old_semantic_types and (one_to_one_relation or not unresolved_rows.any()): + metadata = metadata.add_semantic_type((main_resource_id, metadata_base.ALL_ELEMENTS, main_column_index), 'https://metadata.datadrivendiscovery.org/types/PrimaryMultiKey') + + # TODO: Update boundary columns and "confidence for" references. + # This is not currently needed because all file collections are just one column so they do not + # move the column indices. But as a general case we should be updating all standard column references. + + # Update columns number in the main resource. + metadata = metadata.update((main_resource_id, metadata_base.ALL_ELEMENTS), { + 'dimension': { + 'length': main_resource.shape[1], + }, + }) + + # We remove the relation we just joined, forward. + self._remove_graph_edge(graph, main_resource_id, foreign_resource_id, True, main_column_index, foreign_column_index) + + # We remove the relation we just joined, backward. + self._remove_graph_edge(graph, foreign_resource_id, main_resource_id, False, foreign_column_index, main_column_index) + + # We have to update column indices if they have changed because we inserted new columns. + for resource_id, edges in graph.items(): + if resource_id == main_resource_id: + for i, (edge_resource_id, edge_direction, edge_from_index, edge_to_index, custom_state) in enumerate(edges): + if edge_direction and main_column_index < edge_from_index: + # We replaced one column with "resolved_foreign_resource.shape[1]" columns, so there is + # "resolved_foreign_resource.shape[1] - 1" new columns to shift indices for. + edges[i] = (edge_resource_id, edge_direction, edge_from_index + resolved_foreign_resource.shape[1] - 1, edge_to_index, custom_state) + else: + for i, (edge_resource_id, edge_direction, edge_from_index, edge_to_index, custom_state) in enumerate(edges): + if edge_resource_id == main_resource_id and not edge_direction and main_column_index < edge_to_index: + # We replaced one column with "resolved_foreign_resource.shape[1]" columns, so there is + # "resolved_foreign_resource.shape[1] - 1" new columns to shift indices for. + edges[i] = (edge_resource_id, edge_direction, edge_from_index, edge_to_index + resolved_foreign_resource.shape[1] - 1, custom_state) + + # If foreign resource has any additional relations, we copy them to new columns in the main resource. + if foreign_resource_id in graph: + # We iterate over a list so that we can change graph while iterating. + for edge_resource_id, edge_direction, edge_from_index, edge_to_index, custom_state in list(graph[foreign_resource_id]): + if edge_resource_id in [main_resource_id, foreign_resource_id]: + # TODO: Implement. + raise NotImplementedError("Support for loops is not implemented yet.") + + if edge_direction: + graph[main_resource_id].append((edge_resource_id, True, main_column_index + edge_from_index, edge_to_index, {})) + graph[edge_resource_id].append((main_resource_id, False, edge_to_index, main_column_index + edge_from_index, {})) + else: + # TODO: What should we do about backward relations? + # For now we just ignore backward relations because we do not support M2M relations. + # For the foreign resource we just joined, we could change all relations to instead point + # to the main resource. This might be tricky though if we have a situation where main table + # includes table 1 twice, and table 1 has a relation to table 2. If we after joining table 1 + # once rewrite all backward relations from table 2 to table 1 to point to main table now, + # when we get to join the table 1 the second time we might have issues. This is why it might + # better to start joining deep-first. See another TODO. + # TODO: We might have to also update foreign key metadata in this case. + # We might want to update metadata so that if table 1 is joined to the main table, and there is + # also table 2 which has a foreign key that points to table 1, then the foreign key in table 2 + # should point to the main table after joining. But what if main table has a foreign key to + # table 1 twice? How do we then update metadata in table 2 to point twice to table 1? + # Metadata does not support that. + + # A special case for now. If relation is one-to-one, then we can move backwards relations to the + # main resource without complications mentioned in TODOs above. Maybe some additional columns might + # be joined through M2M relations in this case, once that is supported, but generally this should not + # be a problem. It might add some duplicated columns at that point. This special case is useful + # when "learningData" with only targets is pointing to some other table with real attributes. + if one_to_one_relation: + self._remove_graph_edge(graph, edge_resource_id, foreign_resource_id, True, edge_to_index, edge_from_index) + self._remove_graph_edge(graph, foreign_resource_id, edge_resource_id, False, edge_from_index, edge_to_index) + + graph[main_resource_id].append((edge_resource_id, False, main_column_index + edge_from_index, edge_to_index, custom_state)) + graph[edge_resource_id].append((main_resource_id, True, edge_to_index, main_column_index + edge_from_index, custom_state)) + + # We override metadata for foreign key to make it point to the main resource (and not to foreign resource anymore). + metadata = metadata.update((edge_resource_id, metadata_base.ALL_ELEMENTS, edge_to_index), { + 'foreign_key': { + 'type': 'COLUMN', + 'resource_id': main_resource_id, + 'column_index': main_column_index + edge_from_index, + 'column_name': metadata_base.NO_VALUE, + }, + }) + + return main_resource, metadata + + def _get_dependent_upon_resources(self, graph: typing.Dict[str, typing.List[typing.Tuple[str, bool, int, int, typing.Dict]]]) -> typing.Set[str]: + """ + Returns a set of resources which have other resources depend on them. + """ + + dependent_upon_resources = set() + + for resource_id, edges in graph.items(): + for edge_resource_id, edge_direction, edge_from_index, edge_to_index, custom_state in edges: + if edge_direction: + dependent_upon_resources.add(edge_resource_id) + + return dependent_upon_resources + + def _remove_graph_edge(self, graph: typing.Dict[str, typing.List[typing.Tuple[str, bool, int, int, typing.Dict]]], + resource_id: str, edge_resource_id: str, edge_direction: bool, edge_from_index: int, edge_to_index: int) -> None: + assert resource_id in graph + + for i, edge in enumerate(graph[resource_id]): + if edge[0:4] == (edge_resource_id, edge_direction, edge_from_index, edge_to_index): + del graph[resource_id][i] + break + + if not graph[resource_id]: + del graph[resource_id] + + +if __name__ == '__main__': + import logging + import pprint + import sys + + logging.basicConfig() + + for dataset_file_path in sys.argv[1:]: + try: + dataset = container.Dataset.load('file://{dataset_doc_path}'.format(dataset_doc_path=os.path.abspath(dataset_file_path))) + except Exception as error: + raise Exception("Unable to load dataset: {dataset_doc_path}".format(dataset_doc_path=dataset_file_path)) from error + + primitive = DenormalizePrimitive(hyperparams=Hyperparams.defaults().replace({ + 'recursive': True, + 'discard_not_joined_tabular_resources': False, + })) + + try: + denormalized_dataset = primitive.produce(inputs=dataset).value + + pprint.pprint(denormalized_dataset) + denormalized_dataset.metadata.pretty_print() + except Exception as error: + raise Exception("Unable to denormalize dataset: {dataset_doc_path}".format(dataset_doc_path=dataset_file_path)) from error diff --git a/autovideo/common/extract_columns_semantic_types.py b/autovideo/common/extract_columns_semantic_types.py new file mode 100644 index 0000000..19dfbf4 --- /dev/null +++ b/autovideo/common/extract_columns_semantic_types.py @@ -0,0 +1,141 @@ +import os +import typing + +from d3m import container, exceptions, utils as d3m_utils +from d3m.base import utils as base_utils +from d3m.metadata import base as metadata_base, hyperparams +from d3m.primitive_interfaces import base, transformer + + + +__all__ = ('ExtractColumnsBySemanticTypesPrimitive',) + +Inputs = container.DataFrame +Outputs = container.DataFrame + + +class Hyperparams(hyperparams.Hyperparams): + semantic_types = hyperparams.Set( + elements=hyperparams.Hyperparameter[str](''), + default=('https://metadata.datadrivendiscovery.org/types/Attribute',), + min_size=1, + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Semantic types to use to extract columns. If any of them matches, by default.", + ) + match_logic = hyperparams.Enumeration( + values=['all', 'any', 'equal'], + default='any', + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Should a column have all of semantic types in \"semantic_types\" to be extracted, or any of them?", + ) + negate = hyperparams.UniformBool( + default=False, + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Should columns which do not match semantic types in \"semantic_types\" be extracted?", + ) + use_columns = hyperparams.Set( + elements=hyperparams.Hyperparameter[int](-1), + default=(), + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="A set of column indices to force primitive to operate on. If any specified column does not match any semantic type, it is skipped.", + ) + exclude_columns = hyperparams.Set( + elements=hyperparams.Hyperparameter[int](-1), + default=(), + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="A set of column indices to not operate on. Applicable only if \"use_columns\" is not provided.", + ) + add_index_columns = hyperparams.UniformBool( + default=False, + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="Also include primary index columns if input data has them.", + ) + + +class ExtractColumnsBySemanticTypesPrimitive(transformer.TransformerPrimitiveBase[Inputs, Outputs, Hyperparams]): + """ + A primitive which extracts columns from input data based on semantic types provided. + Columns which match any of the listed semantic types are extracted. + + If you want to extract only attributes, you can use ``https://metadata.datadrivendiscovery.org/types/Attribute`` + semantic type (also default). + + For real targets (not suggested targets) use ``https://metadata.datadrivendiscovery.org/types/Target``. + For this to work, columns have to be are marked as targets by the TA2 in a dataset before passing the dataset + through a pipeline. Or something else has to mark them at some point in a pipeline. + + It uses ``use_columns`` and ``exclude_columns`` to control which columns it considers. + """ + + metadata = metadata_base.PrimitiveMetadata( + { + 'id': '4503a4c6-42f7-45a1-a1d4-ed69699cf5e1', + 'version': '0.4.0', + 'name': "Extracts columns by semantic type", + 'python_path': 'd3m.primitives.autovideo.common.extract_columns_by_semantic_types', + 'source': { + 'name': 'TAMU DATALAB - Zaid Pervaiz Bhat', + 'contact': 'mailto:mitar.commonprimitives@tnode.com', + 'uris': [ + 'https://gitlab.com/datadrivendiscovery/common-primitives/blob/master/common_primitives/extract_columns_semantic_types.py', + 'https://gitlab.com/datadrivendiscovery/common-primitives.git', + ], + }, + 'installation': [{ + 'type': metadata_base.PrimitiveInstallationType.PIP, + 'package_uri': 'git+https://gitlab.com/datadrivendiscovery/common-primitives.git@{git_commit}#egg=common_primitives'.format( + git_commit=d3m_utils.current_git_commit(os.path.dirname(__file__)), + ), + }], + 'algorithm_types': [ + metadata_base.PrimitiveAlgorithmType.ARRAY_SLICING, + ], + 'primitive_family': metadata_base.PrimitiveFamily.DATA_TRANSFORMATION, + }, + ) + + def produce(self, *, inputs: Inputs, timeout: float = None, iterations: int = None) -> base.CallResult[Outputs]: + columns_to_use = self._get_columns(inputs.metadata) #takes columns matching semantic types + + output_columns = inputs.select_columns(columns_to_use) + + outputs = base_utils.combine_columns(inputs, columns_to_use, [output_columns], return_result='new', add_index_columns=self.hyperparams['add_index_columns']) + + return base.CallResult(outputs) + + def _can_use_column(self, inputs_metadata: metadata_base.DataMetadata, column_index: int) -> bool: + column_metadata = inputs_metadata.query((metadata_base.ALL_ELEMENTS, column_index)) + + semantic_types = column_metadata.get('semantic_types', []) + + if self.hyperparams['match_logic'] == 'all': + match = all(semantic_type in semantic_types for semantic_type in self.hyperparams['semantic_types']) + elif self.hyperparams['match_logic'] == 'any': + match = any(semantic_type in semantic_types for semantic_type in self.hyperparams['semantic_types']) + elif self.hyperparams["match_logic"] == "equal": + match = set(semantic_types) == set(self.hyperparams["semantic_types"]) + else: + raise exceptions.UnexpectedValueError("Unknown value of hyper-parameter \"match_logic\": {value}".format(value=self.hyperparams['match_logic'])) + + if self.hyperparams['negate']: + return not match + else: + return match + + def _get_columns(self, inputs_metadata: metadata_base.DataMetadata) -> typing.Sequence[int]: + def can_use_column(column_index: int) -> bool: + return self._can_use_column(inputs_metadata, column_index) + + columns_to_use, columns_not_to_use = base_utils.get_columns_to_use(inputs_metadata, self.hyperparams['use_columns'], self.hyperparams['exclude_columns'], can_use_column) + + if not columns_to_use: + raise ValueError("Input data has no columns matching semantic types: {semantic_types}".format( + semantic_types=self.hyperparams['semantic_types'], + )) + + if self.hyperparams['use_columns'] and columns_not_to_use: + self.logger.warning("Not all specified columns match semantic types. Skipping columns: %(columns)s", { + 'columns': columns_not_to_use, + }) + + return columns_to_use diff --git a/autovideo/common/utils.py b/autovideo/common/utils.py new file mode 100644 index 0000000..d45dbf0 --- /dev/null +++ b/autovideo/common/utils.py @@ -0,0 +1,192 @@ +import datetime +import logging +import typing + +import dateutil.parser +import numpy # type: ignore + +from d3m import container, deprecate +from d3m.base import utils as base_utils +from d3m.metadata import base as metadata_base + +logger = logging.getLogger(__name__) + +DEFAULT_DATETIME = datetime.datetime.fromtimestamp(0, datetime.timezone.utc) + + +@deprecate.function(message="it should not be used anymore") +def copy_elements_metadata(source_metadata: metadata_base.Metadata, target_metadata: metadata_base.DataMetadata, from_selector: metadata_base.Selector, + to_selector: metadata_base.Selector = (), *, ignore_all_elements: bool = False, check: bool = True, source: typing.Any = None) -> metadata_base.DataMetadata: + return source_metadata._copy_elements_metadata(target_metadata, list(from_selector), list(to_selector), [], ignore_all_elements) + + +@deprecate.function(message="use Metadata.copy_to method instead") +def copy_metadata(source_metadata: metadata_base.Metadata, target_metadata: metadata_base.DataMetadata, from_selector: metadata_base.Selector, + to_selector: metadata_base.Selector = (), *, ignore_all_elements: bool = False, check: bool = True, source: typing.Any = None) -> metadata_base.DataMetadata: + return source_metadata.copy_to(target_metadata, from_selector, to_selector, ignore_all_elements=ignore_all_elements) + + +@deprecate.function(message="use DataFrame.select_columns method instead") +@deprecate.arguments('source', message="argument ignored") +def select_columns(inputs: container.DataFrame, columns: typing.Sequence[metadata_base.SimpleSelectorSegment], *, + source: typing.Any = None) -> container.DataFrame: + return inputs.select_columns(columns) + + +@deprecate.function(message="use DataMetadata.select_columns method instead") +@deprecate.arguments('source', message="argument ignored") +def select_columns_metadata(inputs_metadata: metadata_base.DataMetadata, columns: typing.Sequence[metadata_base.SimpleSelectorSegment], *, + source: typing.Any = None) -> metadata_base.DataMetadata: + return inputs_metadata.select_columns(columns) + + +@deprecate.function(message="use DataMetadata.list_columns_with_semantic_types method instead") +def list_columns_with_semantic_types(metadata: metadata_base.DataMetadata, semantic_types: typing.Sequence[str], *, + at: metadata_base.Selector = ()) -> typing.Sequence[int]: + return metadata.list_columns_with_semantic_types(semantic_types, at=at) + + +@deprecate.function(message="use DataMetadata.list_columns_with_structural_types method instead") +def list_columns_with_structural_types(metadata: metadata_base.DataMetadata, structural_types: typing.Union[typing.Callable, typing.Sequence[typing.Union[str, type]]], *, + at: metadata_base.Selector = ()) -> typing.Sequence[int]: + return metadata.list_columns_with_structural_types(structural_types, at=at) + + +@deprecate.function(message="use DataFrame.remove_columns method instead") +@deprecate.arguments('source', message="argument ignored") +def remove_columns(inputs: container.DataFrame, column_indices: typing.Sequence[int], *, source: typing.Any = None) -> container.DataFrame: + return inputs.remove_columns(column_indices) + + +@deprecate.function(message="use DataMetadata.remove_columns method instead") +@deprecate.arguments('source', message="argument ignored") +def remove_columns_metadata(inputs_metadata: metadata_base.DataMetadata, column_indices: typing.Sequence[int], *, source: typing.Any = None) -> metadata_base.DataMetadata: + return inputs_metadata.remove_columns(column_indices) + + +@deprecate.function(message="use DataFrame.append_columns method instead") +@deprecate.arguments('source', message="argument ignored") +def append_columns(left: container.DataFrame, right: container.DataFrame, *, use_right_metadata: bool = False, source: typing.Any = None) -> container.DataFrame: + return left.append_columns(right, use_right_metadata=use_right_metadata) + + +@deprecate.function(message="use DataMetadata.append_columns method instead") +@deprecate.arguments('source', message="argument ignored") +def append_columns_metadata(left_metadata: metadata_base.DataMetadata, right_metadata: metadata_base.DataMetadata, use_right_metadata: bool = False, source: typing.Any = None) -> metadata_base.DataMetadata: + return left_metadata.append_columns(right_metadata, use_right_metadata=use_right_metadata) + + +@deprecate.function(message="use DataFrame.insert_columns method instead") +@deprecate.arguments('source', message="argument ignored") +def insert_columns(inputs: container.DataFrame, columns: container.DataFrame, at_column_index: int, *, source: typing.Any = None) -> container.DataFrame: + return inputs.insert_columns(columns, at_column_index) + + +@deprecate.function(message="use DataMetadata.insert_columns method instead") +@deprecate.arguments('source', message="argument ignored") +def insert_columns_metadata(inputs_metadata: metadata_base.DataMetadata, columns_metadata: metadata_base.DataMetadata, at_column_index: int, *, source: typing.Any = None) -> metadata_base.DataMetadata: + return inputs_metadata.insert_columns(columns_metadata, at_column_index) + + +@deprecate.function(message="use DataFrame.replace_columns method instead") +@deprecate.arguments('source', message="argument ignored") +def replace_columns(inputs: container.DataFrame, columns: container.DataFrame, column_indices: typing.Sequence[int], *, copy: bool = True, source: typing.Any = None) -> container.DataFrame: + return inputs.replace_columns(columns, column_indices, copy=copy) + + +@deprecate.function(message="use DataMetadata.replace_columns method instead") +@deprecate.arguments('source', message="argument ignored") +def replace_columns_metadata(inputs_metadata: metadata_base.DataMetadata, columns_metadata: metadata_base.DataMetadata, column_indices: typing.Sequence[int], *, source: typing.Any = None) -> metadata_base.DataMetadata: + return inputs_metadata.replace_columns(columns_metadata, column_indices) + + +@deprecate.function(message="use DataMetadata.get_index_columns method instead") +def get_index_columns(metadata: metadata_base.DataMetadata, *, at: metadata_base.Selector = ()) -> typing.Sequence[int]: + return metadata.get_index_columns(at=at) + + +@deprecate.function(message="use DataFrame.horizontal_concat method instead") +@deprecate.arguments('source', message="argument ignored") +def horizontal_concat(left: container.DataFrame, right: container.DataFrame, *, use_index: bool = True, + remove_second_index: bool = True, use_right_metadata: bool = False, source: typing.Any = None) -> container.DataFrame: + return left.horizontal_concat(right, use_index=use_index, remove_second_index=remove_second_index, use_right_metadata=use_right_metadata) + + +@deprecate.function(message="use DataMetadata.horizontal_concat method instead") +@deprecate.arguments('source', message="argument ignored") +def horizontal_concat_metadata(left_metadata: metadata_base.DataMetadata, right_metadata: metadata_base.DataMetadata, *, use_index: bool = True, + remove_second_index: bool = True, use_right_metadata: bool = False, source: typing.Any = None) -> metadata_base.DataMetadata: + return left_metadata.horizontal_concat(right_metadata, use_index=use_index, remove_second_index=remove_second_index, use_right_metadata=use_right_metadata) + + +@deprecate.function(message="use d3m.base.utils.get_columns_to_use function instead") +def get_columns_to_use(metadata: metadata_base.DataMetadata, use_columns: typing.Sequence[int], exclude_columns: typing.Sequence[int], + can_use_column: typing.Callable) -> typing.Tuple[typing.List[int], typing.List[int]]: + return base_utils.get_columns_to_use(metadata, use_columns, exclude_columns, can_use_column) + + +@deprecate.function(message="use d3m.base.utils.combine_columns function instead") +@deprecate.arguments('source', message="argument ignored") +def combine_columns(return_result: str, add_index_columns: bool, inputs: container.DataFrame, column_indices: typing.Sequence[int], + columns_list: typing.Sequence[container.DataFrame], *, source: typing.Any = None) -> container.DataFrame: + return base_utils.combine_columns(inputs, column_indices, columns_list, return_result=return_result, add_index_columns=add_index_columns) + + +@deprecate.function(message="use d3m.base.utils.combine_columns_metadata function instead") +@deprecate.arguments('source', message="argument ignored") +def combine_columns_metadata(return_result: str, add_index_columns: bool, inputs_metadata: metadata_base.DataMetadata, column_indices: typing.Sequence[int], + columns_metadata_list: typing.Sequence[metadata_base.DataMetadata], *, source: typing.Any = None) -> metadata_base.DataMetadata: + return base_utils.combine_columns_metadata(inputs_metadata, column_indices, columns_metadata_list, return_result=return_result, add_index_columns=add_index_columns) + + +@deprecate.function(message="use DataMetadata.set_table_metadata method instead") +@deprecate.arguments('source', message="argument ignored") +def set_table_metadata(inputs_metadata: metadata_base.DataMetadata, *, at: metadata_base.Selector = (), source: typing.Any = None) -> metadata_base.DataMetadata: + return inputs_metadata.set_table_metadata(at=at) + + +@deprecate.function(message="use DataMetadata.get_column_index_from_column_name method instead") +def get_column_index_from_column_name(inputs_metadata: metadata_base.DataMetadata, column_name: str, *, at: metadata_base.Selector = ()) -> int: + return inputs_metadata.get_column_index_from_column_name(column_name, at=at) + + +@deprecate.function(message="use Dataset.get_relations_graph method instead") +def build_relation_graph(dataset: container.Dataset) -> typing.Dict[str, typing.List[typing.Tuple[str, bool, int, int, typing.Dict]]]: + return dataset.get_relations_graph() + + +@deprecate.function(message="use d3m.base.utils.get_tabular_resource function instead") +def get_tabular_resource(dataset: container.Dataset, resource_id: typing.Optional[str], *, + pick_entry_point: bool = True, pick_one: bool = True, has_hyperparameter: bool = True) -> typing.Tuple[str, container.DataFrame]: + return base_utils.get_tabular_resource(dataset, resource_id, pick_entry_point=pick_entry_point, pick_one=pick_one, has_hyperparameter=has_hyperparameter) + + +@deprecate.function(message="use d3m.base.utils.get_tabular_resource_metadata function instead") +def get_tabular_resource_metadata(dataset_metadata: metadata_base.DataMetadata, resource_id: typing.Optional[metadata_base.SelectorSegment], *, + pick_entry_point: bool = True, pick_one: bool = True) -> metadata_base.SelectorSegment: + return base_utils.get_tabular_resource_metadata(dataset_metadata, resource_id, pick_entry_point=pick_entry_point, pick_one=pick_one) + + +@deprecate.function(message="use Dataset.select_rows method instead") +@deprecate.arguments('source', message="argument ignored") +def cut_dataset(dataset: container.Dataset, row_indices_to_keep: typing.Mapping[str, typing.Sequence[int]], *, + source: typing.Any = None) -> container.Dataset: + return dataset.select_rows(row_indices_to_keep) + + +def parse_datetime(value: str, *, fuzzy: bool = True) -> typing.Optional[datetime.datetime]: + try: + return dateutil.parser.parse(value, default=DEFAULT_DATETIME, fuzzy=fuzzy) + except (ValueError, OverflowError, TypeError): + return None + + +def parse_datetime_to_float(value: str, *, fuzzy: bool = True) -> float: + try: + parsed = parse_datetime(value, fuzzy=fuzzy) + if parsed is None: + return numpy.nan + else: + return parsed.timestamp() + except (ValueError, OverflowError, TypeError): + return numpy.nan diff --git a/autovideo/recognition/R2p1D/mean.py b/autovideo/recognition/R2p1D/mean.py new file mode 100644 index 0000000..ecd2255 --- /dev/null +++ b/autovideo/recognition/R2p1D/mean.py @@ -0,0 +1,17 @@ +def get_mean_std(value_scale, dataset): + assert dataset in ['activitynet', 'kinetics', '0.5'] + + if dataset == 'activitynet': + mean = [0.4477, 0.4209, 0.3906] + std = [0.2767, 0.2695, 0.2714] + elif dataset == 'kinetics': + mean = [0.4345, 0.4051, 0.3775] + std = [0.2768, 0.2713, 0.2737] + elif dataset == '0.5': + mean = [0.5, 0.5, 0.5] + std = [0.5, 0.5, 0.5] + + mean = [x * value_scale for x in mean] + std = [x * value_scale for x in std] + + return mean, std \ No newline at end of file diff --git a/autovideo/recognition/R2p1D/model.py b/autovideo/recognition/R2p1D/model.py new file mode 100644 index 0000000..c0d8d43 --- /dev/null +++ b/autovideo/recognition/R2p1D/model.py @@ -0,0 +1,127 @@ +import torch +from torch import nn + +from .models import resnet, resnet2p1d, pre_act_resnet, wide_resnet, resnext, densenet + + +def get_module_name(name): + name = name.split('.') + if name[0] == 'module': + i = 1 + else: + i = 0 + if name[i] == 'features': + i += 1 + + return name[i] + + +def get_fine_tuning_parameters(model, ft_begin_module): + if not ft_begin_module: + return model.parameters() + + parameters = [] + add_flag = False + for k, v in model.named_parameters(): + if ft_begin_module == get_module_name(k): + add_flag = True + + if add_flag: + parameters.append({'params': v}) + + return parameters + + +def generate_model(opt): + assert opt.model in [ + 'resnet', 'resnet2p1d', 'preresnet', 'wideresnet', 'resnext', 'densenet' + ] + if opt.model == 'resnet': + model = resnet.generate_model(model_depth=opt.model_depth, + n_classes=opt.n_classes, + n_input_channels=opt.n_input_channels, + shortcut_type=opt.resnet_shortcut, + conv1_t_size=opt.conv1_t_size, + conv1_t_stride=opt.conv1_t_stride, + no_max_pool=opt.no_max_pool, + widen_factor=opt.resnet_widen_factor) + elif opt.model == 'resnet2p1d': + model = resnet2p1d.generate_model(model_depth=opt.model_depth, + n_classes=opt.n_classes, + n_input_channels=opt.n_input_channels, + shortcut_type=opt.resnet_shortcut, + conv1_t_size=opt.conv1_t_size, + conv1_t_stride=opt.conv1_t_stride, + no_max_pool=opt.no_max_pool, + widen_factor=opt.resnet_widen_factor) + elif opt.model == 'wideresnet': + model = wide_resnet.generate_model( + model_depth=opt.model_depth, + k=opt.wide_resnet_k, + n_classes=opt.n_classes, + n_input_channels=opt.n_input_channels, + shortcut_type=opt.resnet_shortcut, + conv1_t_size=opt.conv1_t_size, + conv1_t_stride=opt.conv1_t_stride, + no_max_pool=opt.no_max_pool) + elif opt.model == 'resnext': + model = resnext.generate_model(model_depth=opt.model_depth, + cardinality=opt.resnext_cardinality, + n_classes=opt.n_classes, + n_input_channels=opt.n_input_channels, + shortcut_type=opt.resnet_shortcut, + conv1_t_size=opt.conv1_t_size, + conv1_t_stride=opt.conv1_t_stride, + no_max_pool=opt.no_max_pool) + elif opt.model == 'preresnet': + model = pre_act_resnet.generate_model( + model_depth=opt.model_depth, + n_classes=opt.n_classes, + n_input_channels=opt.n_input_channels, + shortcut_type=opt.resnet_shortcut, + conv1_t_size=opt.conv1_t_size, + conv1_t_stride=opt.conv1_t_stride, + no_max_pool=opt.no_max_pool) + elif opt.model == 'densenet': + model = densenet.generate_model(model_depth=opt.model_depth, + n_classes=opt.n_classes, + n_input_channels=opt.n_input_channels, + conv1_t_size=opt.conv1_t_size, + conv1_t_stride=opt.conv1_t_stride, + no_max_pool=opt.no_max_pool) + + return model + + +def load_pretrained_model(model, pretrain_path, model_name, n_finetune_classes): + if pretrain_path: + print('loading pretrained model {}'.format(pretrain_path)) + pretrain = torch.load(pretrain_path, map_location='cpu') + + model.load_state_dict(pretrain['state_dict']) + tmp_model = model + if model_name == 'densenet': + tmp_model.classifier = nn.Linear(tmp_model.classifier.in_features, + n_finetune_classes) + else: + tmp_model.fc = nn.Linear(tmp_model.fc.in_features, + n_finetune_classes) + + return model + + +def make_data_parallel(model, is_distributed, device): + if is_distributed: + if device.type == 'cuda' and device.index is not None: + torch.cuda.set_device(device) + model.to(device) + + model = nn.parallel.DistributedDataParallel(model, + device_ids=[device]) + else: + model.to(device) + model = nn.parallel.DistributedDataParallel(model) + elif device.type == 'cuda': + model = nn.DataParallel(model, device_ids=None).cuda() + + return model diff --git a/autovideo/recognition/R2p1D/models/__init__.py b/autovideo/recognition/R2p1D/models/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/autovideo/recognition/R2p1D/models/densenet.py b/autovideo/recognition/R2p1D/models/densenet.py new file mode 100644 index 0000000..145009a --- /dev/null +++ b/autovideo/recognition/R2p1D/models/densenet.py @@ -0,0 +1,185 @@ +import math + +import torch +import torch.nn as nn +import torch.nn.functional as F +from collections import OrderedDict + + +class _DenseLayer(nn.Sequential): + + def __init__(self, num_input_features, growth_rate, bn_size, drop_rate): + super().__init__() + self.add_module('norm1', nn.BatchNorm3d(num_input_features)) + self.add_module('relu1', nn.ReLU(inplace=True)) + self.add_module( + 'conv1', + nn.Conv3d(num_input_features, + bn_size * growth_rate, + kernel_size=1, + stride=1, + bias=False)) + self.add_module('norm2', nn.BatchNorm3d(bn_size * growth_rate)) + self.add_module('relu2', nn.ReLU(inplace=True)) + self.add_module( + 'conv2', + nn.Conv3d(bn_size * growth_rate, + growth_rate, + kernel_size=3, + stride=1, + padding=1, + bias=False)) + self.drop_rate = drop_rate + + def forward(self, x): + new_features = super().forward(x) + if self.drop_rate > 0: + new_features = F.dropout(new_features, + p=self.drop_rate, + training=self.training) + return torch.cat([x, new_features], 1) + + +class _DenseBlock(nn.Sequential): + + def __init__(self, num_layers, num_input_features, bn_size, growth_rate, + drop_rate): + super().__init__() + for i in range(num_layers): + layer = _DenseLayer(num_input_features + i * growth_rate, + growth_rate, bn_size, drop_rate) + self.add_module('denselayer{}'.format(i + 1), layer) + + +class _Transition(nn.Sequential): + + def __init__(self, num_input_features, num_output_features): + super().__init__() + self.add_module('norm', nn.BatchNorm3d(num_input_features)) + self.add_module('relu', nn.ReLU(inplace=True)) + self.add_module( + 'conv', + nn.Conv3d(num_input_features, + num_output_features, + kernel_size=1, + stride=1, + bias=False)) + self.add_module('pool', nn.AvgPool3d(kernel_size=2, stride=2)) + + +class DenseNet(nn.Module): + """Densenet-BC model class + Args: + growth_rate (int) - how many filters to add each layer (k in paper) + block_config (list of 4 ints) - how many layers in each pooling block + num_init_features (int) - the number of filters to learn in the first convolution layer + bn_size (int) - multiplicative factor for number of bottle neck layers + (i.e. bn_size * k features in the bottleneck layer) + drop_rate (float) - dropout rate after each dense layer + num_classes (int) - number of classification classes + """ + + def __init__(self, + n_input_channels=3, + conv1_t_size=7, + conv1_t_stride=1, + no_max_pool=False, + growth_rate=32, + block_config=(6, 12, 24, 16), + num_init_features=64, + bn_size=4, + drop_rate=0, + num_classes=1000): + + super().__init__() + + # First convolution + self.features = [('conv1', + nn.Conv3d(n_input_channels, + num_init_features, + kernel_size=(conv1_t_size, 7, 7), + stride=(conv1_t_stride, 2, 2), + padding=(conv1_t_size // 2, 3, 3), + bias=False)), + ('norm1', nn.BatchNorm3d(num_init_features)), + ('relu1', nn.ReLU(inplace=True))] + if not no_max_pool: + self.features.append( + ('pool1', nn.MaxPool3d(kernel_size=3, stride=2, padding=1))) + self.features = nn.Sequential(OrderedDict(self.features)) + + # Each denseblock + num_features = num_init_features + for i, num_layers in enumerate(block_config): + block = _DenseBlock(num_layers=num_layers, + num_input_features=num_features, + bn_size=bn_size, + growth_rate=growth_rate, + drop_rate=drop_rate) + self.features.add_module('denseblock{}'.format(i + 1), block) + num_features = num_features + num_layers * growth_rate + if i != len(block_config) - 1: + trans = _Transition(num_input_features=num_features, + num_output_features=num_features // 2) + self.features.add_module('transition{}'.format(i + 1), trans) + num_features = num_features // 2 + + # Final batch norm + self.features.add_module('norm5', nn.BatchNorm3d(num_features)) + + for m in self.modules(): + if isinstance(m, nn.Conv3d): + m.weight = nn.init.kaiming_normal(m.weight, mode='fan_out') + elif isinstance(m, nn.BatchNorm3d) or isinstance(m, nn.BatchNorm2d): + m.weight.data.fill_(1) + m.bias.data.zero_() + + # Linear layer + self.classifier = nn.Linear(num_features, num_classes) + + for m in self.modules(): + if isinstance(m, nn.Conv3d): + nn.init.kaiming_normal_(m.weight, + mode='fan_out', + nonlinearity='relu') + elif isinstance(m, nn.BatchNorm3d): + nn.init.constant_(m.weight, 1) + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.Linear): + nn.init.constant_(m.bias, 0) + + def forward(self, x): + features = self.features(x) + out = F.relu(features, inplace=True) + out = F.adaptive_avg_pool3d(out, + output_size=(1, 1, + 1)).view(features.size(0), -1) + out = self.classifier(out) + return out + + +def generate_model(model_depth, **kwargs): + assert model_depth in [121, 169, 201, 264] + + if model_depth == 121: + model = DenseNet(num_init_features=64, + growth_rate=32, + block_config=(6, 12, 24, 16), + **kwargs) + elif model_depth == 169: + model = DenseNet(num_init_features=64, + growth_rate=32, + block_config=(6, 12, 32, 32), + **kwargs) + elif model_depth == 201: + model = DenseNet(num_init_features=64, + growth_rate=32, + block_config=(6, 12, 48, 32), + **kwargs) + elif model_depth == 264: + model = DenseNet(num_init_features=64, + growth_rate=32, + block_config=(6, 12, 64, 48), + **kwargs) + + return model \ No newline at end of file diff --git a/autovideo/recognition/R2p1D/models/pre_act_resnet.py b/autovideo/recognition/R2p1D/models/pre_act_resnet.py new file mode 100644 index 0000000..5f89535 --- /dev/null +++ b/autovideo/recognition/R2p1D/models/pre_act_resnet.py @@ -0,0 +1,105 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +from .resnet import conv3x3x3, conv1x1x1, get_inplanes, ResNet + + +class PreActivationBasicBlock(nn.Module): + expansion = 1 + + def __init__(self, inplanes, planes, stride=1, downsample=None): + super().__init__() + + self.bn1 = nn.BatchNorm3d(inplanes) + self.conv1 = conv3x3x3(inplanes, planes, stride) + self.bn2 = nn.BatchNorm3d(planes) + self.conv2 = conv3x3x3(planes, planes) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.bn1(x) + out = self.relu(out) + out = self.conv1(out) + + out = self.bn2(out) + out = self.relu(out) + out = self.conv2(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + + return out + + +class PreActivationBottleneck(nn.Module): + expansion = 4 + + def __init__(self, inplanes, planes, stride=1, downsample=None): + super().__init__() + + self.bn1 = nn.BatchNorm3d(inplanes) + self.conv1 = conv1x1x1(inplanes, planes) + self.bn2 = nn.BatchNorm3d(planes) + self.conv2 = conv3x3x3(planes, planes, stride) + self.bn3 = nn.BatchNorm3d(planes) + self.conv3 = conv1x1x1(planes, planes * self.expansion) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.bn1(x) + out = self.relu(out) + out = self.conv1(out) + + out = self.bn2(out) + out = self.relu(out) + out = self.conv2(out) + + out = self.bn3(out) + out = self.relu(out) + out = self.conv3(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + + return out + + +def generate_model(model_depth, **kwargs): + assert model_depth in [10, 18, 34, 50, 101, 152, 200] + + if model_depth == 10: + model = ResNet(PreActivationBasicBlock, [1, 1, 1, 1], get_inplanes(), + **kwargs) + elif model_depth == 18: + model = ResNet(PreActivationBasicBlock, [2, 2, 2, 2], get_inplanes(), + **kwargs) + elif model_depth == 34: + model = ResNet(PreActivationBasicBlock, [3, 4, 6, 3], get_inplanes(), + **kwargs) + elif model_depth == 50: + model = ResNet(PreActivationBottleneck, [3, 4, 6, 3], get_inplanes(), + **kwargs) + elif model_depth == 101: + model = ResNet(PreActivationBottleneck, [3, 4, 23, 3], get_inplanes(), + **kwargs) + elif model_depth == 152: + model = ResNet(PreActivationBottleneck, [3, 8, 36, 3], get_inplanes(), + **kwargs) + elif model_depth == 200: + model = ResNet(PreActivationBottleneck, [3, 24, 36, 3], get_inplanes(), + **kwargs) + + return model diff --git a/autovideo/recognition/R2p1D/models/resnet.py b/autovideo/recognition/R2p1D/models/resnet.py new file mode 100644 index 0000000..5eef43c --- /dev/null +++ b/autovideo/recognition/R2p1D/models/resnet.py @@ -0,0 +1,234 @@ +import math +from functools import partial + +import torch +import torch.nn as nn +import torch.nn.functional as F + + +def get_inplanes(): + return [64, 128, 256, 512] + + +def conv3x3x3(in_planes, out_planes, stride=1): + return nn.Conv3d(in_planes, + out_planes, + kernel_size=3, + stride=stride, + padding=1, + bias=False) + + +def conv1x1x1(in_planes, out_planes, stride=1): + return nn.Conv3d(in_planes, + out_planes, + kernel_size=1, + stride=stride, + bias=False) + + +class BasicBlock(nn.Module): + expansion = 1 + + def __init__(self, in_planes, planes, stride=1, downsample=None): + super().__init__() + + self.conv1 = conv3x3x3(in_planes, planes, stride) + self.bn1 = nn.BatchNorm3d(planes) + self.relu = nn.ReLU(inplace=True) + self.conv2 = conv3x3x3(planes, planes) + self.bn2 = nn.BatchNorm3d(planes) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, in_planes, planes, stride=1, downsample=None): + super().__init__() + + self.conv1 = conv1x1x1(in_planes, planes) + self.bn1 = nn.BatchNorm3d(planes) + self.conv2 = conv3x3x3(planes, planes, stride) + self.bn2 = nn.BatchNorm3d(planes) + self.conv3 = conv1x1x1(planes, planes * self.expansion) + self.bn3 = nn.BatchNorm3d(planes * self.expansion) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + out = self.relu(out) + + out = self.conv3(out) + out = self.bn3(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class ResNet(nn.Module): + + def __init__(self, + block, + layers, + block_inplanes, + n_input_channels=3, + conv1_t_size=7, + conv1_t_stride=1, + no_max_pool=False, + shortcut_type='B', + widen_factor=1.0, + n_classes=400): + super().__init__() + + block_inplanes = [int(x * widen_factor) for x in block_inplanes] + + self.in_planes = block_inplanes[0] + self.no_max_pool = no_max_pool + + self.conv1 = nn.Conv3d(n_input_channels, + self.in_planes, + kernel_size=(conv1_t_size, 7, 7), + stride=(conv1_t_stride, 2, 2), + padding=(conv1_t_size // 2, 3, 3), + bias=False) + self.bn1 = nn.BatchNorm3d(self.in_planes) + self.relu = nn.ReLU(inplace=True) + self.maxpool = nn.MaxPool3d(kernel_size=3, stride=2, padding=1) + self.layer1 = self._make_layer(block, block_inplanes[0], layers[0], + shortcut_type) + self.layer2 = self._make_layer(block, + block_inplanes[1], + layers[1], + shortcut_type, + stride=2) + self.layer3 = self._make_layer(block, + block_inplanes[2], + layers[2], + shortcut_type, + stride=2) + self.layer4 = self._make_layer(block, + block_inplanes[3], + layers[3], + shortcut_type, + stride=2) + + self.avgpool = nn.AdaptiveAvgPool3d((1, 1, 1)) + self.fc = nn.Linear(block_inplanes[3] * block.expansion, n_classes) + + for m in self.modules(): + if isinstance(m, nn.Conv3d): + nn.init.kaiming_normal_(m.weight, + mode='fan_out', + nonlinearity='relu') + elif isinstance(m, nn.BatchNorm3d): + nn.init.constant_(m.weight, 1) + nn.init.constant_(m.bias, 0) + + def _downsample_basic_block(self, x, planes, stride): + out = F.avg_pool3d(x, kernel_size=1, stride=stride) + zero_pads = torch.zeros(out.size(0), planes - out.size(1), out.size(2), + out.size(3), out.size(4)) + if isinstance(out.data, torch.cuda.FloatTensor): + zero_pads = zero_pads.cuda() + + out = torch.cat([out.data, zero_pads], dim=1) + + return out + + def _make_layer(self, block, planes, blocks, shortcut_type, stride=1): + downsample = None + if stride != 1 or self.in_planes != planes * block.expansion: + if shortcut_type == 'A': + downsample = partial(self._downsample_basic_block, + planes=planes * block.expansion, + stride=stride) + else: + downsample = nn.Sequential( + conv1x1x1(self.in_planes, planes * block.expansion, stride), + nn.BatchNorm3d(planes * block.expansion)) + + layers = [] + layers.append( + block(in_planes=self.in_planes, + planes=planes, + stride=stride, + downsample=downsample)) + self.in_planes = planes * block.expansion + for i in range(1, blocks): + layers.append(block(self.in_planes, planes)) + + return nn.Sequential(*layers) + + def forward(self, x): + x = self.conv1(x) + x = self.bn1(x) + x = self.relu(x) + if not self.no_max_pool: + x = self.maxpool(x) + + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + + x = self.avgpool(x) + + x = x.view(x.size(0), -1) + x = self.fc(x) + + return x + + +def generate_model(model_depth, **kwargs): + assert model_depth in [10, 18, 34, 50, 101, 152, 200] + + if model_depth == 10: + model = ResNet(BasicBlock, [1, 1, 1, 1], get_inplanes(), **kwargs) + elif model_depth == 18: + model = ResNet(BasicBlock, [2, 2, 2, 2], get_inplanes(), **kwargs) + elif model_depth == 34: + model = ResNet(BasicBlock, [3, 4, 6, 3], get_inplanes(), **kwargs) + elif model_depth == 50: + model = ResNet(Bottleneck, [3, 4, 6, 3], get_inplanes(), **kwargs) + elif model_depth == 101: + model = ResNet(Bottleneck, [3, 4, 23, 3], get_inplanes(), **kwargs) + elif model_depth == 152: + model = ResNet(Bottleneck, [3, 8, 36, 3], get_inplanes(), **kwargs) + elif model_depth == 200: + model = ResNet(Bottleneck, [3, 24, 36, 3], get_inplanes(), **kwargs) + + return model diff --git a/autovideo/recognition/R2p1D/models/resnet2p1d.py b/autovideo/recognition/R2p1D/models/resnet2p1d.py new file mode 100644 index 0000000..b9a32c0 --- /dev/null +++ b/autovideo/recognition/R2p1D/models/resnet2p1d.py @@ -0,0 +1,286 @@ +import math +from functools import partial + +import torch +import torch.nn as nn +import torch.nn.functional as F + + +def get_inplanes(): + return [64, 128, 256, 512] + + +def conv1x3x3(in_planes, mid_planes, stride=1): + return nn.Conv3d(in_planes, + mid_planes, + kernel_size=(1, 3, 3), + stride=(1, stride, stride), + padding=(0, 1, 1), + bias=False) + + +def conv3x1x1(mid_planes, planes, stride=1): + return nn.Conv3d(mid_planes, + planes, + kernel_size=(3, 1, 1), + stride=(stride, 1, 1), + padding=(1, 0, 0), + bias=False) + + +def conv1x1x1(in_planes, out_planes, stride=1): + return nn.Conv3d(in_planes, + out_planes, + kernel_size=1, + stride=stride, + bias=False) + + +class BasicBlock(nn.Module): + expansion = 1 + + def __init__(self, in_planes, planes, stride=1, downsample=None): + super().__init__() + + n_3d_parameters1 = in_planes * planes * 3 * 3 * 3 + n_2p1d_parameters1 = in_planes * 3 * 3 + 3 * planes + mid_planes1 = n_3d_parameters1 // n_2p1d_parameters1 + self.conv1_s = conv1x3x3(in_planes, mid_planes1, stride) + self.bn1_s = nn.BatchNorm3d(mid_planes1) + self.conv1_t = conv3x1x1(mid_planes1, planes, stride) + self.bn1_t = nn.BatchNorm3d(planes) + + n_3d_parameters2 = planes * planes * 3 * 3 * 3 + n_2p1d_parameters2 = planes * 3 * 3 + 3 * planes + mid_planes2 = n_3d_parameters2 // n_2p1d_parameters2 + self.conv2_s = conv1x3x3(planes, mid_planes2) + self.bn2_s = nn.BatchNorm3d(mid_planes2) + self.conv2_t = conv3x1x1(mid_planes2, planes) + self.bn2_t = nn.BatchNorm3d(planes) + + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1_s(x) + out = self.bn1_s(out) + out = self.relu(out) + out = self.conv1_t(out) + out = self.bn1_t(out) + out = self.relu(out) + + out = self.conv2_s(out) + out = self.bn2_s(out) + out = self.relu(out) + out = self.conv2_t(out) + out = self.bn2_t(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, in_planes, planes, stride=1, downsample=None): + super().__init__() + + self.conv1 = conv1x1x1(in_planes, planes) + self.bn1 = nn.BatchNorm3d(planes) + + n_3d_parameters = planes * planes * 3 * 3 * 3 + n_2p1d_parameters = planes * 3 * 3 + 3 * planes + mid_planes = n_3d_parameters // n_2p1d_parameters + self.conv2_s = conv1x3x3(planes, mid_planes, stride) + self.bn2_s = nn.BatchNorm3d(mid_planes) + self.conv2_t = conv3x1x1(mid_planes, planes, stride) + self.bn2_t = nn.BatchNorm3d(planes) + + self.conv3 = conv1x1x1(planes, planes * self.expansion) + self.bn3 = nn.BatchNorm3d(planes * self.expansion) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2_s(out) + out = self.bn2_s(out) + out = self.relu(out) + out = self.conv2_t(out) + out = self.bn2_t(out) + out = self.relu(out) + + out = self.conv3(out) + out = self.bn3(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class ResNet(nn.Module): + + def __init__(self, + block, + layers, + block_inplanes, + n_input_channels=3, + conv1_t_size=7, + conv1_t_stride=1, + no_max_pool=False, + shortcut_type='B', + widen_factor=1.0, + n_classes=400): + super().__init__() + + block_inplanes = [int(x * widen_factor) for x in block_inplanes] + + self.in_planes = block_inplanes[0] + self.no_max_pool = no_max_pool + + n_3d_parameters = 3 * self.in_planes * conv1_t_size * 7 * 7 + n_2p1d_parameters = 3 * 7 * 7 + conv1_t_size * self.in_planes + mid_planes = n_3d_parameters // n_2p1d_parameters + self.conv1_s = nn.Conv3d(n_input_channels, + mid_planes, + kernel_size=(1, 7, 7), + stride=(1, 2, 2), + padding=(0, 3, 3), + bias=False) + self.bn1_s = nn.BatchNorm3d(mid_planes) + self.conv1_t = nn.Conv3d(mid_planes, + self.in_planes, + kernel_size=(conv1_t_size, 1, 1), + stride=(conv1_t_stride, 1, 1), + padding=(conv1_t_size // 2, 0, 0), + bias=False) + self.bn1_t = nn.BatchNorm3d(self.in_planes) + self.relu = nn.ReLU(inplace=True) + + self.maxpool = nn.MaxPool3d(kernel_size=3, stride=2, padding=1) + self.layer1 = self._make_layer(block, block_inplanes[0], layers[0], + shortcut_type) + self.layer2 = self._make_layer(block, + block_inplanes[1], + layers[1], + shortcut_type, + stride=2) + self.layer3 = self._make_layer(block, + block_inplanes[2], + layers[2], + shortcut_type, + stride=2) + self.layer4 = self._make_layer(block, + block_inplanes[3], + layers[3], + shortcut_type, + stride=2) + + self.avgpool = nn.AdaptiveAvgPool3d((1, 1, 1)) + self.fc = nn.Linear(block_inplanes[3] * block.expansion, n_classes) + + for m in self.modules(): + if isinstance(m, nn.Conv3d): + nn.init.kaiming_normal_(m.weight, + mode='fan_out', + nonlinearity='relu') + elif isinstance(m, nn.BatchNorm3d): + nn.init.constant_(m.weight, 1) + nn.init.constant_(m.bias, 0) + + def _downsample_basic_block(self, x, planes, stride): + out = F.avg_pool3d(x, kernel_size=1, stride=stride) + zero_pads = torch.zeros(out.size(0), planes - out.size(1), out.size(2), + out.size(3), out.size(4)) + if isinstance(out.data, torch.cuda.FloatTensor): + zero_pads = zero_pads.cuda() + + out = torch.cat([out.data, zero_pads], dim=1) + + return out + + def _make_layer(self, block, planes, blocks, shortcut_type, stride=1): + downsample = None + if stride != 1 or self.in_planes != planes * block.expansion: + if shortcut_type == 'A': + downsample = partial(self._downsample_basic_block, + planes=planes * block.expansion, + stride=stride) + else: + downsample = nn.Sequential( + conv1x1x1(self.in_planes, planes * block.expansion, stride), + nn.BatchNorm3d(planes * block.expansion)) + + layers = [] + layers.append( + block(in_planes=self.in_planes, + planes=planes, + stride=stride, + downsample=downsample)) + self.in_planes = planes * block.expansion + for i in range(1, blocks): + layers.append(block(self.in_planes, planes)) + + return nn.Sequential(*layers) + + def forward(self, x): + x = self.conv1_s(x) + x = self.bn1_s(x) + x = self.relu(x) + x = self.conv1_t(x) + x = self.bn1_t(x) + x = self.relu(x) + + if not self.no_max_pool: + x = self.maxpool(x) + + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + + x = self.avgpool(x) + + x = x.view(x.size(0), -1) + x = self.fc(x) + + return x + + +def generate_model(model_depth, **kwargs): + assert model_depth in [10, 18, 34, 50, 101, 152, 200] + + if model_depth == 10: + model = ResNet(BasicBlock, [1, 1, 1, 1], get_inplanes(), **kwargs) + elif model_depth == 18: + model = ResNet(BasicBlock, [2, 2, 2, 2], get_inplanes(), **kwargs) + elif model_depth == 34: + model = ResNet(BasicBlock, [3, 4, 6, 3], get_inplanes(), **kwargs) + elif model_depth == 50: + model = ResNet(Bottleneck, [3, 4, 6, 3], get_inplanes(), **kwargs) + elif model_depth == 101: + model = ResNet(Bottleneck, [3, 4, 23, 3], get_inplanes(), **kwargs) + elif model_depth == 152: + model = ResNet(Bottleneck, [3, 8, 36, 3], get_inplanes(), **kwargs) + elif model_depth == 200: + model = ResNet(Bottleneck, [3, 24, 36, 3], get_inplanes(), **kwargs) + + return model \ No newline at end of file diff --git a/autovideo/recognition/R2p1D/models/resnext.py b/autovideo/recognition/R2p1D/models/resnext.py new file mode 100644 index 0000000..4b0ceb6 --- /dev/null +++ b/autovideo/recognition/R2p1D/models/resnext.py @@ -0,0 +1,74 @@ +import math +from functools import partial + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from .resnet import conv1x1x1, Bottleneck, ResNet +from ..utils import partialclass + + +def get_inplanes(): + return [128, 256, 512, 1024] + + +class ResNeXtBottleneck(Bottleneck): + expansion = 2 + + def __init__(self, inplanes, planes, cardinality, stride=1, + downsample=None): + super().__init__(inplanes, planes, stride, downsample) + + mid_planes = cardinality * planes // 32 + self.conv1 = conv1x1x1(inplanes, mid_planes) + self.bn1 = nn.BatchNorm3d(mid_planes) + self.conv2 = nn.Conv3d(mid_planes, + mid_planes, + kernel_size=3, + stride=stride, + padding=1, + groups=cardinality, + bias=False) + self.bn2 = nn.BatchNorm3d(mid_planes) + self.conv3 = conv1x1x1(mid_planes, planes * self.expansion) + + +class ResNeXt(ResNet): + + def __init__(self, + block, + layers, + block_inplanes, + n_input_channels=3, + conv1_t_size=7, + conv1_t_stride=1, + no_max_pool=False, + shortcut_type='B', + cardinality=32, + n_classes=400): + block = partialclass(block, cardinality=cardinality) + super().__init__(block, layers, block_inplanes, n_input_channels, + conv1_t_size, conv1_t_stride, no_max_pool, + shortcut_type, n_classes) + + self.fc = nn.Linear(cardinality * 32 * block.expansion, n_classes) + + +def generate_model(model_depth, **kwargs): + assert model_depth in [50, 101, 152, 200] + + if model_depth == 50: + model = ResNeXt(ResNeXtBottleneck, [3, 4, 6, 3], get_inplanes(), + **kwargs) + elif model_depth == 101: + model = ResNeXt(ResNeXtBottleneck, [3, 4, 23, 3], get_inplanes(), + **kwargs) + elif model_depth == 152: + model = ResNeXt(ResNeXtBottleneck, [3, 8, 36, 3], get_inplanes(), + **kwargs) + elif model_depth == 200: + model = ResNeXt(ResNeXtBottleneck, [3, 24, 36, 3], get_inplanes(), + **kwargs) + + return model diff --git a/autovideo/recognition/R2p1D/models/wide_resnet.py b/autovideo/recognition/R2p1D/models/wide_resnet.py new file mode 100644 index 0000000..f7cd0d9 --- /dev/null +++ b/autovideo/recognition/R2p1D/models/wide_resnet.py @@ -0,0 +1,26 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +from . import resnet + + +class WideBottleneck(resnet.Bottleneck): + expansion = 2 + + +def generate_model(model_depth, k, **kwargs): + assert model_depth in [50, 101, 152, 200] + + inplanes = [x * k for x in resnet.get_inplanes()] + if model_depth == 50: + model = resnet.ResNet(WideBottleneck, [3, 4, 6, 3], inplanes, **kwargs) + elif model_depth == 101: + model = resnet.ResNet(WideBottleneck, [3, 4, 23, 3], inplanes, **kwargs) + elif model_depth == 152: + model = resnet.ResNet(WideBottleneck, [3, 8, 36, 3], inplanes, **kwargs) + elif model_depth == 200: + model = resnet.ResNet(WideBottleneck, [3, 24, 36, 3], inplanes, + **kwargs) + + return model diff --git a/autovideo/recognition/R2p1D/opts.py b/autovideo/recognition/R2p1D/opts.py new file mode 100644 index 0000000..e6554cf --- /dev/null +++ b/autovideo/recognition/R2p1D/opts.py @@ -0,0 +1,295 @@ +import argparse +from pathlib import Path + +import sys + +def parse_opts(): + + parser = argparse.ArgumentParser(description="my simple app") + + parser.add_argument('--root_path', + default=None, + type=Path, + help='Root directory path') + parser.add_argument('--video_path', + default=None, + type=Path, + help='Directory path of videos') + parser.add_argument('--annotation_path', + default=None, + type=Path, + help='Annotation file path') + parser.add_argument('--result_path', + default=None, + type=Path, + help='Result directory path') + parser.add_argument( + '--dataset', + default='kinetics', + type=str, + help='Used dataset (activitynet | kinetics | ucf101 | hmdb51)') + parser.add_argument( + '--n_classes', + default=400, + type=int, + help= + 'Number of classes (activitynet: 200, kinetics: 400 or 600, ucf101: 101, hmdb51: 51)' + ) + parser.add_argument('--n_pretrain_classes', + default=0, + type=int, + help=('Number of classes of pretraining task.' + 'When using --pretrain_path, this must be set.')) + parser.add_argument('--pretrain_path', + default=None, + type=Path, + help='Pretrained model path (.pth).') + parser.add_argument( + '--ft_begin_module', + default='', + type=str, + help=('Module name of beginning of fine-tuning' + '(conv1, layer1, fc, denseblock1, classifier, ...).' + 'The default means all layers are fine-tuned.')) + parser.add_argument('--sample_size', + default=112, + type=int, + help='Height and width of inputs') + parser.add_argument('--sample_duration', + default=16, + type=int, + help='Temporal duration of inputs') + parser.add_argument( + '--sample_t_stride', + default=1, + type=int, + help='If larger than 1, input frames are subsampled with the stride.') + parser.add_argument( + '--train_crop', + default='random', + type=str, + help=('Spatial cropping method in training. ' + 'random is uniform. ' + 'corner is selection from 4 corners and 1 center. ' + '(random | corner | center)')) + parser.add_argument('--train_crop_min_scale', + default=0.25, + type=float, + help='Min scale for random cropping in training') + parser.add_argument('--train_crop_min_ratio', + default=0.75, + type=float, + help='Min aspect ratio for random cropping in training') + parser.add_argument('--no_hflip', + action='store_true', + help='If true holizontal flipping is not performed.') + parser.add_argument('--colorjitter', + action='store_true', + help='If true colorjitter is performed.') + parser.add_argument('--train_t_crop', + default='random', + type=str, + help=('Temporal cropping method in training. ' + 'random is uniform. ' + '(random | center)')) + parser.add_argument('--learning_rate', + default=0.1, + type=float, + help=('Initial learning rate' + '(divided by 10 while training by lr scheduler)')) + parser.add_argument('--momentum', default=0.9, type=float, help='Momentum') + parser.add_argument('--dampening', + default=0.0, + type=float, + help='dampening of SGD') + parser.add_argument('--weight_decay', + default=1e-3, + type=float, + help='Weight Decay') + parser.add_argument('--mean_dataset', + default='kinetics', + type=str, + help=('dataset for mean values of mean subtraction' + '(activitynet | kinetics | 0.5)')) + parser.add_argument('--no_mean_norm', + action='store_true', + help='If true, inputs are not normalized by mean.') + parser.add_argument( + '--no_std_norm', + action='store_true', + help='If true, inputs are not normalized by standard deviation.') + parser.add_argument( + '--value_scale', + default=1, + type=int, + help= + 'If 1, range of inputs is [0-1]. If 255, range of inputs is [0-255].') + parser.add_argument('--nesterov', + action='store_true', + help='Nesterov momentum') + parser.add_argument('--optimizer', + default='sgd', + type=str, + help='Currently only support SGD') + parser.add_argument('--lr_scheduler', + default='multistep', + type=str, + help='Type of LR scheduler (multistep | plateau)') + parser.add_argument( + '--multistep_milestones', + default=[50, 100, 150], + type=int, + nargs='+', + help='Milestones of LR scheduler. See documentation of MultistepLR.') + parser.add_argument( + '--overwrite_milestones', + action='store_true', + help='If true, overwriting multistep_milestones when resuming training.' + ) + parser.add_argument( + '--plateau_patience', + default=10, + type=int, + help='Patience of LR scheduler. See documentation of ReduceLROnPlateau.' + ) + parser.add_argument('--batch_size', + default=128, + type=int, + help='Batch Size') + parser.add_argument( + '--inference_batch_size', + default=0, + type=int, + help='Batch Size for inference. 0 means this is the same as batch_size.' + ) + parser.add_argument( + '--batchnorm_sync', + action='store_true', + help='If true, SyncBatchNorm is used instead of BatchNorm.') + parser.add_argument('--n_epochs', + default=200, + type=int, + help='Number of total epochs to run') + parser.add_argument('--n_val_samples', + default=3, + type=int, + help='Number of validation samples for each activity') + parser.add_argument('--resume_path', + default=None, + type=Path, + help='Save data (.pth) of previous training') + parser.add_argument('--no_train', + action='store_true', + help='If true, training is not performed.') + parser.add_argument('--no_val', + action='store_true', + help='If true, validation is not performed.') + parser.add_argument('--inference', + action='store_true', + help='If true, inference is performed.') + parser.add_argument('--inference_subset', + default='val', + type=str, + help='Used subset in inference (train | val | test)') + parser.add_argument('--inference_stride', + default=16, + type=int, + help='Stride of sliding window in inference.') + parser.add_argument( + '--inference_crop', + default='center', + type=str, + help=('Cropping method in inference. (center | nocrop)' + 'When nocrop, fully convolutional inference is performed,' + 'and mini-batch consists of clips of one video.')) + parser.add_argument( + '--inference_no_average', + action='store_true', + help='If true, outputs for segments in a video are not averaged.') + parser.add_argument('--no_cuda', + action='store_true', + help='If true, cuda is not used.') + parser.add_argument('--n_threads', + default=4, + type=int, + help='Number of threads for multi-thread loading') + parser.add_argument('--checkpoint', + default=10, + type=int, + help='Trained model is saved at every this epochs.') + parser.add_argument( + '--model', + default='resnet', + type=str, + help= + '(resnet | resnet2p1d | preresnet | wideresnet | resnext | densenet | ') + parser.add_argument('--model_depth', + default=18, + type=int, + help='Depth of resnet (10 | 18 | 34 | 50 | 101)') + parser.add_argument('--conv1_t_size', + default=7, + type=int, + help='Kernel size in t dim of conv1.') + parser.add_argument('--conv1_t_stride', + default=1, + type=int, + help='Stride in t dim of conv1.') + parser.add_argument('--no_max_pool', + action='store_true', + help='If true, the max pooling after conv1 is removed.') + parser.add_argument('--resnet_shortcut', + default='B', + type=str, + help='Shortcut type of resnet (A | B)') + parser.add_argument( + '--resnet_widen_factor', + default=1.0, + type=float, + help='The number of feature maps of resnet is multiplied by this value') + parser.add_argument('--wide_resnet_k', + default=2, + type=int, + help='Wide resnet k') + parser.add_argument('--resnext_cardinality', + default=32, + type=int, + help='ResNeXt cardinality') + parser.add_argument('--input_type', + default='rgb', + type=str, + help='(rgb | flow)') + parser.add_argument('--manual_seed', + default=1, + type=int, + help='Manually set random seed') + parser.add_argument('--accimage', + action='store_true', + help='If true, accimage is used to load images.') + parser.add_argument('--output_topk', + default=5, + type=int, + help='Top-k scores are saved in json file.') + parser.add_argument('--file_type', + default='jpg', + type=str, + help='(jpg | hdf5)') + parser.add_argument('--tensorboard', + action='store_true', + help='If true, output tensorboard log file.') + parser.add_argument( + '--distributed', + action='store_true', + help='Use multi-processing distributed training to launch ' + 'N processes per node, which has N GPUs.') + parser.add_argument('--dist_url', + default='tcp://127.0.0.1:23456', + type=str, + help='url used to set up distributed training') + parser.add_argument('--world_size', + default=-1, + type=int, + help='number of nodes for distributed training') + if len(sys.argv) == 1: + parser.print_help() + return parser.parse_args('') diff --git a/autovideo/recognition/R2p1D/utils.py b/autovideo/recognition/R2p1D/utils.py new file mode 100644 index 0000000..1d4738b --- /dev/null +++ b/autovideo/recognition/R2p1D/utils.py @@ -0,0 +1,97 @@ +import csv +import random +from functools import partialmethod + +import torch +import numpy as np +from sklearn.metrics import precision_recall_fscore_support + + +class AverageMeter(object): + """Computes and stores the average and current value""" + + def __init__(self): + self.reset() + + def reset(self): + self.val = 0 + self.avg = 0 + self.sum = 0 + self.count = 0 + + def update(self, val, n=1): + self.val = val + self.sum += val * n + self.count += n + self.avg = self.sum / self.count + + +class Logger(object): + + def __init__(self, path, header): + self.log_file = path.open('w') + self.logger = csv.writer(self.log_file, delimiter='\t') + + self.logger.writerow(header) + self.header = header + + def __del(self): + self.log_file.close() + + def log(self, values): + write_values = [] + for col in self.header: + assert col in values + write_values.append(values[col]) + + self.logger.writerow(write_values) + self.log_file.flush() + + +def calculate_accuracy(outputs, targets): + with torch.no_grad(): + batch_size = targets.size(0) + + _, pred = outputs.topk(1, 1, largest=True, sorted=True) + pred = pred.t() + correct = pred.eq(targets.view(1, -1)) + n_correct_elems = correct.float().sum().item() + + return n_correct_elems / batch_size + + +def calculate_precision_and_recall(outputs, targets, pos_label=1): + with torch.no_grad(): + _, pred = outputs.topk(1, 1, largest=True, sorted=True) + precision, recall, _, _ = precision_recall_fscore_support( + targets.view(-1, 1).cpu().numpy(), + pred.cpu().numpy()) + + return precision[pos_label], recall[pos_label] + + +def worker_init_fn(worker_id): + torch_seed = torch.initial_seed() + + random.seed(torch_seed + worker_id) + + if torch_seed >= 2**32: + torch_seed = torch_seed % 2**32 + np.random.seed(torch_seed + worker_id) + + +def get_lr(optimizer): + lrs = [] + for param_group in optimizer.param_groups: + lr = float(param_group['lr']) + lrs.append(lr) + + return max(lrs) + + +def partialclass(cls, *args, **kwargs): + + class PartialClass(cls): + __init__ = partialmethod(cls.__init__, *args, **kwargs) + + return PartialClass \ No newline at end of file diff --git a/autovideo/recognition/c3d_primitive.py b/autovideo/recognition/c3d_primitive.py new file mode 100644 index 0000000..5e008da --- /dev/null +++ b/autovideo/recognition/c3d_primitive.py @@ -0,0 +1,400 @@ +import os +import warnings +import cv2 +import numpy as np +import torch +import torch.nn as nn +import typing +import uuid +from urllib.parse import urlparse +from d3m import container, utils as d3m_utils +from d3m.metadata import base as metadata_base, hyperparams +from d3m.primitive_interfaces import base +from d3m.primitive_interfaces.base import CallResult +from d3m.primitive_interfaces.featurization import FeaturizationTransformerPrimitiveBase +from torch.autograd import Variable +from torch.nn.init import normal, constant +from torch.hub import load_state_dict_from_url +from torchvision import transforms +from PIL import Image +import torchvision.models as models +from autovideo.base.supervised_base import SupervisedParamsBase, SupervisedHyperparamsBase, SupervisedPrimitiveBase +from autovideo.utils import wrap_predictions, construct_primitive_metadata, compute_accuracy, make_predictions, get_frame_list, get_video_loader, adjust_learning_rate, logger + +pretrained_url = "https://drive.google.com/u/1/uc?export=download&confirm=Z7Yt&id=19NWziHWh1LgCcHU34geoKwYezAogv9fX" + +__all__ = ('C3DPrimitive',) +Inputs = container.DataFrame +Outputs = container.DataFrame + +class Params(SupervisedParamsBase): + pass + +class Hyperparams(SupervisedHyperparamsBase): + num_workers = hyperparams.Hyperparameter[int]( + semantic_types=['https://metadata.datadrivendiscovery.org/types/ResourcesUseParameter'], + default=2,#4 + description='The number of subprocesses to use for data loading. 0 means that the data will be loaded in the ' + 'main process.' + ) + batch_size = hyperparams.Hyperparameter[int]( + default=2, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The batch size of training" + ) + epochs = hyperparams.Hyperparameter[int]( + default=50, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="How many epochs to be trained" + ) + learning_rate = hyperparams.Hyperparameter[float]( + default=0.01, #1e-3 + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The learning rate of the optimizer" + ) + momentum = hyperparams.Hyperparameter[float]( + default=0.9, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The momentum of the optimizer" + ) + weight_decay = hyperparams.Hyperparameter[float]( + default=1e-7, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The learning rate of the optimizer" + ) + num_segments = hyperparams.Hyperparameter[int]( + default=3, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The number of segments of frames in each video per training loop" + ) + valid_ratio = hyperparams.Hyperparameter[float]( + default=0.05, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The ratio of validation data" + ) + modality = hyperparams.Enumeration( + values=['RGB', 'RGBDiff', 'Flow'], + default='RGB', + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="The modality of input data to be used for the model", + ) + num_steps_per_update = hyperparams.Hyperparameter[int]( + default=4, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The num_steps to update weights" + ) + + + +class C3DPrimitive(SupervisedPrimitiveBase[Inputs, Outputs, Params, Hyperparams]): + """ + Implementation of C3D pre-trained on UCF101 and HMDB51 ?? + """ + metadata = construct_primitive_metadata('recognition', 'c3d') + + def get_params(self) -> Params: + return super().get_params() + + def set_params(self, *, params: Params) -> None: + super().set_params(params=params) + + def _init_model(self, pretrained): + """ + Initialize the model. Loading the weights if pretrained is True + """ + print("Loading C3D") + self.model = C3D(51, pretrained) + logger.info("Loaded C3D Model") + self.model = self.model.to(self.device) + + def _fit(self, *, timeout: float = None, iterations: int = None): + """ + Training + """ + #Randomly split 5% data for validation + frame_list = np.array(get_frame_list(self._media_dir, self._inputs, self._outputs)) + idx = np.array([i for i in range(len(frame_list))]) + np.random.shuffle(idx) + train_idx, valid_idx = idx[:int(len(idx)*(1-self.hyperparams['valid_ratio']))], idx[int(len(idx)*(1-self.hyperparams['valid_ratio'])):] + train_list, valid_list = frame_list[train_idx], frame_list[valid_idx] + + # Get optimizer and loss + # optimizer = torch.optim.SGD(self.model.get_optim_policies(self.hyperparams['learning_rate']), + # self.hyperparams['learning_rate'], + # momentum=self.hyperparams['momentum'], + # weight_decay=self.hyperparams['weight_decay']) + # criterion = nn.CrossEntropyLoss() + # #Scheduler divides the lr by 10 every 10 epochs + # # scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1) + + optimizer = torch.optim.Adam(self.model.parameters(), + lr=self.hyperparams['learning_rate'], + betas=(0.5, 0.999), + weight_decay=self.hyperparams['weight_decay']) + criterion = torch.nn.CrossEntropyLoss() + + + #Create Dataloaders + train_loader = get_video_loader(video_list=train_list, + crop_size=self.model.crop_size, + scale_size=self.model.scale_size, + input_mean=self.model.input_mean, + input_std=self.model.input_std, + train_augmentation=True, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=True, + input_format="NCTHW") + valid_loader = get_video_loader(video_list=valid_list, + crop_size=self.model.crop_size, + scale_size=self.model.scale_size, + input_mean=self.model.input_mean, + input_std=self.model.input_std, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=False, + input_format="NCTHW") + + best_valid_acc = 0.0 + tmp_file_path = os.path.join(self.tmp_dir, str(uuid.uuid4())) + + total_steps = self.hyperparams['epochs'] * len(train_loader) + num_steps_per_update = self.hyperparams['num_steps_per_update'] + s1, s2 = 0.125 / num_steps_per_update, 0.375 / num_steps_per_update + lr_steps = [int(total_steps * s1), int(total_steps * s2)] #Steps after which lr decays by a factor of 10 + lr_sched = torch.optim.lr_scheduler.MultiStepLR(optimizer, lr_steps) + + + #Training Loop + for epoch in range(self.hyperparams['epochs']): + #Iterate over a batch of videos with num_segments in each video + + num_iter = 0 + self.model.train() + + for i, (inputs,target) in enumerate(train_loader): + num_iter += 1 + + inputs, target = inputs.to(self.device), target.to(self.device) + #inputs = Variable(inputs, requires_grad=True).to(self.device) + #target = target.to(self.device) + output = self.model(inputs) + loss = criterion(output, target) + #optimizer.zero_grad() + loss /= num_steps_per_update + loss.backward() + #optimizer.step() + + if num_iter == num_steps_per_update: + num_iter = 0 + optimizer.step() + optimizer.zero_grad() + lr_sched.step() + + + # Evaluation + self.model.eval() + train_acc = compute_accuracy(train_loader, self.model, self.device) + valid_acc = compute_accuracy(valid_loader, self.model, self.device) + logger.info('Epoch {}, training accuracy {:5.4f}, validation accuracy {:5.4f}'.format(epoch, train_acc*100, valid_acc*100)) + #Save best model + if valid_acc >= best_valid_acc: + best_valid_acc = valid_acc + torch.save(self.model.state_dict(), tmp_file_path) + + # Load the best model with the highest accuracy on validation data + self.model.load_state_dict(torch.load(tmp_file_path)) + self.model.eval() + os.remove(tmp_file_path) + + def produce(self, *, inputs: container.DataFrame, timeout: float=None, iterations: int=None) -> CallResult[container.DataFrame]: + """ + make the predictions + """ + #Create DataLoader + media_dir = urlparse(inputs.metadata.query_column(0)['location_base_uris'][0]).path + test_list = get_frame_list(media_dir, inputs, test_mode=True) + test_loader = get_video_loader(video_list=test_list, + crop_size=self.model.crop_size, + scale_size=self.model.scale_size, + input_mean=self.model.input_mean, + input_std=self.model.input_std, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=False, + test_mode=True, + input_format="NCTHW") + + # Make predictions + self.model.eval() + preds = make_predictions(test_loader, self.model, self.device) + outputs = wrap_predictions(inputs, preds, self.__class__.metadata.query()['name']) + return CallResult(outputs) + + +class C3D(nn.Module): + """ + The C3D network. + """ + def __init__(self, num_classes, pretrained=False): + self._prepare_base_model() + super(C3D, self).__init__() + + self.conv1 = nn.Conv3d(3, 64, kernel_size=(3, 3, 3), padding=(1, 1, 1)) + self.pool1 = nn.MaxPool3d(kernel_size=(1, 2, 2), stride=(1, 2, 2)) + + self.conv2 = nn.Conv3d(64, 128, kernel_size=(3, 3, 3), padding=(1, 1, 1)) + self.pool2 = nn.MaxPool3d(kernel_size=(2, 2, 2), stride=(2, 2, 2)) + + self.conv3a = nn.Conv3d(128, 256, kernel_size=(3, 3, 3), padding=(1, 1, 1)) + self.conv3b = nn.Conv3d(256, 256, kernel_size=(3, 3, 3), padding=(1, 1, 1)) + self.pool3 = nn.MaxPool3d(kernel_size=(2, 2, 2), stride=(2, 2, 2)) + + self.conv4a = nn.Conv3d(256, 512, kernel_size=(3, 3, 3), padding=(1, 1, 1)) + self.conv4b = nn.Conv3d(512, 512, kernel_size=(3, 3, 3), padding=(1, 1, 1)) + self.pool4 = nn.MaxPool3d(kernel_size=(2, 2, 2), stride=(2, 2, 2)) + + self.conv5a = nn.Conv3d(512, 512, kernel_size=(3, 3, 3), padding=(1, 1, 1)) + self.conv5b = nn.Conv3d(512, 512, kernel_size=(3, 3, 3), padding=(1, 1, 1)) + self.pool5 = nn.MaxPool3d(kernel_size=(2, 2, 2), stride=(2, 2, 2), padding=(0, 1, 1)) + + self.fc6 = nn.Linear(8192, 4096) + self.fc7 = nn.Linear(4096, 4096) + self.fc8 = nn.Linear(4096, num_classes) + + self.dropout = nn.Dropout(p=0.5) + + self.relu = nn.ReLU() + + self.__init_weight() + + if pretrained: + self.__load_pretrained_weights() + + def forward(self, x): + + x = self.relu(self.conv1(x)) + x = self.pool1(x) + + x = self.relu(self.conv2(x)) + x = self.pool2(x) + + x = self.relu(self.conv3a(x)) + x = self.relu(self.conv3b(x)) + x = self.pool3(x) + + x = self.relu(self.conv4a(x)) + x = self.relu(self.conv4b(x)) + x = self.pool4(x) + + x = self.relu(self.conv5a(x)) + x = self.relu(self.conv5b(x)) + x = self.pool5(x) + + x = x.view(-1, 8192) + x = self.relu(self.fc6(x)) + x = self.dropout(x) + x = self.relu(self.fc7(x)) + x = self.dropout(x) + + logits = self.fc8(x) + + return logits + + def __load_pretrained_weights(self): + """Initialiaze network.""" + corresp_name = { + # Conv1 + "features.0.weight": "conv1.weight", + "features.0.bias": "conv1.bias", + # Conv2 + "features.3.weight": "conv2.weight", + "features.3.bias": "conv2.bias", + # Conv3a + "features.6.weight": "conv3a.weight", + "features.6.bias": "conv3a.bias", + # Conv3b + "features.8.weight": "conv3b.weight", + "features.8.bias": "conv3b.bias", + # Conv4a + "features.11.weight": "conv4a.weight", + "features.11.bias": "conv4a.bias", + # Conv4b + "features.13.weight": "conv4b.weight", + "features.13.bias": "conv4b.bias", + # Conv5a + "features.16.weight": "conv5a.weight", + "features.16.bias": "conv5a.bias", + # Conv5b + "features.18.weight": "conv5b.weight", + "features.18.bias": "conv5b.bias", + # fc6 + "classifier.0.weight": "fc6.weight", + "classifier.0.bias": "fc6.bias", + # fc7 + "classifier.3.weight": "fc7.weight", + "classifier.3.bias": "fc7.bias", + } + + p_dict = torch.load('/home/anmoll/autovideo/autovideo/c3d-pretrained.pth') + #p_dict = load_state_dict_from_url(pretrained_url) + s_dict = self.state_dict() + for name in p_dict: + if name not in corresp_name: + continue + s_dict[corresp_name[name]] = p_dict[name] + self.load_state_dict(s_dict) + + def __init_weight(self): + for m in self.modules(): + if isinstance(m, nn.Conv3d): + torch.nn.init.kaiming_normal_(m.weight) + elif isinstance(m, nn.BatchNorm3d): + m.weight.data.fill_(1) + m.bias.data.zero_() + + def get_optim_policies(self, lr): + return [{'params': get_1x_lr_params(self), 'lr': lr}, + {'params': get_10x_lr_params(self), 'lr': lr * 10}] + + def _prepare_base_model(self): + self.crop_size = 112 + self.scale_size = 256 + self.input_mean = [0.43216, 0.394666, 0.37645] + self.input_std = [0.22803, 0.22145, 0.216989] + +def get_1x_lr_params(model): + """ + This generator returns all the parameters for conv and two fc layers of the net. + """ + b = [model.conv1, model.conv2, model.conv3a, model.conv3b, model.conv4a, model.conv4b, + model.conv5a, model.conv5b, model.fc6, model.fc7] + for i in range(len(b)): + for k in b[i].parameters(): + if k.requires_grad: + yield k + +def get_10x_lr_params(model): + """ + This generator returns all the parameters for the last fc layer of the net. + """ + b = [model.fc8] + for j in range(len(b)): + for k in b[j].parameters(): + if k.requires_grad: + yield k + + +'''Reference: https://github.com/jfzhang95/pytorch-video-recognition''' + +""" +Test command to check this +python3 -m d3m runtime --volume /tmp/cmu/pretrained_files fit-produce -p pipeline.yml -r /home/grads/z/zaid.bhat1234/cleand3m/datasets/video_sample/TRAIN/problem_TRAIN/problemDoc.json -i /home/grads/z/zaid.bhat1234/cleand3m/datasets/video_sample/TRAIN/dataset_TRAIN/datasetDoc.json -t /home/grads/z/zaid.bhat1234/cleand3m/datasets/video_sample/TEST/dataset_TEST/datasetDoc.json -o results.csv +""" + diff --git a/autovideo/recognition/eco_full_primitive.py b/autovideo/recognition/eco_full_primitive.py new file mode 100644 index 0000000..b1e3d3e --- /dev/null +++ b/autovideo/recognition/eco_full_primitive.py @@ -0,0 +1,393 @@ +import logging +import os +import requests +import math +import numpy as np +import uuid +from urllib.parse import urlparse + +from d3m import container +from d3m.metadata import hyperparams +from d3m.primitive_interfaces.base import CallResult + +import torch +from torch import nn +from torch.nn.init import normal, constant, constant_, kaiming_normal_, xavier_uniform_ +from torch.hub import load_state_dict_from_url +import torchvision + +from autovideo.base.supervised_base import SupervisedParamsBase, SupervisedHyperparamsBase, SupervisedPrimitiveBase + +from autovideo.utils import wrap_predictions, construct_primitive_metadata, compute_accuracy, make_predictions, \ + get_frame_list, get_video_loader, adjust_learning_rate, logger + + +from .eco_primitive import ECO + +import autovideo +# ROOT_PATH = autovideo.__path__[0] +# pretrained_file_id = "17SnoxH8tkuUCvW-4ifa4Hk7ITm93nMqI" +# destination = os.path.join(ROOT_PATH, 'model_weights', 'eco_lite_rgb_16F_kinetics_v3.pth.tar') + +pretrained_url_finetune= "https://drive.google.com/file/d/11cVEZHPaNv6Bl5eTkvBA-JvE0arpUEIe/view?usp=sharing" +pretrained_url_both_2d = "https://drive.google.com/file/d/1ITB2Q8IBPI9VfqBD6xdqs0fXC3N-bKB7/view?usp=sharing" +pretrained_url_both_3d = "https://drive.google.com/file/d/1XXwuEpn1t-AbsIg5xDXBPOqS37QY0Y9X/view?usp=sharing" + +pretrained_path_finetune = "weights/eco_lite_rgb_16F_kinetics_v3.pth.tar" +pretrained_path_2d = "weights/bninception_rgb_kinetics_init-d4ee618d3399.pth" +pretrained_path_3d = "weights/C3DResNet18_rgb_16F_kinetics_v1.pth.tar" + +__all__ = ('ECOfullPrimitive') +Inputs = container.DataFrame +Outputs = container.DataFrame + + +class Params(SupervisedParamsBase): + pass + +class Hyperparams(SupervisedHyperparamsBase): + num_workers = hyperparams.Hyperparameter[int]( + semantic_types=['https://metadata.datadrivendiscovery.org/types/ResourcesUseParameter'], + default=2, + description='The number of subprocesses to use for data loading. 0 means that the data will be loaded in the ' + 'main process.' + ) + batch_size = hyperparams.Hyperparameter[int]( + default=2, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The batch size of training" + ) + epochs = hyperparams.Hyperparameter[int]( + default=100, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="How many epochs to be trained" + ) + learning_rate = hyperparams.Hyperparameter[float]( + default=0.0001, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The learning rate of the optimizer" + ) + # momentum = hyperparams.Hyperparameter[float]( + # default=0.9, + # semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + # description="The momentum of the optimizer" + # ) + weight_decay = hyperparams.Hyperparameter[float]( + default=5e-4, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The learning rate of the optimizer" + ) + num_segments = hyperparams.Hyperparameter[int]( + default=3, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The number of segments of frames in each video per training loop" + ) + valid_ratio = hyperparams.Hyperparameter[float]( + default=0.05, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The ratio of validation data" + ) + modality = hyperparams.Enumeration( + values=['RGB', 'RGBDiff', 'Flow'], + default='RGB', + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="The modality of input data to be used for the model", + ) + + +class ECOFullPrimitive(SupervisedPrimitiveBase[Inputs, Outputs, Params, Hyperparams]): + """ + Implementation of ECOfull + """ + metadata = construct_primitive_metadata('recognition', 'eco_full') + + def get_params(self) -> Params: + return super().get_params() + + def set_params(self, *, params: Params) -> None: + super().set_params(params=params) + + def _fit(self, *, timeout: float = None, iterations: int = None): + """ + Training + """ + # Randomly split 5% data for validation + #root = logging.getLogger() + frame_list = np.array(get_frame_list(self._media_dir, self._inputs, self._outputs)) + idx = np.array([i for i in range(len(frame_list))]) + np.random.shuffle(idx) + train_idx, valid_idx = idx[:int(len(idx) * (1 - self.hyperparams['valid_ratio']))], idx[int( + len(idx) * (1 - self.hyperparams['valid_ratio'])):] + train_list, valid_list = frame_list[train_idx], frame_list[valid_idx] + + # Get optimizer and loss + # optimizer = torch.optim.SGD(self.model.get_optim_policies(), + # self.hyperparams['learning_rate'], + # momentum=self.hyperparams['momentum'], + # weight_decay=self.hyperparams['weight_decay']) + optimizer = torch.optim.Adam(self.model.get_optim_policies(), + self.hyperparams['learning_rate'], + # momentum=self.hyperparams['momentum'], + weight_decay=self.hyperparams['weight_decay']) + criterion = nn.CrossEntropyLoss() + + # Create Dataloaders + train_loader = get_video_loader(video_list=train_list, + crop_size=self.model.crop_size, + scale_size=self.model.scale_size, + input_mean=self.model.input_mean, + input_std=self.model.input_std, + train_augmentation=True, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=True) + valid_loader = get_video_loader(video_list=valid_list, + crop_size=self.model.crop_size, + scale_size=self.model.scale_size, + input_mean=self.model.input_mean, + input_std=self.model.input_std, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=False) + + #root.error('hyperparams {}'.format(self.hyperparams)) + #root.error('ECO-full') + best_valid_acc = 0.0 + lr_steps = [30, 60] # Steps after which lr decays by a factor of 10 + tmp_file_path = os.path.join(self.tmp_dir, str(uuid.uuid4())) + #root.error('tmp: {}'.format(tmp_file_path)) + + # Training Loop + for epoch in range(self.hyperparams['epochs']): + adjust_learning_rate(self.hyperparams['learning_rate'], + self.hyperparams['weight_decay'], + optimizer, + epoch, + lr_steps) # lr decay + # Iterate over a batch of videos with num_segments in each video + self.model.train() + for i, (inputs, target) in enumerate(train_loader): + optimizer.zero_grad() + inputs, target = inputs.to(self.device), target.to(self.device) + output = self.model(inputs) + loss = criterion(output, target) + #if i%10 ==0: + # root.error('train {:03d} loss {:5.4f}'.format(i, loss.item())) + loss.backward() + optimizer.step() + + # Evaluation + self.model.eval() + print('computing train_acc:') + train_acc = compute_accuracy(train_loader, self.model, self.device) + print('computing valid_acc:') + valid_acc = compute_accuracy(valid_loader, self.model, self.device) + logger.info('Epoch {}, training accuracy {:5.4f}, validation accuracy {:5.4f}'.format(epoch, train_acc*100, valid_acc*100)) + #root.error( + # 'Epoch {}: training accuracy: {:5.4f}, validation accuracy: {:5.4f}'.format(epoch, train_acc * 100, valid_acc * 100)) + # Save best model + if valid_acc >= best_valid_acc: + best_valid_acc = valid_acc + torch.save(self.model.state_dict(), tmp_file_path) + + # Load the best model with the highest accuracy on validation data + self.model.load_state_dict(torch.load(tmp_file_path)) + self.model.eval() + #print('fit', self.model.new_fc.weight) + os.remove(tmp_file_path) + + def _init_model(self, pretrained): + """ + Initialize the model. Loading the weights if pretrained is True + """ + # Load ECO Full model + + if pretrained: + self.model = ECO(400, self.hyperparams['num_segments'], 'both', self.hyperparams['modality'], + base_model='ECOfull', consensus_type='identity', dropout=0.8, partial_bn=False) + + else: + self.model = ECO(400, self.hyperparams['num_segments'], 'scratch', self.hyperparams['modality'], + base_model='ECOfull', consensus_type='identity', dropout=0.8, partial_bn=False) + + + model_dict = self.model.state_dict() + new_state_dict = init_ECOfull(model_dict, self.model.pretrained_parts) + + un_init_dict_keys = [k for k in model_dict.keys() if k not in new_state_dict] + + print("\n------------------------------------") + + for k in un_init_dict_keys: + new_state_dict[k] = torch.DoubleTensor(model_dict[k].size()).zero_() + if 'weight' in k: + if 'bn' in k: + print("{} init as: 1".format(k)) + constant_(new_state_dict[k], 1) + else: + print("{} init as: kaiming normal".format(k)) + kaiming_normal_(new_state_dict[k]) + elif 'bias' in k: + print("{} init as: 0".format(k)) + constant_(new_state_dict[k], 0) + + print("------------------------------------") + + num_classes = len(np.unique(self._outputs.values)) + self.model.load_state_dict(new_state_dict) + + self.model.new_fc = nn.Linear(1536, num_classes) + + + + self.model = self.model.to(self.device) + + def produce(self, *, inputs: container.DataFrame, timeout: float = None, iterations: int = None) -> CallResult[ + container.DataFrame]: + """ + make the predictions + """ + # Create DataLoader + media_dir = urlparse(inputs.metadata.query_column(0)['location_base_uris'][0]).path + test_list = get_frame_list(media_dir, inputs, test_mode=True) + test_loader = get_video_loader(video_list=test_list, + crop_size=self.model.crop_size, + scale_size=self.model.scale_size, + input_mean=self.model.input_mean, + input_std=self.model.input_std, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=False, + test_mode=True) + + # Make predictions + self.model.eval() + + preds = make_predictions(test_loader, self.model, self.device) + outputs = wrap_predictions(inputs, preds, self.__class__.metadata.query()['name']) + + return CallResult(outputs) + + +def init_ECOfull(model_dict, pretrained_parts): + + if pretrained_parts == "scratch": + + new_state_dict = {} + + elif pretrained_parts == "finetune": + pretrained_dict = torch.load(pretrained_path_finetune) + print(("=> loading model-finetune-url: '{}'".format(pretrained_path_finetune))) + + new_state_dict = {k[7:]: v for k, v in pretrained_dict['state_dict'].items() if + (k[7:] in model_dict) and (v.size() == model_dict[k[7:]].size())} + print("*" * 50) + print("Start finetuning ..") + return new_state_dict + + elif pretrained_parts == "both": + + # Load the 2D net pretrained model + # weight_url_2d = 'https://yjxiong.blob.core.windows.net/ssn-models/bninception_rgb_kinetics_init-d4ee618d3399.pth' + pretrained_dict_2d = torch.load(pretrained_path_2d) + print(("=> loading model - 2D net-url: '{}'".format(pretrained_path_2d))) + + # Load the 3D net pretrained model + # pretrained_file_id_3d="1J2mV0Kl9pWOK0FJ23ApHnJHQ3eq76D8a" + # destination_3d = "C3DResNet18_rgb_16F_kinetics_v1.pth.tar" + # download_file_from_google_drive(pretrained_file_id_3d, destination_3d) + pretrained_dict_3d = torch.load(pretrained_path_3d) + print(("=> loading model - 3D net-url: '{}'".format(pretrained_path_3d))) + + new_state_dict = {"base_model." + k: v for k, v in pretrained_dict_2d['state_dict'].items() if + "base_model." + k in model_dict} + + for k, v in pretrained_dict_3d['state_dict'].items(): + if (k[7:] in model_dict) and (v.size() == model_dict[k[7:]].size()): + new_state_dict[k[7:]] = v + + res3a_2_weight_chunk = torch.chunk(pretrained_dict_3d["state_dict"]["module.base_model.res3a_2.weight"], 4, 1) + new_state_dict["base_model.res3a_2.weight"] = torch.cat( + (res3a_2_weight_chunk[0], res3a_2_weight_chunk[1], res3a_2_weight_chunk[2]), 1) + return new_state_dict + + + +class Identity(torch.nn.Module): + def forward(self, input): + return input + + +class SegmentConsensus(torch.nn.Module): + def __init__(self, consensus_type, dim=1): + super(SegmentConsensus, self).__init__() + self.consensus_type = consensus_type + self.dim = dim + self.shape = None + + def forward(self, input_tensor): + self.shape = input_tensor.size() + if self.consensus_type == 'avg': + output = input_tensor.mean(dim=self.dim, keepdim=True) + elif self.consensus_type == 'identity': + output = input_tensor + else: + output = None + + return output + + def backward(self, grad_output): + if self.consensus_type == 'avg': + grad_in = grad_output.expand(self.shape) / float(self.shape[self.dim]) + elif self.consensus_type == 'identity': + grad_in = grad_output + else: + grad_in = None + + return grad_in + + +class ConsensusModule(torch.nn.Module): + def __init__(self, consensus_type, dim=1): + super(ConsensusModule, self).__init__() + self.consensus_type = consensus_type if consensus_type != 'rnn' else 'identity' + self.dim = dim + + def forward(self, input): + return SegmentConsensus(self.consensus_type, self.dim)(input) +import requests + + +def download_file_from_google_drive(id, destination): + def get_confirm_token(response): + for key, value in response.cookies.items(): + if key.startswith('download_warning'): + return value + + return None + + def save_response_content(response, destination): + CHUNK_SIZE = 32768 + + with open(destination, "wb") as f: + for chunk in response.iter_content(CHUNK_SIZE): + if chunk: # filter out keep-alive new chunks + f.write(chunk) + + URL = "https://docs.google.com/uc?export=download" + + session = requests.Session() + + response = session.get(URL, params = { 'id' : id }, stream = True) + token = get_confirm_token(response) + + if token: + params = { 'id' : id, 'confirm' : token } + response = session.get(URL, params = params, stream = True) + save_response_content(response, destination) diff --git a/autovideo/recognition/eco_primitive.py b/autovideo/recognition/eco_primitive.py new file mode 100644 index 0000000..fda2ea2 --- /dev/null +++ b/autovideo/recognition/eco_primitive.py @@ -0,0 +1,861 @@ +import os +import requests +import math +import numpy as np +import uuid +from urllib.parse import urlparse + +from d3m import container +from d3m.metadata import hyperparams +from d3m.primitive_interfaces.base import CallResult + +import torch +from torch import nn +from torch.nn.init import normal, constant, constant_, kaiming_normal_, xavier_uniform_ +from torch.hub import load_state_dict_from_url +import torchvision + +from autovideo.base.supervised_base import SupervisedParamsBase, SupervisedHyperparamsBase, SupervisedPrimitiveBase + +from autovideo.utils.transforms import * +from autovideo.utils import wrap_predictions, construct_primitive_metadata, compute_accuracy, make_predictions, \ + get_frame_list, get_video_loader, adjust_learning_rate, logger + +import autovideo +# ROOT_PATH = autovideo.__path__[0] +# pretrained_file_id = "17SnoxH8tkuUCvW-4ifa4Hk7ITm93nMqI" +# destination = os.path.join(ROOT_PATH, 'model_weights', 'eco_lite_rgb_16F_kinetics_v3.pth.tar') +pretrained_url_finetune= "https://drive.google.com/file/d/11cVEZHPaNv6Bl5eTkvBA-JvE0arpUEIe/view?usp=sharing" +pretrained_url_both_2d = "https://drive.google.com/file/d/1ITB2Q8IBPI9VfqBD6xdqs0fXC3N-bKB7/view?usp=sharing" +pretrained_url_both_3d = "https://drive.google.com/file/d/1XXwuEpn1t-AbsIg5xDXBPOqS37QY0Y9X/view?usp=sharing" + +pretrained_path_finetune = "weights/eco_lite_rgb_16F_kinetics_v3.pth.tar" +pretrained_path_2d = "weights/bninception_rgb_kinetics_init-d4ee618d3399.pth" +pretrained_path_3d = "weights/C3DResNet18_rgb_16F_kinetics_v1.pth.tar" + +__all__ = ('ECOPrimitive') +Inputs = container.DataFrame +Outputs = container.DataFrame + + +class Params(SupervisedParamsBase): + pass + +class Hyperparams(SupervisedHyperparamsBase): + num_workers = hyperparams.Hyperparameter[int]( + semantic_types=['https://metadata.datadrivendiscovery.org/types/ResourcesUseParameter'], + default=2, + description='The number of subprocesses to use for data loading. 0 means that the data will be loaded in the ' + 'main process.' + ) + batch_size = hyperparams.Hyperparameter[int]( + default=2, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The batch size of training" + ) + epochs = hyperparams.Hyperparameter[int]( + default=100, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="How many epochs to be trained" + ) + learning_rate = hyperparams.Hyperparameter[float]( + default=0.0001, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The learning rate of the optimizer" + ) + # momentum = hyperparams.Hyperparameter[float]( + # default=0.9, + # semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + # description="The momentum of the optimizer" + # ) + weight_decay = hyperparams.Hyperparameter[float]( + default=5e-4, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The learning rate of the optimizer" + ) + num_segments = hyperparams.Hyperparameter[int]( + default=3, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The number of segments of frames in each video per training loop" + ) + valid_ratio = hyperparams.Hyperparameter[float]( + default=0.05, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The ratio of validation data" + ) + modality = hyperparams.Enumeration( + values=['RGB', 'RGBDiff', 'Flow'], + default='RGB', + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="The modality of input data to be used for the model", + ) + + +class ECOPrimitive(SupervisedPrimitiveBase[Inputs, Outputs, Params, Hyperparams]): + """ + Implementation of ECO + """ + metadata = construct_primitive_metadata('recognition', 'eco') + + def get_params(self) -> Params: + return super().get_params() + + def set_params(self, *, params: Params) -> None: + super().set_params(params=params) + + def _fit(self, *, timeout: float = None, iterations: int = None): + """ + Training + """ + #root = logging.getLogger() + # Randomly split 5% data for validation + frame_list = np.array(get_frame_list(self._media_dir, self._inputs, self._outputs)) + idx = np.array([i for i in range(len(frame_list))]) + np.random.shuffle(idx) + train_idx, valid_idx = idx[:int(len(idx) * (1 - self.hyperparams['valid_ratio']))], idx[int( + len(idx) * (1 - self.hyperparams['valid_ratio'])):] + train_list, valid_list = frame_list[train_idx], frame_list[valid_idx] + + # Get optimizer and loss + # optimizer = torch.optim.SGD(self.model.get_optim_policies(), + # self.hyperparams['learning_rate'], + # momentum=self.hyperparams['momentum'], + # weight_decay=self.hyperparams['weight_decay']) + optimizer = torch.optim.Adam(self.model.get_optim_policies(), + self.hyperparams['learning_rate'], + # momentum=self.hyperparams['momentum'], + weight_decay=self.hyperparams['weight_decay']) + criterion = nn.CrossEntropyLoss() + + # Create Dataloaders + train_loader = get_video_loader(video_list=train_list, + crop_size=self.model.crop_size, + scale_size=self.model.scale_size, + input_mean=self.model.input_mean, + input_std=self.model.input_std, + train_augmentation=True, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=True) + valid_loader = get_video_loader(video_list=valid_list, + crop_size=self.model.crop_size, + scale_size=self.model.scale_size, + input_mean=self.model.input_mean, + input_std=self.model.input_std, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=False) + + #root.error('hyperparams {}'.format(self.hyperparams)) + #root.error('ECO-lite') + best_valid_acc = 0.0 + lr_steps = [30, 60] # Steps after which lr decays by a factor of 10 + + tmp_file_path = os.path.join(self.tmp_dir, str(uuid.uuid4())) + #root.error('tmp: {}'.format(tmp_file_path)) + # Training Loop + for epoch in range(self.hyperparams['epochs']): + adjust_learning_rate(self.hyperparams['learning_rate'], + self.hyperparams['weight_decay'], + optimizer, + epoch, + lr_steps) # lr decay + # Iterate over a batch of videos with num_segments in each video + self.model.train() + for i, (inputs, target) in enumerate(train_loader): + optimizer.zero_grad() + inputs, target = inputs.to(self.device), target.to(self.device) + output = self.model(inputs) + loss = criterion(output, target) + #if i%10 ==0: + # root.error('train {:03d} loss {:5.4f}'.format(i, loss.item())) + loss.backward() + optimizer.step() + + # Evaluation + self.model.eval() + train_acc = compute_accuracy(train_loader, self.model, self.device) + valid_acc = compute_accuracy(valid_loader, self.model, self.device) + logger.info('Epoch {}, training accuracy {:5.4f}, validation accuracy {:5.4f}'.format(epoch, train_acc*100, valid_acc*100)) + #root.error( + # 'Epoch {}: training accuracy: {:5.4f}, validation accuracy: {:5.4f}'.format(epoch, train_acc * 100, valid_acc * 100)) + # Save best model + if valid_acc >= best_valid_acc: + best_valid_acc = valid_acc + torch.save(self.model.state_dict(), tmp_file_path) + + # Load the best model with the highest accuracy on validation data + self.model.load_state_dict(torch.load(tmp_file_path)) + self.model.eval() + os.remove(tmp_file_path) + + def _init_model(self, pretrained): + """ + Initialize the model. Loading the weights if pretrained is True + """ + # Load ECO model + + if pretrained: + self.model = ECO(400, self.hyperparams['num_segments'], 'both', self.hyperparams['modality'], + base_model='ECO', consensus_type='identity', dropout=0.8, partial_bn=False) + + else: + self.model = ECO(400, self.hyperparams['num_segments'], 'scratch', self.hyperparams['modality'], + base_model='ECO', consensus_type='identity', dropout=0.8, partial_bn=False) + + + model_dict = self.model.state_dict() + new_state_dict = init_ECO(model_dict, self.model.pretrained_parts) + + un_init_dict_keys = [k for k in model_dict.keys() if k not in new_state_dict] + print("\n------------------------------------") + + for k in un_init_dict_keys: + new_state_dict[k] = torch.DoubleTensor(model_dict[k].size()).zero_() + if 'weight' in k: + if 'bn' in k: + print("{} init as: 1".format(k)) + constant_(new_state_dict[k], 1) + else: + print("{} init as: kaiming normal".format(k)) + kaiming_normal_(new_state_dict[k]) + elif 'bias' in k: + print("{} init as: 0".format(k)) + constant_(new_state_dict[k], 0) + + print("------------------------------------") + + num_classes = len(np.unique(self._outputs.values)) + self.model.load_state_dict(new_state_dict) + + self.model.new_fc = nn.Linear(512, num_classes) + + + + self.model = self.model.to(self.device) + + def produce(self, *, inputs: container.DataFrame, timeout: float = None, iterations: int = None) -> CallResult[ + container.DataFrame]: + """ + make the predictions + """ + # Create DataLoader + media_dir = urlparse(inputs.metadata.query_column(0)['location_base_uris'][0]).path + test_list = get_frame_list(media_dir, inputs, test_mode=True) + test_loader = get_video_loader(video_list=test_list, + crop_size=self.model.crop_size, + scale_size=self.model.scale_size, + input_mean=self.model.input_mean, + input_std=self.model.input_std, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=False, + test_mode=True) + + # Make predictions + self.model.eval() + preds = make_predictions(test_loader, self.model, self.device) + outputs = wrap_predictions(inputs, preds, self.__class__.metadata.query()['name']) + + return CallResult(outputs) + + +def init_ECO(model_dict, pretrained_parts): + + if pretrained_parts == "scratch": + + new_state_dict = {} + + elif pretrained_parts == "finetune": + download_file_from_google_drive(pretrained_file_id, destination) + pretrained_dict = torch.load(destination) + print(("=> loading model-finetune-url: '{}'".format(destination))) + + new_state_dict = {k[7:]: v for k, v in pretrained_dict['state_dict'].items() if + (k[7:] in model_dict) and (v.size() == model_dict[k[7:]].size())} + print("*" * 50) + print("Start finetuning ..") + return new_state_dict + + elif pretrained_parts == "both": + + # Load the 2D net pretrained model + # weight_url_2d = 'https://yjxiong.blob.core.windows.net/ssn-models/bninception_rgb_kinetics_init-d4ee618d3399.pth' + pretrained_dict_2d = torch.load(pretrained_path_2d) + print(("=> loading model - 2D net-url: '{}'".format(pretrained_path_2d))) + + # Load the 3D net pretrained model + # pretrained_file_id_3d="1J2mV0Kl9pWOK0FJ23ApHnJHQ3eq76D8a" + # destination_3d = "C3DResNet18_rgb_16F_kinetics_v1.pth.tar" + # download_file_from_google_drive(pretrained_file_id_3d, destination_3d) + pretrained_dict_3d = torch.load(pretrained_path_3d) + print(("=> loading model - 3D net-url: '{}'".format(pretrained_path_3d))) + + new_state_dict = {"base_model." + k: v for k, v in pretrained_dict_2d['state_dict'].items() if + "base_model." + k in model_dict} + + for k, v in pretrained_dict_3d['state_dict'].items(): + if (k[7:] in model_dict) and (v.size() == model_dict[k[7:]].size()): + new_state_dict[k[7:]] = v + + res3a_2_weight_chunk = torch.chunk(pretrained_dict_3d["state_dict"]["module.base_model.res3a_2.weight"], 4, 1) + new_state_dict["base_model.res3a_2.weight"] = torch.cat( + (res3a_2_weight_chunk[0], res3a_2_weight_chunk[1], res3a_2_weight_chunk[2]), 1) + return new_state_dict + + + +class Identity(torch.nn.Module): + def forward(self, input): + return input + + +class SegmentConsensus(torch.nn.Module): + def __init__(self, consensus_type, dim=1): + super(SegmentConsensus, self).__init__() + self.consensus_type = consensus_type + self.dim = dim + self.shape = None + + def forward(self, input_tensor): + self.shape = input_tensor.size() + if self.consensus_type == 'avg': + output = input_tensor.mean(dim=self.dim, keepdim=True) + elif self.consensus_type == 'identity': + output = input_tensor + else: + output = None + + return output + + def backward(self, grad_output): + if self.consensus_type == 'avg': + grad_in = grad_output.expand(self.shape) / float(self.shape[self.dim]) + elif self.consensus_type == 'identity': + grad_in = grad_output + else: + grad_in = None + + return grad_in + + +class ConsensusModule(torch.nn.Module): + def __init__(self, consensus_type, dim=1): + super(ConsensusModule, self).__init__() + self.consensus_type = consensus_type if consensus_type != 'rnn' else 'identity' + self.dim = dim + + def forward(self, input): + return SegmentConsensus(self.consensus_type, self.dim)(input) +import requests + + +def download_file_from_google_drive(id, destination): + def get_confirm_token(response): + for key, value in response.cookies.items(): + if key.startswith('download_warning'): + return value + + return None + + def save_response_content(response, destination): + CHUNK_SIZE = 32768 + + with open(destination, "wb") as f: + for chunk in response.iter_content(CHUNK_SIZE): + if chunk: # filter out keep-alive new chunks + f.write(chunk) + + URL = "https://docs.google.com/uc?export=download" + + session = requests.Session() + + response = session.get(URL, params = { 'id' : id }, stream = True) + token = get_confirm_token(response) + + if token: + params = { 'id' : id, 'confirm' : token } + response = session.get(URL, params = params, stream = True) + save_response_content(response, destination) + + +class ECO(nn.Module): + def __init__(self, num_class, num_segments, pretrained_parts, modality, + base_model='resnet101', new_length=None, + consensus_type='avg', before_softmax=True, + dropout=0.8, + crop_num=1, partial_bn=True): + super(ECO, self).__init__() + self.modality = modality + self.num_segments = num_segments + self.pretrained_parts = pretrained_parts + self.reshape = True + self.before_softmax = before_softmax + self.dropout = dropout + self.crop_num = crop_num + self.consensus_type = consensus_type + self.base_model_name = base_model + if not before_softmax and consensus_type != 'avg': + raise ValueError("Only avg consensus can be used after Softmax") + + if new_length is None: + self.new_length = 1 if modality == "RGB" else 5 + else: + self.new_length = new_length + + print((""" +Initializing ECO with base model: {}. +ECO Configurations: + input_modality: {} + num_segments: {} + new_length: {} + consensus_module: {} + dropout_ratio: {} + """.format(base_model, self.modality, self.num_segments, self.new_length, consensus_type, self.dropout))) + + self._prepare_base_model(base_model) + + # zc comments + feature_dim = self._prepare_tsn(num_class) + # modules = list(self.modules()) + # print(modules) + # zc comments end + + ''' + # zc: print "NN variable name" + zc_params = self.base_model.state_dict() + for zc_k in zc_params.items(): + print(zc_k) + + # zc: print "Specified layer's weight and bias" + print(zc_params['conv1_7x7_s2.weight']) + print(zc_params['conv1_7x7_s2.bias']) + ''' + + if self.modality == 'Flow': + print("Converting the ImageNet model to a flow init model") + self.base_model = self._construct_flow_model(self.base_model) + print("Done. Flow model ready...") + elif self.modality == 'RGBDiff': + print("Converting the ImageNet model to RGB+Diff init model") + self.base_model = self._construct_diff_model(self.base_model) + print("Done. RGBDiff model ready.") + + self.consensus = ConsensusModule(consensus_type) + + if not self.before_softmax: + self.softmax = nn.Softmax() + + self._enable_pbn = partial_bn + if partial_bn: + self.partialBN(True) + + def _prepare_tsn(self, num_class): + feature_dim = getattr(self.base_model, self.base_model.last_layer_name).in_features + if self.dropout == 0: + setattr(self.base_model, self.base_model.last_layer_name, nn.Linear(feature_dim, num_class)) + self.new_fc = None + else: + setattr(self.base_model, self.base_model.last_layer_name, nn.Dropout(p=self.dropout)) + self.new_fc = nn.Linear(feature_dim, num_class) + + std = 0.001 + if self.new_fc is None: + xavier_uniform_(getattr(self.base_model, self.base_model.last_layer_name).weight) + constant_(getattr(self.base_model, self.base_model.last_layer_name).bias, 0) + else: + xavier_uniform_(self.new_fc.weight) + constant_(self.new_fc.bias, 0) + return feature_dim + + def _prepare_base_model(self, base_model): + + if 'resnet' in base_model or 'vgg' in base_model: + self.base_model = getattr(torchvision.models, base_model)(True) + self.base_model.last_layer_name = 'fc' + self.input_size = 224 + self.input_mean = [0.485, 0.456, 0.406] + self.input_std = [0.229, 0.224, 0.225] + + if self.modality == 'Flow': + self.input_mean = [0.5] + self.input_std = [np.mean(self.input_std)] + elif self.modality == 'RGBDiff': + self.input_mean = [0.485, 0.456, 0.406] + [0] * 3 * self.new_length + self.input_std = self.input_std + [np.mean(self.input_std) * 2] * 3 * self.new_length + + elif base_model == 'C3DRes18': + import tf_model_zoo + self.base_model = getattr(tf_model_zoo, base_model)(num_segments=self.num_segments, pretrained_parts=self.pretrained_parts) + self.base_model.last_layer_name = 'fc8' + self.input_size = 112 + self.input_mean = [104, 117, 128] + self.input_std = [1] + + if self.modality == 'Flow': + self.input_mean = [128] + elif self.modality == 'RGBDiff': + self.input_mean = self.input_mean * (1 + self.new_length) + + elif base_model == 'ECO': + from .eco_utils import ECOModel + self.base_model = ECOModel(num_segments=self.num_segments, pretrained_parts=self.pretrained_parts) + + self.base_model.last_layer_name = 'fc_final' + self.input_size = 224 + self.input_mean = [104, 117, 128] + self.input_std = [1] + + if self.modality == 'Flow': + self.input_mean = [128] + elif self.modality == 'RGBDiff': + self.input_mean = self.input_mean * (1 + self.new_length) + + elif base_model == 'ECOfull' : + from .eco_utils import ECOFullModel + self.base_model = ECOFullModel(num_segments=self.num_segments, pretrained_parts=self.pretrained_parts) + self.base_model.last_layer_name = 'fc_final' + self.input_size = 224 + self.input_mean = [104, 117, 128] + self.input_std = [1] + + if self.modality == 'Flow': + self.input_mean = [128] + elif self.modality == 'RGBDiff': + self.input_mean = self.input_mean * (1 + self.new_length) + + + elif base_model == 'BN2to1D': + import tf_model_zoo + self.base_model = getattr(tf_model_zoo, base_model)(num_segments=self.num_segments) + self.base_model.last_layer_name = 'fc' + self.input_size = 224 + self.input_mean = [104, 117, 128] + self.input_std = [1] + + if self.modality == 'Flow': + self.input_mean = [128] + elif self.modality == 'RGBDiff': + self.input_mean = self.input_mean * (1 + self.new_length) + + elif 'inception' in base_model: + import tf_model_zoo + self.base_model = getattr(tf_model_zoo, base_model)() + self.base_model.last_layer_name = 'classif' + self.input_size = 299 + self.input_mean = [0.5] + self.input_std = [0.5] + else: + raise ValueError('Unknown base model: {}'.format(base_model)) + + def train(self, mode=True): + """ + Override the default train() to freeze the BN parameters + :return: + """ + super(ECO, self).train(mode) + count = 0 + if self._enable_pbn: + print("Freezing BatchNorm2D except the first one.") + for m in self.base_model.modules(): + if (isinstance(m, nn.BatchNorm2d) or isinstance(m, nn.BatchNorm3d)): + count += 1 + if count >= (2 if self._enable_pbn else 1): + m.eval() + + # shutdown update in frozen mode + m.weight.requires_grad = False + m.bias.requires_grad = False + else: + print("No BN layer Freezing.") + + def partialBN(self, enable): + self._enable_pbn = enable + + def get_optim_policies(self): + first_3d_conv_weight = [] + first_3d_conv_bias = [] + normal_weight = [] + normal_bias = [] + bn = [] + + conv_2d_cnt = 0 + conv_3d_cnt = 0 + bn_cnt = 0 + for m in self.modules(): + # (conv1d or conv2d) 1st layer's params will be append to list: first_conv_weight & first_conv_bias, total num 1 respectively(1 conv2d) + # (conv1d or conv2d or Linear) from 2nd layers' params will be append to list: normal_weight & normal_bias, total num 69 respectively(68 Conv2d + 1 Linear) + if isinstance(m, torch.nn.Conv2d): + ps = list(m.parameters()) + conv_2d_cnt += 1 + normal_weight.append(ps[0]) + if len(ps) == 2: + normal_bias.append(ps[1]) + + elif isinstance(m, torch.nn.Conv3d): + ps = list(m.parameters()) + conv_3d_cnt += 1 + if conv_3d_cnt == 1: + first_3d_conv_weight.append(ps[0]) + if len(ps) == 2: + first_3d_conv_bias.append(ps[1]) + else: + normal_weight.append(ps[0]) + if len(ps) == 2: + normal_bias.append(ps[1]) + + elif isinstance(m, torch.nn.Linear): + ps = list(m.parameters()) + normal_weight.append(ps[0]) + if len(ps) == 2: + normal_bias.append(ps[1]) + # (BatchNorm1d or BatchNorm2d) params will be append to list: bn, total num 2 (enabled pbn, so only: 1st BN layer's weight + 1st BN layer's bias) + elif isinstance(m, torch.nn.BatchNorm1d): + bn.extend(list(m.parameters())) + elif isinstance(m, torch.nn.BatchNorm2d): + bn_cnt += 1 + # later BN's are frozen + if not self._enable_pbn or bn_cnt == 1: + bn.extend(list(m.parameters())) + elif isinstance(m, torch.nn.BatchNorm3d): + bn_cnt += 1 + # 4 + # later BN's are frozen + if not self._enable_pbn or bn_cnt == 1: + bn.extend(list(m.parameters())) + elif len(m._modules) == 0: + if len(list(m.parameters())) > 0: + raise ValueError("New atomic module type: {}. Need to give it a learning policy".format(type(m))) + return [ + {'params': first_3d_conv_weight, 'lr_mult': 5 if self.modality == 'Flow' else 1, 'decay_mult': 1, + 'name': "first_3d_conv_weight"}, + {'params': first_3d_conv_bias, 'lr_mult': 10 if self.modality == 'Flow' else 2, 'decay_mult': 0, + 'name': "first_3d_conv_bias"}, + {'params': normal_weight, 'lr_mult': 1, 'decay_mult': 1, + 'name': "normal_weight"}, + {'params': normal_bias, 'lr_mult': 2, 'decay_mult': 0, + 'name': "normal_bias"}, + {'params': bn, 'lr_mult': 1, 'decay_mult': 0, + 'name': "BN scale/shift"}, + ] + + def get_optim_policies_BN2to1D(self): + first_conv_weight = [] + first_conv_bias = [] + normal_weight = [] + normal_bias = [] + bn = [] + last_conv_weight = [] + last_conv_bias = [] + + conv_cnt = 0 + bn_cnt = 0 + for m in self.modules(): + # (conv1d or conv2d) 1st layer's params will be append to list: first_conv_weight & first_conv_bias, total num 1 respectively(1 conv2d) + # (conv1d or conv2d or Linear) from 2nd layers' params will be append to list: normal_weight & normal_bias, total num 69 respectively(68 Conv2d + 1 Linear) + if isinstance(m, torch.nn.Conv2d) or isinstance(m, torch.nn.Conv1d): + ps = list(m.parameters()) + conv_cnt += 1 + if conv_cnt == 1: + first_conv_weight.append(ps[0]) + if len(ps) == 2: + first_conv_bias.append(ps[1]) + else: + normal_weight.append(ps[0]) + if len(ps) == 2: + normal_bias.append(ps[1]) + elif isinstance(m, torch.nn.Conv3d): + ps = list(m.parameters()) + last_conv_weight.append(ps[0]) + if len(ps) == 2: + last_conv_bias.append(ps[1]) + elif isinstance(m, torch.nn.Linear): + ps = list(m.parameters()) + normal_weight.append(ps[0]) + if len(ps) == 2: + normal_bias.append(ps[1]) + # (BatchNorm1d or BatchNorm2d) params will be append to list: bn, total num 2 (enabled pbn, so only: 1st BN layer's weight + 1st BN layer's bias) + elif isinstance(m, torch.nn.BatchNorm1d): + bn.extend(list(m.parameters())) + elif isinstance(m, torch.nn.BatchNorm2d): + bn_cnt += 1 + # later BN's are frozen + if not self._enable_pbn or bn_cnt == 1: + bn.extend(list(m.parameters())) + elif isinstance(m, torch.nn.BatchNorm3d): + bn_cnt += 1 + # 4 + # later BN's are frozen + if not self._enable_pbn or bn_cnt == 1: + bn.extend(list(m.parameters())) + elif len(m._modules) == 0: + if len(list(m.parameters())) > 0: + raise ValueError("New atomic module type: {}. Need to give it a learning policy".format(type(m))) + return [ + {'params': first_conv_weight, 'lr_mult': 5 if self.modality == 'Flow' else 1, 'decay_mult': 1, + 'name': "first_conv_weight"}, + {'params': first_conv_bias, 'lr_mult': 10 if self.modality == 'Flow' else 2, 'decay_mult': 0, + 'name': "first_conv_bias"}, + {'params': normal_weight, 'lr_mult': 1, 'decay_mult': 1, + 'name': "normal_weight"}, + {'params': normal_bias, 'lr_mult': 2, 'decay_mult': 0, + 'name': "normal_bias"}, + {'params': last_conv_weight, 'lr_mult': 5, 'decay_mult': 1, + 'name': "last_conv_weight"}, + {'params': last_conv_bias, 'lr_mult': 10, 'decay_mult': 0, + 'name': "last_conv_bias"}, + {'params': bn, 'lr_mult': 1, 'decay_mult': 0, + 'name': "BN scale/shift"}, + ] + + def forward(self, input): + sample_len = (3 if self.modality == "RGB" else 2) * self.new_length + + if self.modality == 'RGBDiff': + sample_len = 3 * self.new_length + input = self._get_diff(input) + + # input.size(): [32, 9, 224, 224] + # after view() func: [96, 3, 224, 224] + # print(input.view((-1, sample_len) + input.size()[-2:]).size()) + if self.base_model_name == "C3DRes18": + before_permute = input.view((-1, sample_len) + input.size()[-2:]) + input_var = torch.transpose(before_permute.view((-1, self.num_segments) + before_permute.size()[1:]), 1, 2) + else: + input_var = input.view((-1, sample_len) + input.size()[-2:]) + base_out = self.base_model(input_var) + + # zc comments + if self.dropout > 0: + base_out = self.new_fc(base_out) + + if not self.before_softmax: + base_out = self.softmax(base_out) + # zc comments end + + if self.reshape: + + if self.base_model_name == 'C3DRes18': + output = base_out + output = self.consensus(base_out) + return output + elif self.base_model_name == 'ECO': + output = base_out + output = self.consensus(base_out) + return output + elif self.base_model_name == 'ECOfull': + output = base_out + output = self.consensus(base_out) + return output + else: + # base_out.size(): [32, 3, 101], [batch_size, num_segments, num_class] respectively + base_out = base_out.view((-1, self.num_segments) + base_out.size()[1:]) + # output.size(): [32, 1, 101] + output = self.consensus(base_out) + # output after squeeze(1): [32, 101], forward() returns size: [batch_size, num_class] + return output.squeeze(1) + + + def _get_diff(self, input, keep_rgb=False): + input_c = 3 if self.modality in ["RGB", "RGBDiff"] else 2 + input_view = input.view((-1, self.num_segments, self.new_length + 1, input_c,) + input.size()[2:]) + if keep_rgb: + new_data = input_view.clone() + else: + new_data = input_view[:, :, 1:, :, :, :].clone() + + for x in reversed(list(range(1, self.new_length + 1))): + if keep_rgb: + new_data[:, :, x, :, :, :] = input_view[:, :, x, :, :, :] - input_view[:, :, x - 1, :, :, :] + else: + new_data[:, :, x - 1, :, :, :] = input_view[:, :, x, :, :, :] - input_view[:, :, x - 1, :, :, :] + + return new_data + + + def _construct_flow_model(self, base_model): + # modify the convolution layers + # Torch models are usually defined in a hierarchical way. + # nn.modules.children() return all sub modules in a DFS manner + modules = list(self.base_model.modules()) + first_conv_idx = list(filter(lambda x: isinstance(modules[x], nn.Conv2d), list(range(len(modules)))))[0] + conv_layer = modules[first_conv_idx] + container = modules[first_conv_idx - 1] + + # modify parameters, assume the first blob contains the convolution kernels + params = [x.clone() for x in conv_layer.parameters()] + kernel_size = params[0].size() + new_kernel_size = kernel_size[:1] + (2 * self.new_length, ) + kernel_size[2:] + new_kernels = params[0].data.mean(dim=1, keepdim=True).expand(new_kernel_size).contiguous() + + new_conv = nn.Conv2d(2 * self.new_length, conv_layer.out_channels, + conv_layer.kernel_size, conv_layer.stride, conv_layer.padding, + bias=True if len(params) == 2 else False) + new_conv.weight.data = new_kernels + if len(params) == 2: + new_conv.bias.data = params[1].data # add bias if neccessary + layer_name = list(container.state_dict().keys())[0][:-7] # remove .weight suffix to get the layer name + + # replace the first convlution layer + setattr(container, layer_name, new_conv) + return base_model + + def _construct_diff_model(self, base_model, keep_rgb=False): + # modify the convolution layers + # Torch models are usually defined in a hierarchical way. + # nn.modules.children() return all sub modules in a DFS manner + modules = list(self.base_model.modules()) + first_conv_idx = filter(lambda x: isinstance(modules[x], nn.Conv2d), list(range(len(modules))))[0] + conv_layer = modules[first_conv_idx] + container = modules[first_conv_idx - 1] + + # modify parameters, assume the first blob contains the convolution kernels + params = [x.clone() for x in conv_layer.parameters()] + kernel_size = params[0].size() + if not keep_rgb: + new_kernel_size = kernel_size[:1] + (3 * self.new_length,) + kernel_size[2:] + new_kernels = params[0].data.mean(dim=1, keepdim=True).expand(new_kernel_size).contiguous() + else: + new_kernel_size = kernel_size[:1] + (3 * self.new_length,) + kernel_size[2:] + new_kernels = torch.cat((params[0].data, params[0].data.mean(dim=1, keepdim=True).expand(new_kernel_size).contiguous()), + 1) + new_kernel_size = kernel_size[:1] + (3 + 3 * self.new_length,) + kernel_size[2:] + + new_conv = nn.Conv2d(new_kernel_size[1], conv_layer.out_channels, + conv_layer.kernel_size, conv_layer.stride, conv_layer.padding, + bias=True if len(params) == 2 else False) + new_conv.weight.data = new_kernels + if len(params) == 2: + new_conv.bias.data = params[1].data # add bias if neccessary + layer_name = list(container.state_dict().keys())[0][:-7] # remove .weight suffix to get the layer name + + # replace the first convolution layer + setattr(container, layer_name, new_conv) + return base_model + + @property + def crop_size(self): + return self.input_size + + @property + def scale_size(self): + return self.input_size * 256 // 224 + + def get_augmentation(self): + if self.modality == 'RGB': + return torchvision.transforms.Compose([GroupMultiScaleCrop(self.input_size, [1, .875, .75, .66]), + GroupRandomHorizontalFlip(is_flow=False)]) + elif self.modality == 'Flow': + return torchvision.transforms.Compose([GroupMultiScaleCrop(self.input_size, [1, .875, .75]), + GroupRandomHorizontalFlip(is_flow=True)]) + elif self.modality == 'RGBDiff': + return torchvision.transforms.Compose([GroupMultiScaleCrop(self.input_size, [1, .875, .75]), + GroupRandomHorizontalFlip(is_flow=False)]) + + diff --git a/autovideo/recognition/eco_utils/__init__.py b/autovideo/recognition/eco_utils/__init__.py new file mode 100644 index 0000000..0e70a05 --- /dev/null +++ b/autovideo/recognition/eco_utils/__init__.py @@ -0,0 +1,2 @@ +from .eco.pytorch_load import ECOModel +from .eco_full.pytorch_load import ECOFullModel diff --git a/autovideo/recognition/eco_utils/eco/ECO.yaml b/autovideo/recognition/eco_utils/eco/ECO.yaml new file mode 100644 index 0000000..b0a645f --- /dev/null +++ b/autovideo/recognition/eco_utils/eco/ECO.yaml @@ -0,0 +1,256 @@ +inputs: [] +layers: +- attrs: {kernel_size: 7, num_output: 64, pad: 3, stride: 2} + expr: conv1_7x7_s2<=Convolution<=data + id: conv1_7x7_s2 +- attrs: {frozen: true} + expr: conv1_7x7_s2_bn<=BN<=conv1_7x7_s2 + id: conv1_7x7_s2_bn +- {expr: conv1_7x7_s2_bn<=ReLU<=conv1_7x7_s2_bn, id: conv1_relu_7x7} +- attrs: {kernel_size: 3, mode: max, stride: 2} + expr: pool1_3x3_s2<=Pooling<=conv1_7x7_s2_bn + id: pool1_3x3_s2 +- attrs: {kernel_size: 1, num_output: 64} + expr: conv2_3x3_reduce<=Convolution<=pool1_3x3_s2 + id: conv2_3x3_reduce +- attrs: {frozen: true} + expr: conv2_3x3_reduce_bn<=BN<=conv2_3x3_reduce + id: conv2_3x3_reduce_bn +- {expr: conv2_3x3_reduce_bn<=ReLU<=conv2_3x3_reduce_bn, id: conv2_relu_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 192, pad: 1} + expr: conv2_3x3<=Convolution<=conv2_3x3_reduce_bn + id: conv2_3x3 +- attrs: {frozen: true} + expr: conv2_3x3_bn<=BN<=conv2_3x3 + id: conv2_3x3_bn +- {expr: conv2_3x3_bn<=ReLU<=conv2_3x3_bn, id: conv2_relu_3x3} +- attrs: {kernel_size: 3, mode: max, stride: 2} + expr: pool2_3x3_s2<=Pooling<=conv2_3x3_bn + id: pool2_3x3_s2 +- attrs: {kernel_size: 1, num_output: 64} + expr: inception_3a_1x1<=Convolution<=pool2_3x3_s2 + id: inception_3a_1x1 +- attrs: {frozen: true} + expr: inception_3a_1x1_bn<=BN<=inception_3a_1x1 + id: inception_3a_1x1_bn +- {expr: inception_3a_1x1_bn<=ReLU<=inception_3a_1x1_bn, id: inception_3a_relu_1x1} +- attrs: {kernel_size: 1, num_output: 64} + expr: inception_3a_3x3_reduce<=Convolution<=pool2_3x3_s2 + id: inception_3a_3x3_reduce +- attrs: {frozen: true} + expr: inception_3a_3x3_reduce_bn<=BN<=inception_3a_3x3_reduce + id: inception_3a_3x3_reduce_bn +- {expr: inception_3a_3x3_reduce_bn<=ReLU<=inception_3a_3x3_reduce_bn, id: inception_3a_relu_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 64, pad: 1} + expr: inception_3a_3x3<=Convolution<=inception_3a_3x3_reduce_bn + id: inception_3a_3x3 +- attrs: {frozen: true} + expr: inception_3a_3x3_bn<=BN<=inception_3a_3x3 + id: inception_3a_3x3_bn +- {expr: inception_3a_3x3_bn<=ReLU<=inception_3a_3x3_bn, id: inception_3a_relu_3x3} +- attrs: {kernel_size: 1, num_output: 64} + expr: inception_3a_double_3x3_reduce<=Convolution<=pool2_3x3_s2 + id: inception_3a_double_3x3_reduce +- attrs: {frozen: true} + expr: inception_3a_double_3x3_reduce_bn<=BN<=inception_3a_double_3x3_reduce + id: inception_3a_double_3x3_reduce_bn +- {expr: inception_3a_double_3x3_reduce_bn<=ReLU<=inception_3a_double_3x3_reduce_bn, + id: inception_3a_relu_double_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 96, pad: 1} + expr: inception_3a_double_3x3_1<=Convolution<=inception_3a_double_3x3_reduce_bn + id: inception_3a_double_3x3_1 +- attrs: {frozen: true} + expr: inception_3a_double_3x3_1_bn<=BN<=inception_3a_double_3x3_1 + id: inception_3a_double_3x3_1_bn +- {expr: inception_3a_double_3x3_1_bn<=ReLU<=inception_3a_double_3x3_1_bn, id: inception_3a_relu_double_3x3_1} +- attrs: {kernel_size: 3, num_output: 96, pad: 1} + expr: inception_3a_double_3x3_2<=Convolution<=inception_3a_double_3x3_1_bn + id: inception_3a_double_3x3_2 +- attrs: {frozen: true} + expr: inception_3a_double_3x3_2_bn<=BN<=inception_3a_double_3x3_2 + id: inception_3a_double_3x3_2_bn +- {expr: inception_3a_double_3x3_2_bn<=ReLU<=inception_3a_double_3x3_2_bn, id: inception_3a_relu_double_3x3_2} +- attrs: {kernel_size: 3, mode: ave, pad: 1, stride: 1} + expr: inception_3a_pool<=Pooling<=pool2_3x3_s2 + id: inception_3a_pool +- attrs: {kernel_size: 1, num_output: 32} + expr: inception_3a_pool_proj<=Convolution<=inception_3a_pool + id: inception_3a_pool_proj +- attrs: {frozen: true} + expr: inception_3a_pool_proj_bn<=BN<=inception_3a_pool_proj + id: inception_3a_pool_proj_bn +- {expr: inception_3a_pool_proj_bn<=ReLU<=inception_3a_pool_proj_bn, id: inception_3a_relu_pool_proj} +- {expr: 'inception_3a_output<=Concat<=inception_3a_1x1_bn,inception_3a_3x3_bn,inception_3a_double_3x3_2_bn,inception_3a_pool_proj_bn', + id: inception_3a_output} +- attrs: {kernel_size: 1, num_output: 64} + expr: inception_3b_1x1<=Convolution<=inception_3a_output + id: inception_3b_1x1 +- attrs: {frozen: true} + expr: inception_3b_1x1_bn<=BN<=inception_3b_1x1 + id: inception_3b_1x1_bn +- {expr: inception_3b_1x1_bn<=ReLU<=inception_3b_1x1_bn, id: inception_3b_relu_1x1} +- attrs: {kernel_size: 1, num_output: 64} + expr: inception_3b_3x3_reduce<=Convolution<=inception_3a_output + id: inception_3b_3x3_reduce +- attrs: {frozen: true} + expr: inception_3b_3x3_reduce_bn<=BN<=inception_3b_3x3_reduce + id: inception_3b_3x3_reduce_bn +- {expr: inception_3b_3x3_reduce_bn<=ReLU<=inception_3b_3x3_reduce_bn, id: inception_3b_relu_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 96, pad: 1} + expr: inception_3b_3x3<=Convolution<=inception_3b_3x3_reduce_bn + id: inception_3b_3x3 +- attrs: {frozen: true} + expr: inception_3b_3x3_bn<=BN<=inception_3b_3x3 + id: inception_3b_3x3_bn +- {expr: inception_3b_3x3_bn<=ReLU<=inception_3b_3x3_bn, id: inception_3b_relu_3x3} +- attrs: {kernel_size: 1, num_output: 64} + expr: inception_3b_double_3x3_reduce<=Convolution<=inception_3a_output + id: inception_3b_double_3x3_reduce +- attrs: {frozen: true} + expr: inception_3b_double_3x3_reduce_bn<=BN<=inception_3b_double_3x3_reduce + id: inception_3b_double_3x3_reduce_bn +- {expr: inception_3b_double_3x3_reduce_bn<=ReLU<=inception_3b_double_3x3_reduce_bn, + id: inception_3b_relu_double_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 96, pad: 1} + expr: inception_3b_double_3x3_1<=Convolution<=inception_3b_double_3x3_reduce_bn + id: inception_3b_double_3x3_1 +- attrs: {frozen: true} + expr: inception_3b_double_3x3_1_bn<=BN<=inception_3b_double_3x3_1 + id: inception_3b_double_3x3_1_bn +- {expr: inception_3b_double_3x3_1_bn<=ReLU<=inception_3b_double_3x3_1_bn, id: inception_3b_relu_double_3x3_1} +- attrs: {kernel_size: 3, num_output: 96, pad: 1} + expr: inception_3b_double_3x3_2<=Convolution<=inception_3b_double_3x3_1_bn + id: inception_3b_double_3x3_2 +- attrs: {frozen: true} + expr: inception_3b_double_3x3_2_bn<=BN<=inception_3b_double_3x3_2 + id: inception_3b_double_3x3_2_bn +- {expr: inception_3b_double_3x3_2_bn<=ReLU<=inception_3b_double_3x3_2_bn, id: inception_3b_relu_double_3x3_2} +- attrs: {kernel_size: 3, mode: ave, pad: 1, stride: 1} + expr: inception_3b_pool<=Pooling<=inception_3a_output + id: inception_3b_pool +- attrs: {kernel_size: 1, num_output: 64} + expr: inception_3b_pool_proj<=Convolution<=inception_3b_pool + id: inception_3b_pool_proj +- attrs: {frozen: true} + expr: inception_3b_pool_proj_bn<=BN<=inception_3b_pool_proj + id: inception_3b_pool_proj_bn +- {expr: inception_3b_pool_proj_bn<=ReLU<=inception_3b_pool_proj_bn, id: inception_3b_relu_pool_proj} +- {expr: 'inception_3b_output<=Concat<=inception_3b_1x1_bn,inception_3b_3x3_bn,inception_3b_double_3x3_2_bn,inception_3b_pool_proj_bn', + id: inception_3b_output} +- attrs: {kernel_size: 1, num_output: 64} + expr: inception_3c_double_3x3_reduce<=Convolution<=inception_3b_output + id: inception_3c_double_3x3_reduce +- attrs: {frozen: true} + expr: inception_3c_double_3x3_reduce_bn<=BN<=inception_3c_double_3x3_reduce + id: inception_3c_double_3x3_reduce_bn +- {expr: inception_3c_double_3x3_reduce_bn<=ReLU<=inception_3c_double_3x3_reduce_bn, + id: inception_3c_relu_double_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 96, pad: 1} + expr: inception_3c_double_3x3_1<=Convolution<=inception_3c_double_3x3_reduce_bn + id: inception_3c_double_3x3_1 +- attrs: {frozen: true} + expr: inception_3c_double_3x3_1_bn<=BN<=inception_3c_double_3x3_1 + id: inception_3c_double_3x3_1_bn +- {expr: inception_3c_double_3x3_1_bn<=ReLU<=inception_3c_double_3x3_1_bn, id: inception_3c_relu_double_3x3_1} + + +- attrs: {kernel_size: 3, num_output: 128, pad: 1, stride: 1} + expr: res3a_2<=Conv3d<=inception_3c_double_3x3_1_bn + id: res3a_2 +- attrs: {frozen: false} + expr: res3a_bn<=BN3d<=res3a_2 + id: res3a_bn +- {expr: res3a_bn<=ReLU<=res3a_bn, id: res3a_relu} +- attrs: {kernel_size: 3, num_output: 128, pad: 1, stride: 1} + expr: res3b_1<=Conv3d<=res3a_bn + id: res3b_1 +- attrs: {frozen: false} + expr: res3b_1_bn<=BN3d<=res3b_1 + id: res3b_1_bn +- {expr: res3b_1_bn<=ReLU<=res3b_1_bn, id: res3b_1_relu} +- attrs: {kernel_size: 3, num_output: 128, pad: 1, stride: 1} + expr: res3b_2<=Conv3d<=res3b_1_bn + id: res3b_2 +- {expr: 'res3b<=Eltwise<=res3b_2,res3a_2', id: res3b} +- attrs: {frozen: false} + expr: res3b_bn<=BN3d<=res3b + id: res3b_bn +- {expr: res3b_bn<=ReLU<=res3b_bn, id: res3b_relu} + +- attrs: {kernel_size: 3, num_output: 256, pad: 1, stride: 2} + expr: res4a_1<=Conv3d<=res3b_bn + id: res4a_1 +- attrs: {frozen: false} + expr: res4a_1_bn<=BN3d<=res4a_1 + id: res4a_1_bn +- {expr: res4a_1_bn<=ReLU<=res4a_1_bn, id: res4a_1_relu} +- attrs: {kernel_size: 3, num_output: 256, pad: 1, stride: 1} + expr: res4a_2<=Conv3d<=res4a_1_bn + id: res4a_2 +- attrs: {kernel_size: 3, num_output: 256, pad: 1, stride: 2} + expr: res4a_down<=Conv3d<=res3b_bn + id: res4a_down +- {expr: 'res4a<=Eltwise<=res4a_2,res4a_down', id: res4a} + +- attrs: {frozen: false} + expr: res4a_bn<=BN3d<=res4a + id: res4a_bn +- {expr: res4a_bn<=ReLU<=res4a_bn, id: res4a_relu} +- attrs: {kernel_size: 3, num_output: 256, pad: 1, stride: 1} + expr: res4b_1<=Conv3d<=res4a_bn + id: res4b_1 +- attrs: {frozen: false} + expr: res4b_1_bn<=BN3d<=res4b_1 + id: res4b_1_bn +- {expr: res4b_1_bn<=ReLU<=res4b_1_bn, id: res4b_1_relu} +- attrs: {kernel_size: 3, num_output: 256, pad: 1, stride: 1} + expr: res4b_2<=Conv3d<=res4b_1_bn + id: res4b_2 +- {expr: 'res4b<=Eltwise<=res4b_2,res4a', id: res4b} +- attrs: {frozen: false} + expr: res4b_bn<=BN3d<=res4b + id: res4b_bn +- {expr: res4b_bn<=ReLU<=res4b_bn, id: res4b_relu} + +- attrs: {kernel_size: 3, num_output: 512, pad: 1, stride: 2} + expr: res5a_1<=Conv3d<=res4b_bn + id: res5a_1 +- attrs: {frozen: false} + expr: res5a_1_bn<=BN3d<=res5a_1 + id: res5a_1_bn +- {expr: res5a_1_bn<=ReLU<=res5a_1_bn, id: res5a_1_relu} +- attrs: {kernel_size: 3, num_output: 512, pad: 1, stride: 1} + expr: res5a_2<=Conv3d<=res5a_1_bn + id: res5a_2 +- attrs: {kernel_size: 3, num_output: 512, pad: 1, stride: 2} + expr: res5a_down<=Conv3d<=res4b_bn + id: res5a_down +- {expr: 'res5a<=Eltwise<=res5a_2,res5a_down', id: res5a} + +- attrs: {frozen: false} + expr: res5a_bn<=BN3d<=res5a + id: res5a_bn +- {expr: res5a_bn<=ReLU<=res5a_bn, id: res5a_relu} +- attrs: {kernel_size: 3, num_output: 512, pad: 1, stride: 1} + expr: res5b_1<=Conv3d<=res5a_bn + id: res5b_1 +- attrs: {frozen: false} + expr: res5b_1_bn<=BN3d<=res5b_1 + id: res5b_1_bn +- {expr: res5b_1_bn<=ReLU<=res5b_1_bn, id: res5b_1_relu} +- attrs: {kernel_size: 3, num_output: 512, pad: 1, stride: 1} + expr: res5b_2<=Conv3d<=res5b_1_bn + id: res5b_2 +- {expr: 'res5b<=Eltwise<=res5b_2,res5a', id: res5b} +- attrs: {frozen: false} + expr: res5b_bn<=BN3d<=res5b + id: res5b_bn +- {expr: res5b_bn<=ReLU<=res5b_bn, id: res5b_relu} + +- attrs: {kernel_d: 1, kernel_h: 7, kernel_w: 7, stride: 1, mode: ave} + expr: global_pool<=Pooling3d<=res5b_bn + id: global_pool +- attrs: {num_output: 400} + expr: fc_action<=InnerProduct<=global_pool + id: fc_final +name: ECO diff --git a/autovideo/recognition/eco_utils/eco/__init__.py b/autovideo/recognition/eco_utils/eco/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/autovideo/recognition/eco_utils/eco/layer_factory.py b/autovideo/recognition/eco_utils/eco/layer_factory.py new file mode 100644 index 0000000..162efd0 --- /dev/null +++ b/autovideo/recognition/eco_utils/eco/layer_factory.py @@ -0,0 +1,134 @@ +import torch +from torch import nn + + +LAYER_BUILDER_DICT=dict() + + +def parse_expr(expr): + parts = expr.split('<=') + return parts[0].split(','), parts[1], parts[2].split(',') + + +def get_basic_layer(info, channels=None, conv_bias=False, num_segments=4): + id = info['id'] + + attr = info['attrs'] if 'attrs' in info else list() + if id=="global_pool": + attr['kernel_d'] = int(num_segments / 4) + + out, op, in_vars = parse_expr(info['expr']) + assert(len(out) == 1) + assert(len(in_vars) == 1) + mod, out_channel, = LAYER_BUILDER_DICT[op](attr, channels, conv_bias) + + return id, out[0], mod, out_channel, in_vars[0] + + +def build_conv(attr, channels=None, conv_bias=False): + out_channels = attr['num_output'] + ks = attr['kernel_size'] if 'kernel_size' in attr else (attr['kernel_h'], attr['kernel_w']) + if 'pad' in attr or 'pad_w' in attr and 'pad_h' in attr: + padding = attr['pad'] if 'pad' in attr else (attr['pad_h'], attr['pad_w']) + else: + padding = 0 + if 'stride' in attr or 'stride_w' in attr and 'stride_h' in attr: + stride = attr['stride'] if 'stride' in attr else (attr['stride_h'], attr['stride_w']) + else: + stride = 1 + + conv = nn.Conv2d(channels, out_channels, ks, stride, padding, bias=conv_bias) + + return conv, out_channels + + +def build_pooling(attr, channels=None, conv_bias=False): + method = attr['mode'] + pad = attr['pad'] if 'pad' in attr else 0 + if method == 'max': + pool = nn.MaxPool2d(attr['kernel_size'], attr['stride'], pad, + ceil_mode=True) # all Caffe pooling use ceil model + elif method == 'ave': + pool = nn.AvgPool2d(attr['kernel_size'], attr['stride'], pad, + ceil_mode=True) # all Caffe pooling use ceil model + else: + raise ValueError("Unknown pooling method: {}".format(method)) + + return pool, channels + + +def build_relu(attr, channels=None, conv_bias=False): + return nn.ReLU(inplace=True), channels + + +def build_bn(attr, channels=None, conv_bias=False): + return nn.BatchNorm2d(channels, momentum=0.1), channels + + +def build_linear(attr, channels=None, conv_bias=False): + return nn.Linear(channels, attr['num_output']), channels + + +def build_dropout(attr, channels=None, conv_bias=False): + return nn.Dropout(p=attr['dropout_ratio']), channels + +def build_conv3d(attr, channels=None, conv_bias=False): + out_channels = attr['num_output'] + ks = attr['kernel_size'] if 'kernel_size' in attr else (attr['kernel_d'], attr['kernel_h'], attr['kernel_w']) + if ('pad' in attr) or ('pad_d' in attr and 'pad_w' in attr and 'pad_h' in attr): + padding = attr['pad'] if 'pad' in attr else (attr['pad_d'], attr['pad_h'], attr['pad_w']) + else: + padding = 0 + if ('stride' in attr) or ('stride_d' in attr and 'stride_w' in attr and 'stride_h' in attr): + stride = attr['stride'] if 'stride' in attr else (attr['stride_d'], attr['stride_h'], attr['stride_w']) + else: + stride = 1 + + conv = nn.Conv3d(channels, out_channels, ks, stride, padding, bias=conv_bias) + + return conv, out_channels + +def build_pooling3d(attr, channels=None, conv_bias=False): + method = attr['mode'] + ks = attr['kernel_size'] if 'kernel_size' in attr else (attr['kernel_d'], attr['kernel_h'], attr['kernel_w']) + if ('pad' in attr) or ('pad_d' in attr and 'pad_w' in attr and 'pad_h' in attr): + padding = attr['pad'] if 'pad' in attr else (attr['pad_d'], attr['pad_h'], attr['pad_w']) + else: + padding = 0 + if ('stride' in attr) or ('stride_d' in attr and 'stride_w' in attr and 'stride_h' in attr): + stride = attr['stride'] if 'stride' in attr else (attr['stride_d'], attr['stride_h'], attr['stride_w']) + else: + stride = 1 + if method == 'max': + pool = nn.MaxPool3d(ks, stride, padding, + ceil_mode=True) # all Caffe pooling use ceil model + elif method == 'ave': + pool = nn.AvgPool3d(ks, stride, padding, + ceil_mode=True) # all Caffe pooling use ceil model + else: + raise ValueError("Unknown pooling method: {}".format(method)) + + return pool, channels + +def build_bn3d(attr, channels=None, conv_bias=False): + return nn.BatchNorm3d(channels, momentum=0.1), channels + + +LAYER_BUILDER_DICT['Convolution'] = build_conv + +LAYER_BUILDER_DICT['Pooling'] = build_pooling + +LAYER_BUILDER_DICT['ReLU'] = build_relu + +LAYER_BUILDER_DICT['Dropout'] = build_dropout + +LAYER_BUILDER_DICT['BN'] = build_bn + +LAYER_BUILDER_DICT['InnerProduct'] = build_linear + +LAYER_BUILDER_DICT['Conv3d'] = build_conv3d + +LAYER_BUILDER_DICT['Pooling3d'] = build_pooling3d + +LAYER_BUILDER_DICT['BN3d'] = build_bn3d + diff --git a/autovideo/recognition/eco_utils/eco/pytorch_load.py b/autovideo/recognition/eco_utils/eco/pytorch_load.py new file mode 100644 index 0000000..a2456d5 --- /dev/null +++ b/autovideo/recognition/eco_utils/eco/pytorch_load.py @@ -0,0 +1,95 @@ +import os + +import torch +from torch import nn +from .layer_factory import get_basic_layer, parse_expr +import torch.utils.model_zoo as model_zoo +import yaml + +import autovideo +ROOT_PATH = autovideo.__path__[0] +MODEL_PATH = os.path.join(ROOT_PATH, 'recognition/eco_utils/eco/ECO.yaml') + +class ECOModel(nn.Module): + def __init__(self, model_path=MODEL_PATH, num_classes=101, + num_segments=4, pretrained_parts='both'): + + super(ECOModel, self).__init__() + + self.num_segments = num_segments + + self.pretrained_parts = pretrained_parts + + manifest = yaml.load(open(model_path)) + + layers = manifest['layers'] + + self._channel_dict = dict() + + self._op_list = list() + for l in layers: + out_var, op, in_var = parse_expr(l['expr']) + if op != 'Concat' and op != 'Eltwise': + id, out_name, module, out_channel, in_name = get_basic_layer(l, + 3 if len(self._channel_dict) == 0 else self._channel_dict[in_var[0]], + conv_bias=True if op == 'Conv3d' else True, num_segments=num_segments) + + self._channel_dict[out_name] = out_channel + setattr(self, id, module) + self._op_list.append((id, op, out_name, in_name)) + elif op == 'Concat': + self._op_list.append((id, op, out_var[0], in_var)) + channel = sum([self._channel_dict[x] for x in in_var]) + self._channel_dict[out_var[0]] = channel + else: + self._op_list.append((id, op, out_var[0], in_var)) + channel = self._channel_dict[in_var[0]] + self._channel_dict[out_var[0]] = channel + + + def forward(self, input): + data_dict = dict() + data_dict[self._op_list[0][-1]] = input + + def get_hook(name): + + def hook(m, grad_in, grad_out): + print(name, grad_out[0].data.abs().mean()) + + return hook + for op in self._op_list: + if op[1] != 'Concat' and op[1] != 'InnerProduct' and op[1] != 'Eltwise': + # first 3d conv layer judge, the last 2d conv layer's output must be transpose from 4d to 5d + if op[0] == 'res3a_2': + inception_3c_output = data_dict['inception_3c_double_3x3_1_bn'] + inception_3c_transpose_output = torch.transpose(inception_3c_output.view((-1, self.num_segments) + inception_3c_output.size()[1:]), 1, 2) + data_dict[op[2]] = getattr(self, op[0])(inception_3c_transpose_output) + else: + data_dict[op[2]] = getattr(self, op[0])(data_dict[op[-1]]) + # getattr(self, op[0]).register_backward_hook(get_hook(op[0])) + elif op[1] == 'InnerProduct': + x = data_dict[op[-1]] + data_dict[op[2]] = getattr(self, op[0])(x.view(x.size(0), -1)) + elif op[1] == 'Eltwise': + try: + data_dict[op[2]] = torch.add(data_dict[op[-1][0]], 1, data_dict[op[-1][1]]) + except: + for x in op[-1]: + print(x,data_dict[x].size()) + raise + # x = data_dict[op[-1]] + # data_dict[op[2]] = getattr(self, op[0])(x.view(x.size(0), -1)) + else: + try: + data_dict[op[2]] = torch.cat(tuple(data_dict[x] for x in op[-1]), 1) + except: + for x in op[-1]: + print(x,data_dict[x].size()) + raise + # print output data size in each layers + # for k in data_dict.keys(): + # print(k,": ",data_dict[k].size()) + # exit() + + # "self._op_list[-1][2]" represents: last layer's name(e.g. fc_action) + return data_dict[self._op_list[-1][2]] diff --git a/autovideo/recognition/eco_utils/eco_full/ECOFull.yaml b/autovideo/recognition/eco_utils/eco_full/ECOFull.yaml new file mode 100644 index 0000000..2627d7a --- /dev/null +++ b/autovideo/recognition/eco_utils/eco_full/ECOFull.yaml @@ -0,0 +1,676 @@ +inputs: [] +layers: +- attrs: {kernel_size: 7, num_output: 64, pad: 3, stride: 2} + expr: conv1_7x7_s2<=Convolution<=data + id: conv1_7x7_s2 +- attrs: {frozen: true} + expr: conv1_7x7_s2_bn<=BN<=conv1_7x7_s2 + id: conv1_7x7_s2_bn +- {expr: conv1_7x7_s2_bn<=ReLU<=conv1_7x7_s2_bn, id: conv1_relu_7x7} +- attrs: {kernel_size: 3, mode: max, stride: 2} + expr: pool1_3x3_s2<=Pooling<=conv1_7x7_s2_bn + id: pool1_3x3_s2 +- attrs: {kernel_size: 1, num_output: 64} + expr: conv2_3x3_reduce<=Convolution<=pool1_3x3_s2 + id: conv2_3x3_reduce +- attrs: {frozen: true} + expr: conv2_3x3_reduce_bn<=BN<=conv2_3x3_reduce + id: conv2_3x3_reduce_bn +- {expr: conv2_3x3_reduce_bn<=ReLU<=conv2_3x3_reduce_bn, id: conv2_relu_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 192, pad: 1} + expr: conv2_3x3<=Convolution<=conv2_3x3_reduce_bn + id: conv2_3x3 +- attrs: {frozen: true} + expr: conv2_3x3_bn<=BN<=conv2_3x3 + id: conv2_3x3_bn +- {expr: conv2_3x3_bn<=ReLU<=conv2_3x3_bn, id: conv2_relu_3x3} +- attrs: {kernel_size: 3, mode: max, stride: 2} + expr: pool2_3x3_s2<=Pooling<=conv2_3x3_bn + id: pool2_3x3_s2 +- attrs: {kernel_size: 1, num_output: 64} + expr: inception_3a_1x1<=Convolution<=pool2_3x3_s2 + id: inception_3a_1x1 +- attrs: {frozen: true} + expr: inception_3a_1x1_bn<=BN<=inception_3a_1x1 + id: inception_3a_1x1_bn +- {expr: inception_3a_1x1_bn<=ReLU<=inception_3a_1x1_bn, id: inception_3a_relu_1x1} +- attrs: {kernel_size: 1, num_output: 64} + expr: inception_3a_3x3_reduce<=Convolution<=pool2_3x3_s2 + id: inception_3a_3x3_reduce +- attrs: {frozen: true} + expr: inception_3a_3x3_reduce_bn<=BN<=inception_3a_3x3_reduce + id: inception_3a_3x3_reduce_bn +- {expr: inception_3a_3x3_reduce_bn<=ReLU<=inception_3a_3x3_reduce_bn, id: inception_3a_relu_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 64, pad: 1} + expr: inception_3a_3x3<=Convolution<=inception_3a_3x3_reduce_bn + id: inception_3a_3x3 +- attrs: {frozen: true} + expr: inception_3a_3x3_bn<=BN<=inception_3a_3x3 + id: inception_3a_3x3_bn +- {expr: inception_3a_3x3_bn<=ReLU<=inception_3a_3x3_bn, id: inception_3a_relu_3x3} +- attrs: {kernel_size: 1, num_output: 64} + expr: inception_3a_double_3x3_reduce<=Convolution<=pool2_3x3_s2 + id: inception_3a_double_3x3_reduce +- attrs: {frozen: true} + expr: inception_3a_double_3x3_reduce_bn<=BN<=inception_3a_double_3x3_reduce + id: inception_3a_double_3x3_reduce_bn +- {expr: inception_3a_double_3x3_reduce_bn<=ReLU<=inception_3a_double_3x3_reduce_bn, + id: inception_3a_relu_double_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 96, pad: 1} + expr: inception_3a_double_3x3_1<=Convolution<=inception_3a_double_3x3_reduce_bn + id: inception_3a_double_3x3_1 +- attrs: {frozen: true} + expr: inception_3a_double_3x3_1_bn<=BN<=inception_3a_double_3x3_1 + id: inception_3a_double_3x3_1_bn +- {expr: inception_3a_double_3x3_1_bn<=ReLU<=inception_3a_double_3x3_1_bn, id: inception_3a_relu_double_3x3_1} +- attrs: {kernel_size: 3, num_output: 96, pad: 1} + expr: inception_3a_double_3x3_2<=Convolution<=inception_3a_double_3x3_1_bn + id: inception_3a_double_3x3_2 +- attrs: {frozen: true} + expr: inception_3a_double_3x3_2_bn<=BN<=inception_3a_double_3x3_2 + id: inception_3a_double_3x3_2_bn +- {expr: inception_3a_double_3x3_2_bn<=ReLU<=inception_3a_double_3x3_2_bn, id: inception_3a_relu_double_3x3_2} +- attrs: {kernel_size: 3, mode: ave, pad: 1, stride: 1} + expr: inception_3a_pool<=Pooling<=pool2_3x3_s2 + id: inception_3a_pool +- attrs: {kernel_size: 1, num_output: 32} + expr: inception_3a_pool_proj<=Convolution<=inception_3a_pool + id: inception_3a_pool_proj +- attrs: {frozen: true} + expr: inception_3a_pool_proj_bn<=BN<=inception_3a_pool_proj + id: inception_3a_pool_proj_bn +- {expr: inception_3a_pool_proj_bn<=ReLU<=inception_3a_pool_proj_bn, id: inception_3a_relu_pool_proj} +- {expr: 'inception_3a_output<=Concat<=inception_3a_1x1_bn,inception_3a_3x3_bn,inception_3a_double_3x3_2_bn,inception_3a_pool_proj_bn', + id: inception_3a_output} +- attrs: {kernel_size: 1, num_output: 64} + expr: inception_3b_1x1<=Convolution<=inception_3a_output + id: inception_3b_1x1 +- attrs: {frozen: true} + expr: inception_3b_1x1_bn<=BN<=inception_3b_1x1 + id: inception_3b_1x1_bn +- {expr: inception_3b_1x1_bn<=ReLU<=inception_3b_1x1_bn, id: inception_3b_relu_1x1} +- attrs: {kernel_size: 1, num_output: 64} + expr: inception_3b_3x3_reduce<=Convolution<=inception_3a_output + id: inception_3b_3x3_reduce +- attrs: {frozen: true} + expr: inception_3b_3x3_reduce_bn<=BN<=inception_3b_3x3_reduce + id: inception_3b_3x3_reduce_bn +- {expr: inception_3b_3x3_reduce_bn<=ReLU<=inception_3b_3x3_reduce_bn, id: inception_3b_relu_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 96, pad: 1} + expr: inception_3b_3x3<=Convolution<=inception_3b_3x3_reduce_bn + id: inception_3b_3x3 +- attrs: {frozen: true} + expr: inception_3b_3x3_bn<=BN<=inception_3b_3x3 + id: inception_3b_3x3_bn +- {expr: inception_3b_3x3_bn<=ReLU<=inception_3b_3x3_bn, id: inception_3b_relu_3x3} +- attrs: {kernel_size: 1, num_output: 64} + expr: inception_3b_double_3x3_reduce<=Convolution<=inception_3a_output + id: inception_3b_double_3x3_reduce +- attrs: {frozen: true} + expr: inception_3b_double_3x3_reduce_bn<=BN<=inception_3b_double_3x3_reduce + id: inception_3b_double_3x3_reduce_bn +- {expr: inception_3b_double_3x3_reduce_bn<=ReLU<=inception_3b_double_3x3_reduce_bn, + id: inception_3b_relu_double_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 96, pad: 1} + expr: inception_3b_double_3x3_1<=Convolution<=inception_3b_double_3x3_reduce_bn + id: inception_3b_double_3x3_1 +- attrs: {frozen: true} + expr: inception_3b_double_3x3_1_bn<=BN<=inception_3b_double_3x3_1 + id: inception_3b_double_3x3_1_bn +- {expr: inception_3b_double_3x3_1_bn<=ReLU<=inception_3b_double_3x3_1_bn, id: inception_3b_relu_double_3x3_1} +- attrs: {kernel_size: 3, num_output: 96, pad: 1} + expr: inception_3b_double_3x3_2<=Convolution<=inception_3b_double_3x3_1_bn + id: inception_3b_double_3x3_2 +- attrs: {frozen: true} + expr: inception_3b_double_3x3_2_bn<=BN<=inception_3b_double_3x3_2 + id: inception_3b_double_3x3_2_bn +- {expr: inception_3b_double_3x3_2_bn<=ReLU<=inception_3b_double_3x3_2_bn, id: inception_3b_relu_double_3x3_2} +- attrs: {kernel_size: 3, mode: ave, pad: 1, stride: 1} + expr: inception_3b_pool<=Pooling<=inception_3a_output + id: inception_3b_pool +- attrs: {kernel_size: 1, num_output: 64} + expr: inception_3b_pool_proj<=Convolution<=inception_3b_pool + id: inception_3b_pool_proj +- attrs: {frozen: true} + expr: inception_3b_pool_proj_bn<=BN<=inception_3b_pool_proj + id: inception_3b_pool_proj_bn +- {expr: inception_3b_pool_proj_bn<=ReLU<=inception_3b_pool_proj_bn, id: inception_3b_relu_pool_proj} +- {expr: 'inception_3b_output<=Concat<=inception_3b_1x1_bn,inception_3b_3x3_bn,inception_3b_double_3x3_2_bn,inception_3b_pool_proj_bn', + id: inception_3b_output} +- attrs: {kernel_size: 1, num_output: 128} + expr: inception_3c_3x3_reduce<=Convolution<=inception_3b_output + id: inception_3c_3x3_reduce +- attrs: {frozen: true} + expr: inception_3c_3x3_reduce_bn<=BN<=inception_3c_3x3_reduce + id: inception_3c_3x3_reduce_bn +- {expr: inception_3c_3x3_reduce_bn<=ReLU<=inception_3c_3x3_reduce_bn, id: inception_3c_relu_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 160, pad: 1, stride: 2} + expr: inception_3c_3x3<=Convolution<=inception_3c_3x3_reduce_bn + id: inception_3c_3x3 +- attrs: {frozen: true} + expr: inception_3c_3x3_bn<=BN<=inception_3c_3x3 + id: inception_3c_3x3_bn +- {expr: inception_3c_3x3_bn<=ReLU<=inception_3c_3x3_bn, id: inception_3c_relu_3x3} +- attrs: {kernel_size: 1, num_output: 64} + expr: inception_3c_double_3x3_reduce<=Convolution<=inception_3b_output + id: inception_3c_double_3x3_reduce +- attrs: {frozen: true} + expr: inception_3c_double_3x3_reduce_bn<=BN<=inception_3c_double_3x3_reduce + id: inception_3c_double_3x3_reduce_bn +- {expr: inception_3c_double_3x3_reduce_bn<=ReLU<=inception_3c_double_3x3_reduce_bn, + id: inception_3c_relu_double_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 96, pad: 1} + expr: inception_3c_double_3x3_1<=Convolution<=inception_3c_double_3x3_reduce_bn + id: inception_3c_double_3x3_1 +- attrs: {frozen: true} + expr: inception_3c_double_3x3_1_bn<=BN<=inception_3c_double_3x3_1 + id: inception_3c_double_3x3_1_bn +- {expr: inception_3c_double_3x3_1_bn<=ReLU<=inception_3c_double_3x3_1_bn, id: inception_3c_relu_double_3x3_1} +################################################################# +# Start to make 3D network +################################################################# +- attrs: {kernel_size: 3, num_output: 128, pad: 1, stride: 1} + expr: res3a_2<=Conv3d<=inception_3c_double_3x3_1_bn + id: res3a_2 +- attrs: {frozen: false} + expr: res3a_bn<=BN3d<=res3a_2 + id: res3a_bn +- {expr: res3a_bn<=ReLU<=res3a_bn, id: res3a_relu} +- attrs: {kernel_size: 3, num_output: 128, pad: 1, stride: 1} + expr: res3b_1<=Conv3d<=res3a_bn + id: res3b_1 +- attrs: {frozen: false} + expr: res3b_1_bn<=BN3d<=res3b_1 + id: res3b_1_bn +- {expr: res3b_1_bn<=ReLU<=res3b_1_bn, id: res3b_1_relu} +- attrs: {kernel_size: 3, num_output: 128, pad: 1, stride: 1} + expr: res3b_2<=Conv3d<=res3b_1_bn + id: res3b_2 +- {expr: 'res3b<=Eltwise<=res3b_2,res3a_2', id: res3b} +- attrs: {frozen: false} + expr: res3b_bn<=BN3d<=res3b + id: res3b_bn +- {expr: res3b_bn<=ReLU<=res3b_bn, id: res3b_relu} + +- attrs: {kernel_size: 3, num_output: 256, pad: 1, stride: 2} + expr: res4a_1<=Conv3d<=res3b_bn + id: res4a_1 +- attrs: {frozen: false} + expr: res4a_1_bn<=BN3d<=res4a_1 + id: res4a_1_bn +- {expr: res4a_1_bn<=ReLU<=res4a_1_bn, id: res4a_1_relu} +- attrs: {kernel_size: 3, num_output: 256, pad: 1, stride: 1} + expr: res4a_2<=Conv3d<=res4a_1_bn + id: res4a_2 +- attrs: {kernel_size: 3, num_output: 256, pad: 1, stride: 2} + expr: res4a_down<=Conv3d<=res3b_bn + id: res4a_down +- {expr: 'res4a<=Eltwise<=res4a_2,res4a_down', id: res4a} + +- attrs: {frozen: false} + expr: res4a_bn<=BN3d<=res4a + id: res4a_bn +- {expr: res4a_bn<=ReLU<=res4a_bn, id: res4a_relu} +- attrs: {kernel_size: 3, num_output: 256, pad: 1, stride: 1} + expr: res4b_1<=Conv3d<=res4a_bn + id: res4b_1 +- attrs: {frozen: false} + expr: res4b_1_bn<=BN3d<=res4b_1 + id: res4b_1_bn +- {expr: res4b_1_bn<=ReLU<=res4b_1_bn, id: res4b_1_relu} +- attrs: {kernel_size: 3, num_output: 256, pad: 1, stride: 1} + expr: res4b_2<=Conv3d<=res4b_1_bn + id: res4b_2 +- {expr: 'res4b<=Eltwise<=res4b_2,res4a', id: res4b} +- attrs: {frozen: false} + expr: res4b_bn<=BN3d<=res4b + id: res4b_bn +- {expr: res4b_bn<=ReLU<=res4b_bn, id: res4b_relu} + +- attrs: {kernel_size: 3, num_output: 512, pad: 1, stride: 2} + expr: res5a_1<=Conv3d<=res4b_bn + id: res5a_1 +- attrs: {frozen: false} + expr: res5a_1_bn<=BN3d<=res5a_1 + id: res5a_1_bn +- {expr: res5a_1_bn<=ReLU<=res5a_1_bn, id: res5a_1_relu} +- attrs: {kernel_size: 3, num_output: 512, pad: 1, stride: 1} + expr: res5a_2<=Conv3d<=res5a_1_bn + id: res5a_2 +- attrs: {kernel_size: 3, num_output: 512, pad: 1, stride: 2} + expr: res5a_down<=Conv3d<=res4b_bn + id: res5a_down +- {expr: 'res5a<=Eltwise<=res5a_2,res5a_down', id: res5a} + +- attrs: {frozen: false} + expr: res5a_bn<=BN3d<=res5a + id: res5a_bn +- {expr: res5a_bn<=ReLU<=res5a_bn, id: res5a_relu} +- attrs: {kernel_size: 3, num_output: 512, pad: 1, stride: 1} + expr: res5b_1<=Conv3d<=res5a_bn + id: res5b_1 +- attrs: {frozen: false} + expr: res5b_1_bn<=BN3d<=res5b_1 + id: res5b_1_bn +- {expr: res5b_1_bn<=ReLU<=res5b_1_bn, id: res5b_1_relu} +- attrs: {kernel_size: 3, num_output: 512, pad: 1, stride: 1} + expr: res5b_2<=Conv3d<=res5b_1_bn + id: res5b_2 +- {expr: 'res5b<=Eltwise<=res5b_2,res5a', id: res5b} +- attrs: {frozen: false} + expr: res5b_bn<=BN3d<=res5b + id: res5b_bn +- {expr: res5b_bn<=ReLU<=res5b_bn, id: res5b_relu} + +######################## 3D-Net end ######################## + +- attrs: {kernel_size: 3, num_output: 96, pad: 1, stride: 2} + expr: inception_3c_double_3x3_2<=Convolution<=inception_3c_double_3x3_1_bn + id: inception_3c_double_3x3_2 +- attrs: {frozen: true} + expr: inception_3c_double_3x3_2_bn<=BN<=inception_3c_double_3x3_2 + id: inception_3c_double_3x3_2_bn +- {expr: inception_3c_double_3x3_2_bn<=ReLU<=inception_3c_double_3x3_2_bn, id: inception_3c_relu_double_3x3_2} +- attrs: {kernel_size: 3, mode: max, stride: 2} + expr: inception_3c_pool<=Pooling<=inception_3b_output + id: inception_3c_pool +- {expr: 'inception_3c_output<=Concat<=inception_3c_3x3_bn,inception_3c_double_3x3_2_bn,inception_3c_pool', + id: inception_3c_output} +- attrs: {kernel_size: 1, num_output: 224} + expr: inception_4a_1x1<=Convolution<=inception_3c_output + id: inception_4a_1x1 +- attrs: {frozen: true} + expr: inception_4a_1x1_bn<=BN<=inception_4a_1x1 + id: inception_4a_1x1_bn +- {expr: inception_4a_1x1_bn<=ReLU<=inception_4a_1x1_bn, id: inception_4a_relu_1x1} +- attrs: {kernel_size: 1, num_output: 64} + expr: inception_4a_3x3_reduce<=Convolution<=inception_3c_output + id: inception_4a_3x3_reduce +- attrs: {frozen: true} + expr: inception_4a_3x3_reduce_bn<=BN<=inception_4a_3x3_reduce + id: inception_4a_3x3_reduce_bn +- {expr: inception_4a_3x3_reduce_bn<=ReLU<=inception_4a_3x3_reduce_bn, id: inception_4a_relu_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 96, pad: 1} + expr: inception_4a_3x3<=Convolution<=inception_4a_3x3_reduce_bn + id: inception_4a_3x3 +- attrs: {frozen: true} + expr: inception_4a_3x3_bn<=BN<=inception_4a_3x3 + id: inception_4a_3x3_bn +- {expr: inception_4a_3x3_bn<=ReLU<=inception_4a_3x3_bn, id: inception_4a_relu_3x3} +- attrs: {kernel_size: 1, num_output: 96} + expr: inception_4a_double_3x3_reduce<=Convolution<=inception_3c_output + id: inception_4a_double_3x3_reduce +- attrs: {frozen: true} + expr: inception_4a_double_3x3_reduce_bn<=BN<=inception_4a_double_3x3_reduce + id: inception_4a_double_3x3_reduce_bn +- {expr: inception_4a_double_3x3_reduce_bn<=ReLU<=inception_4a_double_3x3_reduce_bn, + id: inception_4a_relu_double_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 128, pad: 1} + expr: inception_4a_double_3x3_1<=Convolution<=inception_4a_double_3x3_reduce_bn + id: inception_4a_double_3x3_1 +- attrs: {frozen: true} + expr: inception_4a_double_3x3_1_bn<=BN<=inception_4a_double_3x3_1 + id: inception_4a_double_3x3_1_bn +- {expr: inception_4a_double_3x3_1_bn<=ReLU<=inception_4a_double_3x3_1_bn, id: inception_4a_relu_double_3x3_1} +- attrs: {kernel_size: 3, num_output: 128, pad: 1} + expr: inception_4a_double_3x3_2<=Convolution<=inception_4a_double_3x3_1_bn + id: inception_4a_double_3x3_2 +- attrs: {frozen: true} + expr: inception_4a_double_3x3_2_bn<=BN<=inception_4a_double_3x3_2 + id: inception_4a_double_3x3_2_bn +- {expr: inception_4a_double_3x3_2_bn<=ReLU<=inception_4a_double_3x3_2_bn, id: inception_4a_relu_double_3x3_2} +- attrs: {kernel_size: 3, mode: ave, pad: 1, stride: 1} + expr: inception_4a_pool<=Pooling<=inception_3c_output + id: inception_4a_pool +- attrs: {kernel_size: 1, num_output: 128} + expr: inception_4a_pool_proj<=Convolution<=inception_4a_pool + id: inception_4a_pool_proj +- attrs: {frozen: true} + expr: inception_4a_pool_proj_bn<=BN<=inception_4a_pool_proj + id: inception_4a_pool_proj_bn +- {expr: inception_4a_pool_proj_bn<=ReLU<=inception_4a_pool_proj_bn, id: inception_4a_relu_pool_proj} +- {expr: 'inception_4a_output<=Concat<=inception_4a_1x1_bn,inception_4a_3x3_bn,inception_4a_double_3x3_2_bn,inception_4a_pool_proj_bn', + id: inception_4a_output} +- attrs: {kernel_size: 1, num_output: 192} + expr: inception_4b_1x1<=Convolution<=inception_4a_output + id: inception_4b_1x1 +- attrs: {frozen: true} + expr: inception_4b_1x1_bn<=BN<=inception_4b_1x1 + id: inception_4b_1x1_bn +- {expr: inception_4b_1x1_bn<=ReLU<=inception_4b_1x1_bn, id: inception_4b_relu_1x1} +- attrs: {kernel_size: 1, num_output: 96} + expr: inception_4b_3x3_reduce<=Convolution<=inception_4a_output + id: inception_4b_3x3_reduce +- attrs: {frozen: true} + expr: inception_4b_3x3_reduce_bn<=BN<=inception_4b_3x3_reduce + id: inception_4b_3x3_reduce_bn +- {expr: inception_4b_3x3_reduce_bn<=ReLU<=inception_4b_3x3_reduce_bn, id: inception_4b_relu_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 128, pad: 1} + expr: inception_4b_3x3<=Convolution<=inception_4b_3x3_reduce_bn + id: inception_4b_3x3 +- attrs: {frozen: true} + expr: inception_4b_3x3_bn<=BN<=inception_4b_3x3 + id: inception_4b_3x3_bn +- {expr: inception_4b_3x3_bn<=ReLU<=inception_4b_3x3_bn, id: inception_4b_relu_3x3} +- attrs: {kernel_size: 1, num_output: 96} + expr: inception_4b_double_3x3_reduce<=Convolution<=inception_4a_output + id: inception_4b_double_3x3_reduce +- attrs: {frozen: true} + expr: inception_4b_double_3x3_reduce_bn<=BN<=inception_4b_double_3x3_reduce + id: inception_4b_double_3x3_reduce_bn +- {expr: inception_4b_double_3x3_reduce_bn<=ReLU<=inception_4b_double_3x3_reduce_bn, + id: inception_4b_relu_double_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 128, pad: 1} + expr: inception_4b_double_3x3_1<=Convolution<=inception_4b_double_3x3_reduce_bn + id: inception_4b_double_3x3_1 +- attrs: {frozen: true} + expr: inception_4b_double_3x3_1_bn<=BN<=inception_4b_double_3x3_1 + id: inception_4b_double_3x3_1_bn +- {expr: inception_4b_double_3x3_1_bn<=ReLU<=inception_4b_double_3x3_1_bn, id: inception_4b_relu_double_3x3_1} +- attrs: {kernel_size: 3, num_output: 128, pad: 1} + expr: inception_4b_double_3x3_2<=Convolution<=inception_4b_double_3x3_1_bn + id: inception_4b_double_3x3_2 +- attrs: {frozen: true} + expr: inception_4b_double_3x3_2_bn<=BN<=inception_4b_double_3x3_2 + id: inception_4b_double_3x3_2_bn +- {expr: inception_4b_double_3x3_2_bn<=ReLU<=inception_4b_double_3x3_2_bn, id: inception_4b_relu_double_3x3_2} +- attrs: {kernel_size: 3, mode: ave, pad: 1, stride: 1} + expr: inception_4b_pool<=Pooling<=inception_4a_output + id: inception_4b_pool +- attrs: {kernel_size: 1, num_output: 128} + expr: inception_4b_pool_proj<=Convolution<=inception_4b_pool + id: inception_4b_pool_proj +- attrs: {frozen: true} + expr: inception_4b_pool_proj_bn<=BN<=inception_4b_pool_proj + id: inception_4b_pool_proj_bn +- {expr: inception_4b_pool_proj_bn<=ReLU<=inception_4b_pool_proj_bn, id: inception_4b_relu_pool_proj} +- {expr: 'inception_4b_output<=Concat<=inception_4b_1x1_bn,inception_4b_3x3_bn,inception_4b_double_3x3_2_bn,inception_4b_pool_proj_bn', + id: inception_4b_output} +- attrs: {kernel_size: 1, num_output: 160} + expr: inception_4c_1x1<=Convolution<=inception_4b_output + id: inception_4c_1x1 +- attrs: {frozen: true} + expr: inception_4c_1x1_bn<=BN<=inception_4c_1x1 + id: inception_4c_1x1_bn +- {expr: inception_4c_1x1_bn<=ReLU<=inception_4c_1x1_bn, id: inception_4c_relu_1x1} +- attrs: {kernel_size: 1, num_output: 128} + expr: inception_4c_3x3_reduce<=Convolution<=inception_4b_output + id: inception_4c_3x3_reduce +- attrs: {frozen: true} + expr: inception_4c_3x3_reduce_bn<=BN<=inception_4c_3x3_reduce + id: inception_4c_3x3_reduce_bn +- {expr: inception_4c_3x3_reduce_bn<=ReLU<=inception_4c_3x3_reduce_bn, id: inception_4c_relu_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 160, pad: 1} + expr: inception_4c_3x3<=Convolution<=inception_4c_3x3_reduce_bn + id: inception_4c_3x3 +- attrs: {frozen: true} + expr: inception_4c_3x3_bn<=BN<=inception_4c_3x3 + id: inception_4c_3x3_bn +- {expr: inception_4c_3x3_bn<=ReLU<=inception_4c_3x3_bn, id: inception_4c_relu_3x3} +- attrs: {kernel_size: 1, num_output: 128} + expr: inception_4c_double_3x3_reduce<=Convolution<=inception_4b_output + id: inception_4c_double_3x3_reduce +- attrs: {frozen: true} + expr: inception_4c_double_3x3_reduce_bn<=BN<=inception_4c_double_3x3_reduce + id: inception_4c_double_3x3_reduce_bn +- {expr: inception_4c_double_3x3_reduce_bn<=ReLU<=inception_4c_double_3x3_reduce_bn, + id: inception_4c_relu_double_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 160, pad: 1} + expr: inception_4c_double_3x3_1<=Convolution<=inception_4c_double_3x3_reduce_bn + id: inception_4c_double_3x3_1 +- attrs: {frozen: true} + expr: inception_4c_double_3x3_1_bn<=BN<=inception_4c_double_3x3_1 + id: inception_4c_double_3x3_1_bn +- {expr: inception_4c_double_3x3_1_bn<=ReLU<=inception_4c_double_3x3_1_bn, id: inception_4c_relu_double_3x3_1} +- attrs: {kernel_size: 3, num_output: 160, pad: 1} + expr: inception_4c_double_3x3_2<=Convolution<=inception_4c_double_3x3_1_bn + id: inception_4c_double_3x3_2 +- attrs: {frozen: true} + expr: inception_4c_double_3x3_2_bn<=BN<=inception_4c_double_3x3_2 + id: inception_4c_double_3x3_2_bn +- {expr: inception_4c_double_3x3_2_bn<=ReLU<=inception_4c_double_3x3_2_bn, id: inception_4c_relu_double_3x3_2} +- attrs: {kernel_size: 3, mode: ave, pad: 1, stride: 1} + expr: inception_4c_pool<=Pooling<=inception_4b_output + id: inception_4c_pool +- attrs: {kernel_size: 1, num_output: 128} + expr: inception_4c_pool_proj<=Convolution<=inception_4c_pool + id: inception_4c_pool_proj +- attrs: {frozen: true} + expr: inception_4c_pool_proj_bn<=BN<=inception_4c_pool_proj + id: inception_4c_pool_proj_bn +- {expr: inception_4c_pool_proj_bn<=ReLU<=inception_4c_pool_proj_bn, id: inception_4c_relu_pool_proj} +- {expr: 'inception_4c_output<=Concat<=inception_4c_1x1_bn,inception_4c_3x3_bn,inception_4c_double_3x3_2_bn,inception_4c_pool_proj_bn', + id: inception_4c_output} +- attrs: {kernel_size: 1, num_output: 96} + expr: inception_4d_1x1<=Convolution<=inception_4c_output + id: inception_4d_1x1 +- attrs: {frozen: true} + expr: inception_4d_1x1_bn<=BN<=inception_4d_1x1 + id: inception_4d_1x1_bn +- {expr: inception_4d_1x1_bn<=ReLU<=inception_4d_1x1_bn, id: inception_4d_relu_1x1} +- attrs: {kernel_size: 1, num_output: 128} + expr: inception_4d_3x3_reduce<=Convolution<=inception_4c_output + id: inception_4d_3x3_reduce +- attrs: {frozen: true} + expr: inception_4d_3x3_reduce_bn<=BN<=inception_4d_3x3_reduce + id: inception_4d_3x3_reduce_bn +- {expr: inception_4d_3x3_reduce_bn<=ReLU<=inception_4d_3x3_reduce_bn, id: inception_4d_relu_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 192, pad: 1} + expr: inception_4d_3x3<=Convolution<=inception_4d_3x3_reduce_bn + id: inception_4d_3x3 +- attrs: {frozen: true} + expr: inception_4d_3x3_bn<=BN<=inception_4d_3x3 + id: inception_4d_3x3_bn +- {expr: inception_4d_3x3_bn<=ReLU<=inception_4d_3x3_bn, id: inception_4d_relu_3x3} +- attrs: {kernel_size: 1, num_output: 160} + expr: inception_4d_double_3x3_reduce<=Convolution<=inception_4c_output + id: inception_4d_double_3x3_reduce +- attrs: {frozen: true} + expr: inception_4d_double_3x3_reduce_bn<=BN<=inception_4d_double_3x3_reduce + id: inception_4d_double_3x3_reduce_bn +- {expr: inception_4d_double_3x3_reduce_bn<=ReLU<=inception_4d_double_3x3_reduce_bn, + id: inception_4d_relu_double_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 192, pad: 1} + expr: inception_4d_double_3x3_1<=Convolution<=inception_4d_double_3x3_reduce_bn + id: inception_4d_double_3x3_1 +- attrs: {frozen: true} + expr: inception_4d_double_3x3_1_bn<=BN<=inception_4d_double_3x3_1 + id: inception_4d_double_3x3_1_bn +- {expr: inception_4d_double_3x3_1_bn<=ReLU<=inception_4d_double_3x3_1_bn, id: inception_4d_relu_double_3x3_1} +- attrs: {kernel_size: 3, num_output: 192, pad: 1} + expr: inception_4d_double_3x3_2<=Convolution<=inception_4d_double_3x3_1_bn + id: inception_4d_double_3x3_2 +- attrs: {frozen: true} + expr: inception_4d_double_3x3_2_bn<=BN<=inception_4d_double_3x3_2 + id: inception_4d_double_3x3_2_bn +- {expr: inception_4d_double_3x3_2_bn<=ReLU<=inception_4d_double_3x3_2_bn, id: inception_4d_relu_double_3x3_2} +- attrs: {kernel_size: 3, mode: ave, pad: 1, stride: 1} + expr: inception_4d_pool<=Pooling<=inception_4c_output + id: inception_4d_pool +- attrs: {kernel_size: 1, num_output: 128} + expr: inception_4d_pool_proj<=Convolution<=inception_4d_pool + id: inception_4d_pool_proj +- attrs: {frozen: true} + expr: inception_4d_pool_proj_bn<=BN<=inception_4d_pool_proj + id: inception_4d_pool_proj_bn +- {expr: inception_4d_pool_proj_bn<=ReLU<=inception_4d_pool_proj_bn, id: inception_4d_relu_pool_proj} +- {expr: 'inception_4d_output<=Concat<=inception_4d_1x1_bn,inception_4d_3x3_bn,inception_4d_double_3x3_2_bn,inception_4d_pool_proj_bn', + id: inception_4d_output} +- attrs: {kernel_size: 1, num_output: 128} + expr: inception_4e_3x3_reduce<=Convolution<=inception_4d_output + id: inception_4e_3x3_reduce +- attrs: {frozen: true} + expr: inception_4e_3x3_reduce_bn<=BN<=inception_4e_3x3_reduce + id: inception_4e_3x3_reduce_bn +- {expr: inception_4e_3x3_reduce_bn<=ReLU<=inception_4e_3x3_reduce_bn, id: inception_4e_relu_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 192, pad: 1, stride: 2} + expr: inception_4e_3x3<=Convolution<=inception_4e_3x3_reduce_bn + id: inception_4e_3x3 +- attrs: {frozen: true} + expr: inception_4e_3x3_bn<=BN<=inception_4e_3x3 + id: inception_4e_3x3_bn +- {expr: inception_4e_3x3_bn<=ReLU<=inception_4e_3x3_bn, id: inception_4e_relu_3x3} +- attrs: {kernel_size: 1, num_output: 192} + expr: inception_4e_double_3x3_reduce<=Convolution<=inception_4d_output + id: inception_4e_double_3x3_reduce +- attrs: {frozen: true} + expr: inception_4e_double_3x3_reduce_bn<=BN<=inception_4e_double_3x3_reduce + id: inception_4e_double_3x3_reduce_bn +- {expr: inception_4e_double_3x3_reduce_bn<=ReLU<=inception_4e_double_3x3_reduce_bn, + id: inception_4e_relu_double_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 256, pad: 1} + expr: inception_4e_double_3x3_1<=Convolution<=inception_4e_double_3x3_reduce_bn + id: inception_4e_double_3x3_1 +- attrs: {frozen: true} + expr: inception_4e_double_3x3_1_bn<=BN<=inception_4e_double_3x3_1 + id: inception_4e_double_3x3_1_bn +- {expr: inception_4e_double_3x3_1_bn<=ReLU<=inception_4e_double_3x3_1_bn, id: inception_4e_relu_double_3x3_1} +- attrs: {kernel_size: 3, num_output: 256, pad: 1, stride: 2} + expr: inception_4e_double_3x3_2<=Convolution<=inception_4e_double_3x3_1_bn + id: inception_4e_double_3x3_2 +- attrs: {frozen: true} + expr: inception_4e_double_3x3_2_bn<=BN<=inception_4e_double_3x3_2 + id: inception_4e_double_3x3_2_bn +- {expr: inception_4e_double_3x3_2_bn<=ReLU<=inception_4e_double_3x3_2_bn, id: inception_4e_relu_double_3x3_2} +- attrs: {kernel_size: 3, mode: max, stride: 2} + expr: inception_4e_pool<=Pooling<=inception_4d_output + id: inception_4e_pool +- {expr: 'inception_4e_output<=Concat<=inception_4e_3x3_bn,inception_4e_double_3x3_2_bn,inception_4e_pool', + id: inception_4e_output} +- attrs: {kernel_size: 1, num_output: 352} + expr: inception_5a_1x1<=Convolution<=inception_4e_output + id: inception_5a_1x1 +- attrs: {frozen: true} + expr: inception_5a_1x1_bn<=BN<=inception_5a_1x1 + id: inception_5a_1x1_bn +- {expr: inception_5a_1x1_bn<=ReLU<=inception_5a_1x1_bn, id: inception_5a_relu_1x1} +- attrs: {kernel_size: 1, num_output: 192} + expr: inception_5a_3x3_reduce<=Convolution<=inception_4e_output + id: inception_5a_3x3_reduce +- attrs: {frozen: true} + expr: inception_5a_3x3_reduce_bn<=BN<=inception_5a_3x3_reduce + id: inception_5a_3x3_reduce_bn +- {expr: inception_5a_3x3_reduce_bn<=ReLU<=inception_5a_3x3_reduce_bn, id: inception_5a_relu_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 320, pad: 1} + expr: inception_5a_3x3<=Convolution<=inception_5a_3x3_reduce_bn + id: inception_5a_3x3 +- attrs: {frozen: true} + expr: inception_5a_3x3_bn<=BN<=inception_5a_3x3 + id: inception_5a_3x3_bn +- {expr: inception_5a_3x3_bn<=ReLU<=inception_5a_3x3_bn, id: inception_5a_relu_3x3} +- attrs: {kernel_size: 1, num_output: 160} + expr: inception_5a_double_3x3_reduce<=Convolution<=inception_4e_output + id: inception_5a_double_3x3_reduce +- attrs: {frozen: true} + expr: inception_5a_double_3x3_reduce_bn<=BN<=inception_5a_double_3x3_reduce + id: inception_5a_double_3x3_reduce_bn +- {expr: inception_5a_double_3x3_reduce_bn<=ReLU<=inception_5a_double_3x3_reduce_bn, + id: inception_5a_relu_double_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 224, pad: 1} + expr: inception_5a_double_3x3_1<=Convolution<=inception_5a_double_3x3_reduce_bn + id: inception_5a_double_3x3_1 +- attrs: {frozen: true} + expr: inception_5a_double_3x3_1_bn<=BN<=inception_5a_double_3x3_1 + id: inception_5a_double_3x3_1_bn +- {expr: inception_5a_double_3x3_1_bn<=ReLU<=inception_5a_double_3x3_1_bn, id: inception_5a_relu_double_3x3_1} +- attrs: {kernel_size: 3, num_output: 224, pad: 1} + expr: inception_5a_double_3x3_2<=Convolution<=inception_5a_double_3x3_1_bn + id: inception_5a_double_3x3_2 +- attrs: {frozen: true} + expr: inception_5a_double_3x3_2_bn<=BN<=inception_5a_double_3x3_2 + id: inception_5a_double_3x3_2_bn +- {expr: inception_5a_double_3x3_2_bn<=ReLU<=inception_5a_double_3x3_2_bn, id: inception_5a_relu_double_3x3_2} +- attrs: {kernel_size: 3, mode: ave, pad: 1, stride: 1} + expr: inception_5a_pool<=Pooling<=inception_4e_output + id: inception_5a_pool +- attrs: {kernel_size: 1, num_output: 128} + expr: inception_5a_pool_proj<=Convolution<=inception_5a_pool + id: inception_5a_pool_proj +- attrs: {frozen: true} + expr: inception_5a_pool_proj_bn<=BN<=inception_5a_pool_proj + id: inception_5a_pool_proj_bn +- {expr: inception_5a_pool_proj_bn<=ReLU<=inception_5a_pool_proj_bn, id: inception_5a_relu_pool_proj} +- {expr: 'inception_5a_output<=Concat<=inception_5a_1x1_bn,inception_5a_3x3_bn,inception_5a_double_3x3_2_bn,inception_5a_pool_proj_bn', + id: inception_5a_output} +- attrs: {kernel_size: 1, num_output: 352} + expr: inception_5b_1x1<=Convolution<=inception_5a_output + id: inception_5b_1x1 +- attrs: {frozen: true} + expr: inception_5b_1x1_bn<=BN<=inception_5b_1x1 + id: inception_5b_1x1_bn +- {expr: inception_5b_1x1_bn<=ReLU<=inception_5b_1x1_bn, id: inception_5b_relu_1x1} +- attrs: {kernel_size: 1, num_output: 192} + expr: inception_5b_3x3_reduce<=Convolution<=inception_5a_output + id: inception_5b_3x3_reduce +- attrs: {frozen: true} + expr: inception_5b_3x3_reduce_bn<=BN<=inception_5b_3x3_reduce + id: inception_5b_3x3_reduce_bn +- {expr: inception_5b_3x3_reduce_bn<=ReLU<=inception_5b_3x3_reduce_bn, id: inception_5b_relu_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 320, pad: 1} + expr: inception_5b_3x3<=Convolution<=inception_5b_3x3_reduce_bn + id: inception_5b_3x3 +- attrs: {frozen: true} + expr: inception_5b_3x3_bn<=BN<=inception_5b_3x3 + id: inception_5b_3x3_bn +- {expr: inception_5b_3x3_bn<=ReLU<=inception_5b_3x3_bn, id: inception_5b_relu_3x3} +- attrs: {kernel_size: 1, num_output: 192} + expr: inception_5b_double_3x3_reduce<=Convolution<=inception_5a_output + id: inception_5b_double_3x3_reduce +- attrs: {frozen: true} + expr: inception_5b_double_3x3_reduce_bn<=BN<=inception_5b_double_3x3_reduce + id: inception_5b_double_3x3_reduce_bn +- {expr: inception_5b_double_3x3_reduce_bn<=ReLU<=inception_5b_double_3x3_reduce_bn, + id: inception_5b_relu_double_3x3_reduce} +- attrs: {kernel_size: 3, num_output: 224, pad: 1} + expr: inception_5b_double_3x3_1<=Convolution<=inception_5b_double_3x3_reduce_bn + id: inception_5b_double_3x3_1 +- attrs: {frozen: true} + expr: inception_5b_double_3x3_1_bn<=BN<=inception_5b_double_3x3_1 + id: inception_5b_double_3x3_1_bn +- {expr: inception_5b_double_3x3_1_bn<=ReLU<=inception_5b_double_3x3_1_bn, id: inception_5b_relu_double_3x3_1} +- attrs: {kernel_size: 3, num_output: 224, pad: 1} + expr: inception_5b_double_3x3_2<=Convolution<=inception_5b_double_3x3_1_bn + id: inception_5b_double_3x3_2 +- attrs: {frozen: true} + expr: inception_5b_double_3x3_2_bn<=BN<=inception_5b_double_3x3_2 + id: inception_5b_double_3x3_2_bn +- {expr: inception_5b_double_3x3_2_bn<=ReLU<=inception_5b_double_3x3_2_bn, id: inception_5b_relu_double_3x3_2} +- attrs: {kernel_size: 3, mode: max, pad: 1, stride: 1} + expr: inception_5b_pool<=Pooling<=inception_5a_output + id: inception_5b_pool +- attrs: {kernel_size: 1, num_output: 128} + expr: inception_5b_pool_proj<=Convolution<=inception_5b_pool + id: inception_5b_pool_proj +- attrs: {frozen: true} + expr: inception_5b_pool_proj_bn<=BN<=inception_5b_pool_proj + id: inception_5b_pool_proj_bn +- {expr: inception_5b_pool_proj_bn<=ReLU<=inception_5b_pool_proj_bn, id: inception_5b_relu_pool_proj} +- {expr: 'inception_5b_output<=Concat<=inception_5b_1x1_bn,inception_5b_3x3_bn,inception_5b_double_3x3_2_bn,inception_5b_pool_proj_bn', + id: inception_5b_output} + +- attrs: {kernel_size: 7, mode: ave, stride: 1} + expr: global_pool2D_pre<=Pooling<=inception_5b_output + id: global_pool2D_pre +- attrs: {dropout_ratio: 0.5} + expr: global_pool2D_pre<=Dropout<=global_pool2D_pre + id: global_pool2D_pre_drop + +- attrs: {kernel_d: 'N/1', kernel_h: 1, kernel_w: 1, stride: 1, mode: ave} + expr: global_pool2D_reshape_consensus<=Pooling3d<=global_pool2D_pre + id: global_pool2D_reshape_consensus + +- attrs: {kernel_d: 'N/4', kernel_h: 7, kernel_w: 7, stride: 1, mode: ave} + expr: global_pool3D<=Pooling3d<=res5b_bn + id: global_pool3D +- attrs: {dropout_ratio: 0.3} + expr: global_pool3D<=Dropout<=global_pool3D + id: global_pool3D_drop + + +- {expr: 'global_pool<=Concat<=global_pool2D_reshape_consensus,global_pool3D', + id: global_pool} + +- attrs: {num_output: 400} + expr: fc_action<=InnerProduct<=global_pool + id: fc_final +name: ECOfull diff --git a/autovideo/recognition/eco_utils/eco_full/__init__.py b/autovideo/recognition/eco_utils/eco_full/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/autovideo/recognition/eco_utils/eco_full/layer_factory.py b/autovideo/recognition/eco_utils/eco_full/layer_factory.py new file mode 100644 index 0000000..cd5cee9 --- /dev/null +++ b/autovideo/recognition/eco_utils/eco_full/layer_factory.py @@ -0,0 +1,136 @@ +import torch +from torch import nn + + +LAYER_BUILDER_DICT=dict() + + +def parse_expr(expr): + parts = expr.split('<=') + return parts[0].split(','), parts[1], parts[2].split(',') + + +def get_basic_layer(info, channels=None, conv_bias=False, num_segments=4): + id = info['id'] + + attr = info['attrs'] if 'attrs' in info else dict() + if 'kernel_d' in attr.keys(): + if isinstance(attr["kernel_d"], str): + div_num = int(attr["kernel_d"].split("/")[-1]) + attr['kernel_d'] = int(num_segments / div_num) + + out, op, in_vars = parse_expr(info['expr']) + assert(len(out) == 1) + assert(len(in_vars) == 1) + mod, out_channel, = LAYER_BUILDER_DICT[op](attr, channels, conv_bias) + + return id, out[0], mod, out_channel, in_vars[0] + + +def build_conv(attr, channels=None, conv_bias=False): + out_channels = attr['num_output'] + ks = attr['kernel_size'] if 'kernel_size' in attr else (attr['kernel_h'], attr['kernel_w']) + if 'pad' in attr or 'pad_w' in attr and 'pad_h' in attr: + padding = attr['pad'] if 'pad' in attr else (attr['pad_h'], attr['pad_w']) + else: + padding = 0 + if 'stride' in attr or 'stride_w' in attr and 'stride_h' in attr: + stride = attr['stride'] if 'stride' in attr else (attr['stride_h'], attr['stride_w']) + else: + stride = 1 + + conv = nn.Conv2d(channels, out_channels, ks, stride, padding, bias=conv_bias) + + return conv, out_channels + + +def build_pooling(attr, channels=None, conv_bias=False): + method = attr['mode'] + pad = attr['pad'] if 'pad' in attr else 0 + if method == 'max': + pool = nn.MaxPool2d(attr['kernel_size'], attr['stride'], pad, + ceil_mode=True) # all Caffe pooling use ceil model + elif method == 'ave': + pool = nn.AvgPool2d(attr['kernel_size'], attr['stride'], pad, + ceil_mode=True) # all Caffe pooling use ceil model + else: + raise ValueError("Unknown pooling method: {}".format(method)) + + return pool, channels + + +def build_relu(attr, channels=None, conv_bias=False): + return nn.ReLU(inplace=True), channels + + +def build_bn(attr, channels=None, conv_bias=False): + return nn.BatchNorm2d(channels, momentum=0.1), channels + + +def build_linear(attr, channels=None, conv_bias=False): + return nn.Linear(channels, attr['num_output']), channels + + +def build_dropout(attr, channels=None, conv_bias=False): + return nn.Dropout(p=attr['dropout_ratio']), channels + +def build_conv3d(attr, channels=None, conv_bias=False): + out_channels = attr['num_output'] + ks = attr['kernel_size'] if 'kernel_size' in attr else (attr['kernel_d'], attr['kernel_h'], attr['kernel_w']) + if ('pad' in attr) or ('pad_d' in attr and 'pad_w' in attr and 'pad_h' in attr): + padding = attr['pad'] if 'pad' in attr else (attr['pad_d'], attr['pad_h'], attr['pad_w']) + else: + padding = 0 + if ('stride' in attr) or ('stride_d' in attr and 'stride_w' in attr and 'stride_h' in attr): + stride = attr['stride'] if 'stride' in attr else (attr['stride_d'], attr['stride_h'], attr['stride_w']) + else: + stride = 1 + + conv = nn.Conv3d(channels, out_channels, ks, stride, padding, bias=conv_bias) + + return conv, out_channels + +def build_pooling3d(attr, channels=None, conv_bias=False): + method = attr['mode'] + ks = attr['kernel_size'] if 'kernel_size' in attr else (attr['kernel_d'], attr['kernel_h'], attr['kernel_w']) + if ('pad' in attr) or ('pad_d' in attr and 'pad_w' in attr and 'pad_h' in attr): + padding = attr['pad'] if 'pad' in attr else (attr['pad_d'], attr['pad_h'], attr['pad_w']) + else: + padding = 0 + if ('stride' in attr) or ('stride_d' in attr and 'stride_w' in attr and 'stride_h' in attr): + stride = attr['stride'] if 'stride' in attr else (attr['stride_d'], attr['stride_h'], attr['stride_w']) + else: + stride = 1 + if method == 'max': + pool = nn.MaxPool3d(ks, stride, padding, + ceil_mode=True) # all Caffe pooling use ceil model + elif method == 'ave': + pool = nn.AvgPool3d(ks, stride, padding, + ceil_mode=True) # all Caffe pooling use ceil model + else: + raise ValueError("Unknown pooling method: {}".format(method)) + + return pool, channels + +def build_bn3d(attr, channels=None, conv_bias=False): + return nn.BatchNorm3d(channels, momentum=0.1), channels + + +LAYER_BUILDER_DICT['Convolution'] = build_conv + +LAYER_BUILDER_DICT['Pooling'] = build_pooling + +LAYER_BUILDER_DICT['ReLU'] = build_relu + +LAYER_BUILDER_DICT['Dropout'] = build_dropout + +LAYER_BUILDER_DICT['BN'] = build_bn + +LAYER_BUILDER_DICT['InnerProduct'] = build_linear + +LAYER_BUILDER_DICT['Conv3d'] = build_conv3d + +LAYER_BUILDER_DICT['Pooling3d'] = build_pooling3d + +LAYER_BUILDER_DICT['BN3d'] = build_bn3d + diff --git a/autovideo/recognition/eco_utils/eco_full/pytorch_load.py b/autovideo/recognition/eco_utils/eco_full/pytorch_load.py new file mode 100644 index 0000000..cc94593 --- /dev/null +++ b/autovideo/recognition/eco_utils/eco_full/pytorch_load.py @@ -0,0 +1,95 @@ +import os + +import torch +from torch import nn +from .layer_factory import get_basic_layer, parse_expr +import torch.utils.model_zoo as model_zoo +import yaml + +import autovideo +ROOT_PATH = autovideo.__path__[0] +MODEL_PATH = os.path.join(ROOT_PATH, 'recognition/eco_utils/eco_full/ECOFull.yaml') + +class ECOFullModel(nn.Module): + def __init__(self, model_path=MODEL_PATH, num_classes=101, + num_segments=4, pretrained_parts='both'): + + super(ECOFullModel, self).__init__() + + self.num_segments = num_segments + + self.pretrained_parts = pretrained_parts + + manifest = yaml.load(open(model_path)) + + layers = manifest['layers'] + + self._channel_dict = dict() + + self._op_list = list() + for l in layers: + out_var, op, in_var = parse_expr(l['expr']) + if op != 'Concat' and op != 'Eltwise': + id, out_name, module, out_channel, in_name = get_basic_layer(l, + 3 if len(self._channel_dict) == 0 else self._channel_dict[in_var[0]], + conv_bias=True if op == 'Conv3d' else True, num_segments=num_segments) + + self._channel_dict[out_name] = out_channel + setattr(self, id, module) + self._op_list.append((id, op, out_name, in_name)) + elif op == 'Concat': + self._op_list.append((id, op, out_var[0], in_var)) + channel = sum([self._channel_dict[x] for x in in_var]) + self._channel_dict[out_var[0]] = channel + else: + self._op_list.append((id, op, out_var[0], in_var)) + channel = self._channel_dict[in_var[0]] + self._channel_dict[out_var[0]] = channel + + + def forward(self, input): + data_dict = dict() + data_dict[self._op_list[0][-1]] = input + + def get_hook(name): + + def hook(m, grad_in, grad_out): + print(name, grad_out[0].data.abs().mean()) + + return hook + for op in self._op_list: + if op[1] != 'Concat' and op[1] != 'InnerProduct' and op[1] != 'Eltwise': + # first 3d conv layer judge, the last 2d conv layer's output must be transpose from 4d to 5d + if op[0] == 'res3a_2' or op[0] == 'global_pool2D_reshape_consensus': + layer_output = data_dict[op[-1]] + layer_transpose_output = torch.transpose(layer_output.view((-1, self.num_segments) + layer_output.size()[1:]), 1, 2) + data_dict[op[2]] = getattr(self, op[0])(layer_transpose_output) + else: + data_dict[op[2]] = getattr(self, op[0])(data_dict[op[-1]]) + # getattr(self, op[0]).register_backward_hook(get_hook(op[0])) + elif op[1] == 'InnerProduct': + x = data_dict[op[-1]] + data_dict[op[2]] = getattr(self, op[0])(x.view(x.size(0), -1)) + elif op[1] == 'Eltwise': + try: + data_dict[op[2]] = torch.add(data_dict[op[-1][0]], 1, data_dict[op[-1][1]]) + except: + for x in op[-1]: + print(x,data_dict[x].size()) + raise + # x = data_dict[op[-1]] + # data_dict[op[2]] = getattr(self, op[0])(x.view(x.size(0), -1)) + else: + try: + data_dict[op[2]] = torch.cat(tuple(data_dict[x] for x in op[-1]), 1) + except: + for x in op[-1]: + print(x,data_dict[x].size()) + raise + # print output data size in each layers + # for k in data_dict.keys(): + # print(k,": ",data_dict[k].size()) + # exit() + + # "self._op_list[-1][2]" represents: last layer's name(e.g. fc_action) + return data_dict[self._op_list[-1][2]] diff --git a/autovideo/recognition/i3d_primitive.py b/autovideo/recognition/i3d_primitive.py new file mode 100644 index 0000000..a5d34fe --- /dev/null +++ b/autovideo/recognition/i3d_primitive.py @@ -0,0 +1,771 @@ +import math + +import os +import numpy as np +import uuid +from urllib.parse import urlparse + +from d3m import container +from d3m.metadata import hyperparams +from d3m.primitive_interfaces.base import CallResult + +import torch +from torch.hub import load_state_dict_from_url +import torch.nn.functional as F + +from autovideo.base.supervised_base import SupervisedParamsBase, SupervisedHyperparamsBase, SupervisedPrimitiveBase +from autovideo.utils.transforms import * +from autovideo.utils import wrap_predictions, construct_primitive_metadata, compute_accuracy, make_predictions, get_frame_list, get_video_loader, adjust_learning_rate, logger + +# The pretrained model is from https://github.com/hassony2/kinetics_i3d_pytorch/blob/master/model/model_rgb.pth +pretrained_url = "https://i3d.s3.us-east-2.amazonaws.com/model_rgb-9729d6f0.pth" + +__all__ = ('I3DPrimitive',) +Inputs = container.DataFrame +Outputs = container.DataFrame + + +class Params(SupervisedParamsBase): + pass + +class Hyperparams(SupervisedHyperparamsBase): + num_workers = hyperparams.Hyperparameter[int]( + semantic_types=['https://metadata.datadrivendiscovery.org/types/ResourcesUseParameter'], + default=2, + description='The number of subprocesses to use for data loading. 0 means that the data will be loaded in the ' + 'main process.' + ) + batch_size = hyperparams.Hyperparameter[int]( + default=2, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The batch size of training" + ) + epochs = hyperparams.Hyperparameter[int]( + default=50, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="How many epochs to be trained" + ) + learning_rate = hyperparams.Hyperparameter[float]( + default=0.01, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The learning rate of the optimizer" + ) + momentum = hyperparams.Hyperparameter[float]( + default=0.9, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The momentum of the optimizer" + ) + weight_decay = hyperparams.Hyperparameter[float]( + default=1e-7, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The learning rate of the optimizer" + ) + num_segments = hyperparams.Hyperparameter[int]( + default=3, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The number of segments of frames in each video per training loop" + ) + valid_ratio = hyperparams.Hyperparameter[float]( + default=0.05, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The ratio of validation data" + ) + modality = hyperparams.Enumeration( + values=['RGB', 'Flow'], + default='RGB', + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="The modality of input data to be used for the model", + ) + down_rate = hyperparams.Hyperparameter[int]( + default=1, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The down rate" + ) + dropout_prob = hyperparams.Hyperparameter[float]( + default=0.5, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The dropout probability" + ) + num_steps_per_update = hyperparams.Hyperparameter[int]( + default=4, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The num_steps to update weights" + ) + +class I3DPrimitive(SupervisedPrimitiveBase[Inputs, Outputs, Params, Hyperparams]): + """ + Implementation of I3D + """ + metadata = construct_primitive_metadata('recognition', 'i3d') + + def get_params(self) -> Params: + return super().get_params() + + def set_params(self, *, params: Params) -> None: + super().set_params(params=params) + + def _fit(self, *, timeout: float = None, iterations: int = None): + """ + Training + """ + #Randomly split 5% data for validation + frame_list = np.array(get_frame_list(self._media_dir, self._inputs, self._outputs)) + idx = np.array([i for i in range(len(frame_list))]) + np.random.shuffle(idx) + train_idx, valid_idx = idx[:int(len(idx)*(1-self.hyperparams['valid_ratio']))], idx[int(len(idx)*(1-self.hyperparams['valid_ratio'])):] + train_list, valid_list = frame_list[train_idx], frame_list[valid_idx] + + # Get optimizer and loss + #root.error('Using Adam optimizer') + optimizer = torch.optim.Adam(self.model.parameters(), + lr=self.hyperparams['learning_rate'], + betas=(0.5, 0.999), + weight_decay=self.hyperparams['weight_decay']) + # root.error('Using SGD optimizer') + # optimizer = torch.optim.SGD(self.model.parameters(), + # self.hyperparams['learning_rate'], + # momentum=self.hyperparams['momentum'], + # weight_decay=self.hyperparams['weight_decay']) + # criterion = F.binary_cross_entropy_with_logits + criterion = torch.nn.CrossEntropyLoss() + + #Create Dataloaders + train_loader = get_video_loader(video_list=train_list, + crop_size=self.model.crop_size, + scale_size=self.model.scale_size, + input_mean=self.model.input_mean, + input_std=self.model.input_std, + train_augmentation=True, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=True, + input_format="NCTHW") + valid_loader = get_video_loader(video_list=valid_list, + crop_size=self.model.crop_size, + scale_size=self.model.scale_size, + input_mean=self.model.input_mean, + input_std=self.model.input_std, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=False, + input_format="NCTHW") + + #root.error('hyperparams {}'.format(self.hyperparams)) + best_valid_acc = 0.0 + total_steps = self.hyperparams['epochs'] * len(train_loader) + num_steps_per_update = self.hyperparams['num_steps_per_update'] + s1, s2 = 0.125 / num_steps_per_update, 0.375 / num_steps_per_update + lr_steps = [int(total_steps * s1), int(total_steps * s2)] #Steps after which lr decays by a factor of 10 + #root.error('lr_steps: {}, total_steps: {}, num_steps_per_update: {}'.format(lr_steps, total_steps, + num_steps_per_update)) + lr_sched = torch.optim.lr_scheduler.MultiStepLR(optimizer, lr_steps) + tmp_file_path = os.path.join(self.tmp_dir, str(uuid.uuid4())) + #root.error('tmp: {}'.format(tmp_file_path)) + + #Training Loop + for epoch in range(self.hyperparams['epochs']): + self.model.train() + num_iter = 0 + + #Iterate over a batch of videos with num_segments in each video + for i, (inputs,target) in enumerate(train_loader): + num_iter += 1 + inputs = inputs.to(self.device) + target = target.to(self.device) + # labels = self._augment_targets(target) + + per_frame_logits = self.model(inputs) + # upsample to input size + # per_frame_logits = F.upsample(per_frame_logits, self.hyperparams['num_segments'], mode='linear') + + # compute localization loss + # loc_loss = criterion(per_frame_logits, labels) + + # cosshmpute classification loss + # cls_loss = criterion(torch.max(per_frame_logits, dim=2)[0], torch.max(labels, dim=2)[0]) + + # loss = (0.5 * loc_loss + 0.5 * cls_loss) / num_steps_per_update + loss = criterion(per_frame_logits, target) + loss /= num_steps_per_update + loss.backward() + + #if i % 50 == 0: + # root.error('train {:03d} loss {:5.4f} lr {:5.6f}'.format(i, loss.item(), lr_sched.get_lr()[0])) + + if num_iter == num_steps_per_update: + num_iter = 0 + optimizer.step() + optimizer.zero_grad() + lr_sched.step() + + # Evaluation + self.model.eval() + train_acc = compute_accuracy(train_loader, self.model, self.device) + valid_acc = compute_accuracy(valid_loader, self.model, self.device) + logger.info('Epoch {}, training accuracy {:5.4f}, validation accuracy {:5.4f}'.format(epoch, train_acc*100, valid_acc*100)) + #Save best model + if valid_acc >= best_valid_acc: + best_valid_acc = valid_acc + torch.save(self.model.state_dict(), tmp_file_path) + + # Load the best model with the highest accuracy on validation data + self.model.load_state_dict(torch.load(tmp_file_path)) + self.model.eval() + os.remove(tmp_file_path) + + def _init_model(self, pretrained): + """ + Initialize the model. Loading the weights if pretrained is True + """ + #Load I3D model + self.model = I3D(num_classes=400, modality=self.hyperparams['modality'].lower(), + dropout_prob=self.hyperparams['dropout_prob']) + root = logging.getLogger() + if pretrained: + state_dict = load_state_dict_from_url(pretrained_url) + self.model.load_state_dict(state_dict) + freeze = True + if freeze: + for param in self.model.parameters(): + param.requires_grad = False + root.error('Use pretrained model (freeze) {}'.format(pretrained_url)) + else: + root.error('Use pretrained model (no freeze) {}'.format(pretrained_url)) + else: + root.error('Do not use pretrained model') + #For pre-trained model modify the last layer to output 51 for HMDB, 101 for UCF and so on. + num_classes = len(np.unique(self._outputs.values)) + self.num_classes = num_classes + self.model.conv3d_0c_1x1 = Unit3Dpy(in_channels=1024, + out_channels=num_classes, + kernel_size=(1, 1, 1), + padding='VALID', + activation=None, + use_bias=True, + use_bn=False) + self.model = self.model.to(self.device) + + def produce(self, *, inputs: container.DataFrame, timeout: float=None, iterations: int=None) -> CallResult[container.DataFrame]: + """ + make the predictions + """ + #Create DataLoader + media_dir = urlparse(inputs.metadata.query_column(0)['location_base_uris'][0]).path + test_list = get_frame_list(media_dir, inputs, test_mode=True) + test_loader = get_video_loader(video_list=test_list, + crop_size=self.model.crop_size, + scale_size=self.model.scale_size, + input_mean=self.model.input_mean, + input_std=self.model.input_std, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=False, + test_mode=True, + input_format="NCTHW") + + # Make predictions + self.model.eval() + preds = make_predictions(test_loader, self.model, self.device) + outputs = wrap_predictions(inputs, preds, self.__class__.metadata.query()['name']) + + return CallResult(outputs) + + def _augment_targets(self, targets): + num_segments = self.hyperparams['num_segments'] + num_classes = self.num_classes + n = targets.size(0) + + target_expansion = targets.view(-1, 1).expand(-1, num_segments).reshape(-1, 1) + target_onehot = torch.zeros((n * num_segments, num_classes), dtype=torch.float32) + target_onehot.scatter_(1, target_expansion, 1) + target_onehot = target_onehot.reshape(n, num_segments, num_classes).permute(0, 2, 1).to(self.device) + return target_onehot + +def get_padding_shape(filter_shape, stride, mod=0): + """Fetch a tuple describing the input padding shape. + + NOTES: To replicate "TF SAME" style padding, the padding shape needs to be + determined at runtime to handle cases when the input dimension is not divisible + by the stride. + See https://stackoverflow.com/a/49842071 for explanation of TF SAME padding logic + """ + def _pad_top_bottom(filter_dim, stride_val, mod): + if mod: + pad_along = max(filter_dim - mod, 0) + else: + pad_along = max(filter_dim - stride_val, 0) + pad_top = pad_along // 2 + pad_bottom = pad_along - pad_top + return pad_top, pad_bottom + + padding_shape = [] + for idx, (filter_dim, stride_val) in enumerate(zip(filter_shape, stride)): + depth_mod = (idx == 0) and mod + pad_top, pad_bottom = _pad_top_bottom(filter_dim, stride_val, depth_mod) + padding_shape.append(pad_top) + padding_shape.append(pad_bottom) + + depth_top = padding_shape.pop(0) + depth_bottom = padding_shape.pop(0) + padding_shape.append(depth_top) + padding_shape.append(depth_bottom) + return tuple(padding_shape) + + +def simplify_padding(padding_shapes): + all_same = True + padding_init = padding_shapes[0] + for pad in padding_shapes[1:]: + if pad != padding_init: + all_same = False + return all_same, padding_init + + +class Unit3Dpy(torch.nn.Module): + def __init__(self, + in_channels, + out_channels, + kernel_size=(1, 1, 1), + stride=(1, 1, 1), + activation='relu', + padding='SAME', + use_bias=False, + use_bn=True): + super(Unit3Dpy, self).__init__() + + self.padding = padding + self.activation = activation + self.use_bn = use_bn + self.stride = stride + if padding == 'SAME': + padding_shape = get_padding_shape(kernel_size, stride) + simplify_pad, pad_size = simplify_padding(padding_shape) + self.simplify_pad = simplify_pad + if stride[0] > 1: + padding_shapes = [get_padding_shape(kernel_size, stride, mod) for + mod in range(stride[0])] + else: + padding_shapes = [padding_shape] + elif padding == 'VALID': + padding_shape = 0 + else: + raise ValueError( + 'padding should be in [VALID|SAME] but got {}'.format(padding)) + + if padding == 'SAME': + if not simplify_pad: + self.pads = [torch.nn.ConstantPad3d(x, 0) for x in padding_shapes] + self.conv3d = torch.nn.Conv3d( + in_channels, + out_channels, + kernel_size, + stride=stride, + bias=use_bias) + else: + self.conv3d = torch.nn.Conv3d( + in_channels, + out_channels, + kernel_size, + stride=stride, + padding=pad_size, + bias=use_bias) + elif padding == 'VALID': + self.conv3d = torch.nn.Conv3d( + in_channels, + out_channels, + kernel_size, + padding=padding_shape, + stride=stride, + bias=use_bias) + else: + raise ValueError( + 'padding should be in [VALID|SAME] but got {}'.format(padding)) + + if self.use_bn: + # This is not strictly the correct map between epsilons in keras and + # pytorch (which have slightly different definitions of the batch norm + # forward pass), but it seems to be good enough. The PyTorch formula + # is described here: + # https://pytorch.org/docs/stable/_modules/torch/nn/modules/batchnorm.html + tf_style_eps = 1E-3 + self.batch3d = torch.nn.BatchNorm3d(out_channels, eps=tf_style_eps) + + if activation == 'relu': + self.activation = torch.nn.functional.relu + + def forward(self, inp): + if self.padding == 'SAME' and self.simplify_pad is False: + # Determine the padding to be applied by examining the input shape + pad_idx = inp.shape[2] % self.stride[0] + pad_op = self.pads[pad_idx] + inp = pad_op(inp) + out = self.conv3d(inp) + if self.use_bn: + out = self.batch3d(out) + if self.activation is not None: + out = torch.nn.functional.relu(out) + return out + + +class MaxPool3dTFPadding(torch.nn.Module): + def __init__(self, kernel_size, stride=None, padding='SAME'): + super(MaxPool3dTFPadding, self).__init__() + if padding == 'SAME': + padding_shape = get_padding_shape(kernel_size, stride) + self.padding_shape = padding_shape + self.stride = stride + if stride[0] > 1: + padding_shapes = [get_padding_shape(kernel_size, stride, mod) for + mod in range(stride[0])] + else: + padding_shapes = [padding_shape] + self.pads = [torch.nn.ConstantPad3d(x, 0) for x in padding_shapes] + self.pool = torch.nn.MaxPool3d(kernel_size, stride, ceil_mode=True) + + def forward(self, inp): + pad_idx = inp.shape[2] % self.stride[0] + pad_op = self.pads[pad_idx] + inp = pad_op(inp) + out = self.pool(inp) + return out + + +class Mixed(torch.nn.Module): + def __init__(self, in_channels, out_channels): + super(Mixed, self).__init__() + # Branch 0 + self.branch_0 = Unit3Dpy( + in_channels, out_channels[0], kernel_size=(1, 1, 1)) + + # Branch 1 + branch_1_conv1 = Unit3Dpy( + in_channels, out_channels[1], kernel_size=(1, 1, 1)) + branch_1_conv2 = Unit3Dpy( + out_channels[1], out_channels[2], kernel_size=(3, 3, 3)) + self.branch_1 = torch.nn.Sequential(branch_1_conv1, branch_1_conv2) + + # Branch 2 + branch_2_conv1 = Unit3Dpy( + in_channels, out_channels[3], kernel_size=(1, 1, 1)) + branch_2_conv2 = Unit3Dpy( + out_channels[3], out_channels[4], kernel_size=(3, 3, 3)) + self.branch_2 = torch.nn.Sequential(branch_2_conv1, branch_2_conv2) + + # Branch3 + branch_3_pool = MaxPool3dTFPadding( + kernel_size=(3, 3, 3), stride=(1, 1, 1), padding='SAME') + branch_3_conv2 = Unit3Dpy( + in_channels, out_channels[5], kernel_size=(1, 1, 1)) + self.branch_3 = torch.nn.Sequential(branch_3_pool, branch_3_conv2) + + def forward(self, inp): + out_0 = self.branch_0(inp) + out_1 = self.branch_1(inp) + out_2 = self.branch_2(inp) + out_3 = self.branch_3(inp) + out = torch.cat((out_0, out_1, out_2, out_3), 1) + return out + + +class I3D(torch.nn.Module): + def __init__(self, + num_classes, + modality='rgb', + dropout_prob=0, + name='inception'): + super(I3D, self).__init__() + + self.name = name + self.num_classes = num_classes + if modality == 'rgb': + in_channels = 3 + elif modality == 'flow': + in_channels = 2 + else: + raise ValueError( + '{} not among known modalities [rgb|flow]'.format(modality)) + self.modality = modality + + conv3d_1a_7x7 = Unit3Dpy( + out_channels=64, + in_channels=in_channels, + kernel_size=(7, 7, 7), + stride=(2, 2, 2), + padding='SAME') + # 1st conv-pool + self.conv3d_1a_7x7 = conv3d_1a_7x7 + self.maxPool3d_2a_3x3 = MaxPool3dTFPadding( + kernel_size=(1, 3, 3), stride=(1, 2, 2), padding='SAME') + # conv conv + conv3d_2b_1x1 = Unit3Dpy( + out_channels=64, + in_channels=64, + kernel_size=(1, 1, 1), + padding='SAME') + self.conv3d_2b_1x1 = conv3d_2b_1x1 + conv3d_2c_3x3 = Unit3Dpy( + out_channels=192, + in_channels=64, + kernel_size=(3, 3, 3), + padding='SAME') + self.conv3d_2c_3x3 = conv3d_2c_3x3 + self.maxPool3d_3a_3x3 = MaxPool3dTFPadding( + kernel_size=(1, 3, 3), stride=(1, 2, 2), padding='SAME') + + # Mixed_3b + self.mixed_3b = Mixed(192, [64, 96, 128, 16, 32, 32]) + self.mixed_3c = Mixed(256, [128, 128, 192, 32, 96, 64]) + + self.maxPool3d_4a_3x3 = MaxPool3dTFPadding( + kernel_size=(3, 3, 3), stride=(2, 2, 2), padding='SAME') + + # Mixed 4 + self.mixed_4b = Mixed(480, [192, 96, 208, 16, 48, 64]) + self.mixed_4c = Mixed(512, [160, 112, 224, 24, 64, 64]) + self.mixed_4d = Mixed(512, [128, 128, 256, 24, 64, 64]) + self.mixed_4e = Mixed(512, [112, 144, 288, 32, 64, 64]) + self.mixed_4f = Mixed(528, [256, 160, 320, 32, 128, 128]) + + self.maxPool3d_5a_2x2 = MaxPool3dTFPadding( + kernel_size=(2, 2, 2), stride=(2, 2, 2), padding='SAME') + + # Mixed 5 + self.mixed_5b = Mixed(832, [256, 160, 320, 32, 128, 128]) + self.mixed_5c = Mixed(832, [384, 192, 384, 48, 128, 128]) + + self.avg_pool = torch.nn.AvgPool3d((2, 7, 7), (1, 1, 1)) + self.dropout = torch.nn.Dropout(dropout_prob) + self.conv3d_0c_1x1 = Unit3Dpy( + in_channels=1024, + out_channels=self.num_classes, + kernel_size=(1, 1, 1), + activation=None, + use_bias=True, + use_bn=False) + self.softmax = torch.nn.Softmax(1) + self._prepare_base_model(name) + + def forward(self, inp): + # Preprocessing + out = self.conv3d_1a_7x7(inp) + out = self.maxPool3d_2a_3x3(out) + out = self.conv3d_2b_1x1(out) + out = self.conv3d_2c_3x3(out) + out = self.maxPool3d_3a_3x3(out) + out = self.mixed_3b(out) + out = self.mixed_3c(out) + out = self.maxPool3d_4a_3x3(out) + out = self.mixed_4b(out) + out = self.mixed_4c(out) + out = self.mixed_4d(out) + out = self.mixed_4e(out) + out = self.mixed_4f(out) + out = self.maxPool3d_5a_2x2(out) + out = self.mixed_5b(out) + out = self.mixed_5c(out) + out = self.avg_pool(out) + out = self.dropout(out) + out = self.conv3d_0c_1x1(out) + out = out.squeeze(3) + out = out.squeeze(3) + out = out.mean(2) + # if not self.training: + # out = self.softmax(out) + return out + + def load_tf_weights(self, sess): + state_dict = {} + if self.modality == 'rgb': + prefix = 'RGB/inception_i3d' + elif self.modality == 'flow': + prefix = 'Flow/inception_i3d' + load_conv3d(state_dict, 'conv3d_1a_7x7', sess, + os.path.join(prefix, 'Conv3d_1a_7x7')) + load_conv3d(state_dict, 'conv3d_2b_1x1', sess, + os.path.join(prefix, 'Conv3d_2b_1x1')) + load_conv3d(state_dict, 'conv3d_2c_3x3', sess, + os.path.join(prefix, 'Conv3d_2c_3x3')) + + load_mixed(state_dict, 'mixed_3b', sess, + os.path.join(prefix, 'Mixed_3b')) + load_mixed(state_dict, 'mixed_3c', sess, + os.path.join(prefix, 'Mixed_3c')) + load_mixed(state_dict, 'mixed_4b', sess, + os.path.join(prefix, 'Mixed_4b')) + load_mixed(state_dict, 'mixed_4c', sess, + os.path.join(prefix, 'Mixed_4c')) + load_mixed(state_dict, 'mixed_4d', sess, + os.path.join(prefix, 'Mixed_4d')) + load_mixed(state_dict, 'mixed_4e', sess, + os.path.join(prefix, 'Mixed_4e')) + # Here goest to 0.1 max error with tf + load_mixed(state_dict, 'mixed_4f', sess, + os.path.join(prefix, 'Mixed_4f')) + + load_mixed( + state_dict, + 'mixed_5b', + sess, + os.path.join(prefix, 'Mixed_5b'), + fix_typo=True) + load_mixed(state_dict, 'mixed_5c', sess, + os.path.join(prefix, 'Mixed_5c')) + load_conv3d( + state_dict, + 'conv3d_0c_1x1', + sess, + os.path.join(prefix, 'Logits', 'Conv3d_0c_1x1'), + bias=True, + bn=False) + self.load_state_dict(state_dict) + + def _prepare_base_model(self, base_model): + if 'resnet' in base_model or 'vgg' in base_model: + self.input_size = 224 + self.input_mean = [0.485, 0.456, 0.406] + self.input_std = [0.229, 0.224, 0.225] + + if self.modality == 'flow': + self.input_mean = [0.5] + self.input_std = [np.mean(self.input_std)] + elif base_model == 'BNInception': + self.input_size = 224 + self.input_mean = [104, 117, 128] + self.input_std = [1] + + if self.modality == 'flow': + self.input_mean = [128] + elif 'inception' in base_model: + self.input_size = 224 + self.input_mean = [0.5] + self.input_std = [0.5] + else: + raise ValueError('Unknown base model: {}'.format(base_model)) + + @property + def crop_size(self): + return self.input_size + + @property + def scale_size(self): + return self.input_size * 256 // 224 + + +def get_conv_params(sess, name, bias=False): + # Get conv weights + conv_weights_tensor = sess.graph.get_tensor_by_name( + os.path.join(name, 'w:0')) + if bias: + conv_bias_tensor = sess.graph.get_tensor_by_name( + os.path.join(name, 'b:0')) + conv_bias = sess.run(conv_bias_tensor) + conv_weights = sess.run(conv_weights_tensor) + conv_shape = conv_weights.shape + + kernel_shape = conv_shape[0:3] + in_channels = conv_shape[3] + out_channels = conv_shape[4] + + conv_op = sess.graph.get_operation_by_name( + os.path.join(name, 'convolution')) + padding_name = conv_op.get_attr('padding') + padding = _get_padding(padding_name, kernel_shape) + all_strides = conv_op.get_attr('strides') + strides = all_strides[1:4] + conv_params = [ + conv_weights, kernel_shape, in_channels, out_channels, strides, padding + ] + if bias: + conv_params.append(conv_bias) + return conv_params + + +def get_bn_params(sess, name): + moving_mean_tensor = sess.graph.get_tensor_by_name( + os.path.join(name, 'moving_mean:0')) + moving_var_tensor = sess.graph.get_tensor_by_name( + os.path.join(name, 'moving_variance:0')) + beta_tensor = sess.graph.get_tensor_by_name(os.path.join(name, 'beta:0')) + moving_mean = sess.run(moving_mean_tensor) + moving_var = sess.run(moving_var_tensor) + beta = sess.run(beta_tensor) + return moving_mean, moving_var, beta + + +def _get_padding(padding_name, conv_shape): + padding_name = padding_name.decode("utf-8") + if padding_name == "VALID": + return [0, 0] + elif padding_name == "SAME": + # return [math.ceil(int(conv_shape[0])/2), math.ceil(int(conv_shape[1])/2)] + return [ + math.floor(int(conv_shape[0]) / 2), + math.floor(int(conv_shape[1]) / 2), + math.floor(int(conv_shape[2]) / 2) + ] + else: + raise ValueError('Invalid padding name ' + padding_name) + + +def load_conv3d(state_dict, name_pt, sess, name_tf, bias=False, bn=True): + # Transfer convolution params + conv_name_tf = os.path.join(name_tf, 'conv_3d') + conv_params = get_conv_params(sess, conv_name_tf, bias=bias) + if bias: + conv_weights, kernel_shape, in_channels, out_channels, strides, padding, conv_bias = conv_params + else: + conv_weights, kernel_shape, in_channels, out_channels, strides, padding = conv_params + + conv_weights_rs = np.transpose( + conv_weights, (4, 3, 0, 1, + 2)) # to pt format (out_c, in_c, depth, height, width) + state_dict[name_pt + '.conv3d.weight'] = torch.from_numpy(conv_weights_rs) + if bias: + state_dict[name_pt + '.conv3d.bias'] = torch.from_numpy(conv_bias) + + # Transfer batch norm params + if bn: + conv_tf_name = os.path.join(name_tf, 'batch_norm') + moving_mean, moving_var, beta = get_bn_params(sess, conv_tf_name) + + out_planes = conv_weights_rs.shape[0] + state_dict[name_pt + '.batch3d.weight'] = torch.ones(out_planes) + state_dict[name_pt + + '.batch3d.bias'] = torch.from_numpy(beta.squeeze()) + state_dict[name_pt + + '.batch3d.running_mean'] = torch.from_numpy(moving_mean.squeeze()) + state_dict[name_pt + + '.batch3d.running_var'] = torch.from_numpy(moving_var.squeeze()) + + +def load_mixed(state_dict, name_pt, sess, name_tf, fix_typo=False): + # Branch 0 + load_conv3d(state_dict, name_pt + '.branch_0', sess, + os.path.join(name_tf, 'Branch_0/Conv3d_0a_1x1')) + + # Branch .1 + load_conv3d(state_dict, name_pt + '.branch_1.0', sess, + os.path.join(name_tf, 'Branch_1/Conv3d_0a_1x1')) + load_conv3d(state_dict, name_pt + '.branch_1.1', sess, + os.path.join(name_tf, 'Branch_1/Conv3d_0b_3x3')) + + # Branch 2 + load_conv3d(state_dict, name_pt + '.branch_2.0', sess, + os.path.join(name_tf, 'Branch_2/Conv3d_0a_1x1')) + if fix_typo: + load_conv3d(state_dict, name_pt + '.branch_2.1', sess, + os.path.join(name_tf, 'Branch_2/Conv3d_0a_3x3')) + else: + load_conv3d(state_dict, name_pt + '.branch_2.1', sess, + os.path.join(name_tf, 'Branch_2/Conv3d_0b_3x3')) + + # Branch 3 + load_conv3d(state_dict, name_pt + '.branch_3.1', sess, + os.path.join(name_tf, 'Branch_3/Conv3d_0b_1x1')) + diff --git a/autovideo/recognition/r2p1d_primitive.py b/autovideo/recognition/r2p1d_primitive.py new file mode 100644 index 0000000..aee10f5 --- /dev/null +++ b/autovideo/recognition/r2p1d_primitive.py @@ -0,0 +1,588 @@ +import os +import numpy as np +import torch +import torch.nn as nn +import uuid +from urllib.parse import urlparse + +from d3m import container +from d3m.metadata import hyperparams +from d3m.primitive_interfaces import base +from d3m.primitive_interfaces.base import CallResult + +from torch.nn.init import normal, constant +from torch.hub import load_state_dict_from_url +from torchvision import transforms +import torchvision + +from autovideo.base.supervised_base import SupervisedParamsBase, SupervisedHyperparamsBase, SupervisedPrimitiveBase +from autovideo.utils import wrap_predictions, construct_primitive_metadata, compute_accuracy, make_predictions, get_frame_list, get_video_loader, adjust_learning_rate, logger +from torch.nn.modules.utils import _triple + +import math +from torch import optim +from torch.optim import SGD, lr_scheduler +pretrained_path = "weights/r2p1d34_K_200ep.pth" + +from .R2p1D.opts import parse_opts +from .R2p1D.model import (generate_model, load_pretrained_model, make_data_parallel, + get_fine_tuning_parameters) +from .R2p1D.mean import get_mean_std +from .R2p1D.utils import get_lr + + +__all__ = ('R2P1DPrimitive',) +Inputs = container.DataFrame +Outputs = container.DataFrame + +class Params(SupervisedParamsBase): + pass + +class Hyperparams(SupervisedHyperparamsBase): + num_workers = hyperparams.Hyperparameter[int]( + semantic_types=['https://metadata.datadrivendiscovery.org/types/ResourcesUseParameter'], + default=4, + description='The number of subprocesses to use for data loading. 0 means that the data will be loaded in the ' + 'main process.' + ) + batch_size = hyperparams.Hyperparameter[int]( + default=2, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The batch size of training" + ) + epochs = hyperparams.Hyperparameter[int]( + default=50, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="How many epochs to be trained" + ) + learning_rate = hyperparams.Hyperparameter[float]( + default=0.001, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The learning rate of the optimizer" + ) + momentum = hyperparams.Hyperparameter[float]( + default=0.9, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The momentum of the optimizer" + ) + weight_decay = hyperparams.Hyperparameter[float]( + default=5e-4, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="Weight Decay" + ) + num_segments = hyperparams.Hyperparameter[int]( + default=3, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The number of segments of frames in each video per training loop" + ) + valid_ratio = hyperparams.Hyperparameter[float]( + default=0.05, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The ratio of validation data" + ) + modality = hyperparams.Enumeration( + values=['RGB', 'RGBDiff', 'Flow'], + default='RGB', + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="The modality of input data to be used for the model", + ) + + +class R2P1DPrimitive(SupervisedPrimitiveBase[Inputs, Outputs, Params, Hyperparams]): + """ + Implementation of R2P1D + """ + + metadata = construct_primitive_metadata('recognition', 'r2p1d') + + def get_params(self) -> Params: + return super().get_params() + + def set_params(self, *, params: Params) -> None: + super().set_params(params=params) + + def _init_model(self, pretrained): + """ + Initialize the model. Loading the weights if pretrained is True + """ + + self.opt = self._get_opt() + self.opt.device = self.device + self.opt.n_finetune_classes = len(np.unique(self._outputs.values)) + + if pretrained: + self.model = generate_model(self.opt) + self.model = load_pretrained_model(self.model, self.opt.pretrain_path, self.opt.model,self.opt.n_finetune_classes) + logger.info("Loaded from pre-trained weights") + else: + self.model = generate_model(self.opt) + + #For pre-trained model modify the last layer to output 51 for HMDB, 101 for UCF and so on. + #num_classes = len(np.unique(self._outputs.values)) + #self.model.fc = nn.Linear(2048, num_classes) + + self.model = self.model.to(self.device) + + def _fit(self, *, timeout: float = None, iterations: int = None): + """ + Training + """ + #Randomly split 5% data for validation + frame_list = np.array(get_frame_list(self._media_dir, self._inputs, self._outputs)) + idx = np.array([i for i in range(len(frame_list))]) + np.random.shuffle(idx) + train_idx, valid_idx = idx[:int(len(idx)*(1-self.hyperparams['valid_ratio']))], idx[int(len(idx)*(1-self.hyperparams['valid_ratio'])):] + train_list, valid_list = frame_list[train_idx], frame_list[valid_idx] + + + parameters = self.model.parameters() + finetune = False + if finetune == True: + self.opt.ft_begin_module = 'fc' + print("FINE TUNING ONLY") + parameters = get_fine_tuning_parameters(self.model, self.opt.ft_begin_module) + optimizer = torch.optim.SGD(parameters, + self.hyperparams['learning_rate'], + momentum=self.hyperparams['momentum'], + weight_decay=self.hyperparams['weight_decay'], + nesterov=self.opt.nesterov) + + if self.opt.lr_scheduler == 'plateau': + scheduler = lr_scheduler.ReduceLROnPlateau( + optimizer, 'min', patience=self.opt.plateau_patience) + else: + scheduler = lr_scheduler.MultiStepLR(optimizer, + self.opt.multistep_milestones) + criterion = nn.CrossEntropyLoss() + + #Create Dataloaders + train_loader = get_video_loader(video_list=train_list, + crop_size=self.opt.sample_size, + scale_size=112, + input_mean=self.opt.mean, + input_std=self.opt.std, + train_augmentation=True, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=True, + input_format="NCTHW") + valid_loader = get_video_loader(video_list=valid_list, + crop_size=self.opt.sample_size, + scale_size=112, + input_mean=self.opt.mean, + input_std=self.opt.std, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=False, + input_format="NCTHW") + best_valid_acc = 0.0 + tmp_file_path = os.path.join(self.tmp_dir, str(uuid.uuid4())) + + #Training Loop + for epoch in range(self.hyperparams['epochs']): + current_lr = get_lr(optimizer) + #print(epoch, "EPOCH") + #Iterate over a batch of videos with num_segments in each video + self.model.train() + for i, (inputs,target) in enumerate(train_loader): + inputs, target = inputs.to(self.device), target.to(self.device) + output = self.model(inputs) + loss = criterion(output, target) + optimizer.zero_grad() + loss.backward() + optimizer.step() + if self.opt.lr_scheduler == 'multistep': + scheduler.step() + # Evaluation + self.model.eval() + train_acc = compute_accuracy(train_loader, self.model, self.device) + valid_acc = compute_accuracy(valid_loader, self.model, self.device) + logger.info('Epoch {}, training accuracy {:5.4f}, validation accuracy {:5.4f}'.format(epoch, train_acc*100, valid_acc*100)) + #Save best model + if valid_acc >= best_valid_acc: + best_valid_acc = valid_acc + torch.save(self.model.state_dict(), tmp_file_path) + + # Load the best model with the highest accuracy on validation data + self.model.load_state_dict(torch.load(tmp_file_path)) + self.model.eval() + os.remove(tmp_file_path) + + def produce(self, *, inputs: container.DataFrame, timeout: float=None, iterations: int=None) -> CallResult[container.DataFrame]: + """ + make the predictions + """ + #mean,std = get_mean_std(self.opt.value_scale, dataset=self.opt.mean_dataset) + #Create DataLoader + media_dir = urlparse(inputs.metadata.query_column(0)['location_base_uris'][0]).path + test_list = get_frame_list(media_dir, inputs, test_mode=True) + test_loader = get_video_loader(video_list=test_list, + crop_size=112, + scale_size=112, + input_mean=[0.4345, 0.4051, 0.3775], + input_std=[0.2768, 0.2713, 0.2737], + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=False, + test_mode=True, + input_format="NCTHW") + + # Make predictions + self.model.eval() + preds = make_predictions(test_loader, self.model, self.device) + outputs = wrap_predictions(inputs, preds, self.__class__.metadata.query()['name']) + + return CallResult(outputs) + + + + + + def _get_opt(self): + opt = parse_opts() + opt.dataset='hmdb51' + opt.n_pretrain_classes = 700 + #opt.n_classes = 51 + opt.resnet_shortcut = 'B' + self.model_name = 'r2p1d' + if self.model_name=='r2p1d': + print("Loaded R2P1D") + opt.pretrain_path = pretrained_path + opt.model = 'resnet2p1d' + opt.model_depth = 34 + if opt.pretrain_path is not None: + opt.n_finetune_classes = opt.n_classes + opt.n_classes = opt.n_pretrain_classes + + + opt.multistep_milestones = [20, 40, 60] #LR decay ;default for kinetics?: [50, 100, 150] + opt.arch = '{}-{}'.format(opt.model, opt.model_depth) + opt.begin_epoch = 1 + opt.mean, opt.std = get_mean_std(opt.value_scale, dataset=opt.mean_dataset) + opt.n_input_channels = 3 + return opt + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class SpatioTemporalConv(nn.Module): + r"""Applies a factored 3D convolution over an input signal composed of several input + planes with distinct spatial and time axes, by performing a 2D convolution over the + spatial axes to an intermediate subspace, followed by a 1D convolution over the time + axis to produce the final output. + Args: + in_channels (int): Number of channels in the input tensor + out_channels (int): Number of channels produced by the convolution + kernel_size (int or tuple): Size of the convolving kernel + stride (int or tuple, optional): Stride of the convolution. Default: 1 + padding (int or tuple, optional): Zero-padding added to the sides of the input during their respective convolutions. Default: 0 + bias (bool, optional): If ``True``, adds a learnable bias to the output. Default: ``True`` + """ + + def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, bias=False, first_conv=False): + super(SpatioTemporalConv, self).__init__() + + # if ints are entered, convert them to iterables, 1 -> [1, 1, 1] + kernel_size = _triple(kernel_size) + stride = _triple(stride) + padding = _triple(padding) + + if first_conv: + # decomposing the parameters into spatial and temporal components by + # masking out the values with the defaults on the axis that + # won't be convolved over. This is necessary to avoid unintentional + # behavior such as padding being added twice + spatial_kernel_size = kernel_size + spatial_stride = (1, stride[1], stride[2]) + spatial_padding = padding + + temporal_kernel_size = (3, 1, 1) + temporal_stride = (stride[0], 1, 1) + temporal_padding = (1, 0, 0) + + # from the official code, first conv's intermed_channels = 45 + intermed_channels = 45 + + # the spatial conv is effectively a 2D conv due to the + # spatial_kernel_size, followed by batch_norm and ReLU + self.spatial_conv = nn.Conv3d(in_channels, intermed_channels, spatial_kernel_size, + stride=spatial_stride, padding=spatial_padding, bias=bias) + self.bn1 = nn.BatchNorm3d(intermed_channels) + # the temporal conv is effectively a 1D conv, but has batch norm + # and ReLU added inside the model constructor, not here. This is an + # intentional design choice, to allow this module to externally act + # identical to a standard Conv3D, so it can be reused easily in any + # other codebase + self.temporal_conv = nn.Conv3d(intermed_channels, out_channels, temporal_kernel_size, + stride=temporal_stride, padding=temporal_padding, bias=bias) + self.bn2 = nn.BatchNorm3d(out_channels) + self.relu = nn.ReLU() + else: + # decomposing the parameters into spatial and temporal components by + # masking out the values with the defaults on the axis that + # won't be convolved over. This is necessary to avoid unintentional + # behavior such as padding being added twice + spatial_kernel_size = (1, kernel_size[1], kernel_size[2]) + spatial_stride = (1, stride[1], stride[2]) + spatial_padding = (0, padding[1], padding[2]) + + temporal_kernel_size = (kernel_size[0], 1, 1) + temporal_stride = (stride[0], 1, 1) + temporal_padding = (padding[0], 0, 0) + + # compute the number of intermediary channels (M) using formula + # from the paper section 3.5 + intermed_channels = int(math.floor((kernel_size[0] * kernel_size[1] * kernel_size[2] * in_channels * out_channels)/ \ + (kernel_size[1] * kernel_size[2] * in_channels + kernel_size[0] * out_channels))) + + # the spatial conv is effectively a 2D conv due to the + # spatial_kernel_size, followed by batch_norm and ReLU + self.spatial_conv = nn.Conv3d(in_channels, intermed_channels, spatial_kernel_size, + stride=spatial_stride, padding=spatial_padding, bias=bias) + self.bn1 = nn.BatchNorm3d(intermed_channels) + + # the temporal conv is effectively a 1D conv, but has batch norm + # and ReLU added inside the model constructor, not here. This is an + # intentional design choice, to allow this module to externally act + # identical to a standard Conv3D, so it can be reused easily in any + # other codebase + self.temporal_conv = nn.Conv3d(intermed_channels, out_channels, temporal_kernel_size, + stride=temporal_stride, padding=temporal_padding, bias=bias) + self.bn2 = nn.BatchNorm3d(out_channels) + self.relu = nn.ReLU() + + + + def forward(self, x): + x = self.relu(self.bn1(self.spatial_conv(x))) + x = self.relu(self.bn2(self.temporal_conv(x))) + return x + + +class SpatioTemporalResBlock(nn.Module): + r"""Single block for the ResNet network. Uses SpatioTemporalConv in + the standard ResNet block layout (conv->batchnorm->ReLU->conv->batchnorm->sum->ReLU) + + Args: + in_channels (int): Number of channels in the input tensor. + out_channels (int): Number of channels in the output produced by the block. + kernel_size (int or tuple): Size of the convolving kernels. + downsample (bool, optional): If ``True``, the output size is to be smaller than the input. Default: ``False`` + """ + + def __init__(self, in_channels, out_channels, kernel_size, downsample=False): + super(SpatioTemporalResBlock, self).__init__() + + # If downsample == True, the first conv of the layer has stride = 2 + # to halve the residual output size, and the input x is passed + # through a seperate 1x1x1 conv with stride = 2 to also halve it. + + # no pooling layers are used inside ResNet + self.downsample = downsample + + # to allow for SAME padding + padding = kernel_size // 2 + + if self.downsample: + # downsample with stride =2 the input x + self.downsampleconv = SpatioTemporalConv(in_channels, out_channels, 1, stride=2) + self.downsamplebn = nn.BatchNorm3d(out_channels) + + # downsample with stride = 2when producing the residual + self.conv1 = SpatioTemporalConv(in_channels, out_channels, kernel_size, padding=padding, stride=2) + else: + self.conv1 = SpatioTemporalConv(in_channels, out_channels, kernel_size, padding=padding) + + self.bn1 = nn.BatchNorm3d(out_channels) + self.relu = nn.ReLU() + + # standard conv->batchnorm->ReLU + self.conv2 = SpatioTemporalConv(out_channels, out_channels, kernel_size, padding=padding) + self.bn2 = nn.BatchNorm3d(out_channels) + + def forward(self, x): + res = self.relu(self.bn1(self.conv1(x))) + res = self.bn2(self.conv2(res)) + + if self.downsample: + x = self.downsamplebn(self.downsampleconv(x)) + + return self.relu(x + res) + + +class SpatioTemporalResLayer(nn.Module): + r"""Forms a single layer of the ResNet network, with a number of repeating + blocks of same output size stacked on top of each other + + Args: + in_channels (int): Number of channels in the input tensor. + out_channels (int): Number of channels in the output produced by the layer. + kernel_size (int or tuple): Size of the convolving kernels. + layer_size (int): Number of blocks to be stacked to form the layer + block_type (Module, optional): Type of block that is to be used to form the layer. Default: SpatioTemporalResBlock. + downsample (bool, optional): If ``True``, the first block in layer will implement downsampling. Default: ``False`` + """ + + def __init__(self, in_channels, out_channels, kernel_size, layer_size, block_type=SpatioTemporalResBlock, + downsample=False): + + super(SpatioTemporalResLayer, self).__init__() + + # implement the first block + self.block1 = block_type(in_channels, out_channels, kernel_size, downsample) + + # prepare module list to hold all (layer_size - 1) blocks + self.blocks = nn.ModuleList([]) + for i in range(layer_size - 1): + # all these blocks are identical, and have downsample = False by default + self.blocks += [block_type(out_channels, out_channels, kernel_size)] + + def forward(self, x): + x = self.block1(x) + for block in self.blocks: + x = block(x) + + return x + + +class R2Plus1DNet(nn.Module): + r"""Forms the overall ResNet feature extractor by initializng 5 layers, with the number of blocks in + each layer set by layer_sizes, and by performing a global average pool at the end producing a + 512-dimensional vector for each element in the batch. + + Args: + layer_sizes (tuple): An iterable containing the number of blocks in each layer + block_type (Module, optional): Type of block that is to be used to form the layers. Default: SpatioTemporalResBlock. + """ + + def __init__(self, layer_sizes, block_type=SpatioTemporalResBlock): + super(R2Plus1DNet, self).__init__() + + # first conv, with stride 1x2x2 and kernel size 1x7x7 + self.conv1 = SpatioTemporalConv(3, 64, (1, 7, 7), stride=(1, 2, 2), padding=(0, 3, 3), first_conv=True) + # output of conv2 is same size as of conv1, no downsampling needed. kernel_size 3x3x3 + self.conv2 = SpatioTemporalResLayer(64, 64, 3, layer_sizes[0], block_type=block_type) + # each of the final three layers doubles num_channels, while performing downsampling + # inside the first block + self.conv3 = SpatioTemporalResLayer(64, 128, 3, layer_sizes[1], block_type=block_type, downsample=True) + self.conv4 = SpatioTemporalResLayer(128, 256, 3, layer_sizes[2], block_type=block_type, downsample=True) + self.conv5 = SpatioTemporalResLayer(256, 512, 3, layer_sizes[3], block_type=block_type, downsample=True) + + # global average pooling of the output + self.pool = nn.AdaptiveAvgPool3d(1) + + def forward(self, x): + x = self.conv1(x) + x = self.conv2(x) + x = self.conv3(x) + x = self.conv4(x) + x = self.conv5(x) + + x = self.pool(x) + + return x.view(-1, 512) + + +class R2Plus1DClassifier(nn.Module): + r"""Forms a complete ResNet classifier producing vectors of size num_classes, by initializng 5 layers, + with the number of blocks in each layer set by layer_sizes, and by performing a global average pool + at the end producing a 512-dimensional vector for each element in the batch, + and passing them through a Linear layer. + + Args: + num_classes(int): Number of classes in the data + layer_sizes (tuple): An iterable containing the number of blocks in each layer + block_type (Module, optional): Type of block that is to be used to form the layers. Default: SpatioTemporalResBlock. + """ + + def __init__(self, num_classes, layer_sizes, block_type=SpatioTemporalResBlock, pretrained=False): + super(R2Plus1DClassifier, self).__init__() + + self.res2plus1d = R2Plus1DNet(layer_sizes, block_type) + self.linear = nn.Linear(512, num_classes) + + self.__init_weight() + + if pretrained: + self.__load_pretrained_weights() + + def forward(self, x): + x = self.res2plus1d(x) + logits = self.linear(x) + + return logits + + def __load_pretrained_weights(self): + s_dict = self.state_dict() + for name in s_dict: + print(name) + print(s_dict[name].size()) + + def __init_weight(self): + for m in self.modules(): + if isinstance(m, nn.Conv3d): + # n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + # m.weight.data.normal_(0, math.sqrt(2. / n)) + nn.init.kaiming_normal_(m.weight) + elif isinstance(m, nn.BatchNorm3d): + m.weight.data.fill_(1) + m.bias.data.zero_() + + +def get_1x_lr_params(model): + """ + This generator returns all the parameters for the conv layer of the net. + """ + b = [model.res2plus1d] + for i in range(len(b)): + for k in b[i].parameters(): + if k.requires_grad: + yield k + + +def get_10x_lr_params(model): + """ + This generator returns all the parameters for the fc layer of the net. + """ + b = [model.linear] + for j in range(len(b)): + for k in b[j].parameters(): + if k.requires_grad: + yield k + diff --git a/autovideo/recognition/r3d_primitive.py b/autovideo/recognition/r3d_primitive.py new file mode 100644 index 0000000..e4c3a96 --- /dev/null +++ b/autovideo/recognition/r3d_primitive.py @@ -0,0 +1,582 @@ +import os +import numpy as np +import torch +import torch.nn as nn +import uuid +from urllib.parse import urlparse + +from d3m import container +from d3m.metadata import hyperparams +from d3m.primitive_interfaces.base import CallResult + +from torch.nn.init import normal, constant +from torch.hub import load_state_dict_from_url +from torchvision import transforms + +from autovideo.base.supervised_base import SupervisedParamsBase, SupervisedHyperparamsBase, SupervisedPrimitiveBase +from autovideo.utils import wrap_predictions, construct_primitive_metadata, compute_accuracy, make_predictions, get_frame_list, get_video_loader, adjust_learning_rate, logger +from torch.nn.modules.utils import _triple + +import math +from torch import optim +from torch.optim import SGD, lr_scheduler +pretrained_path = 'weights/r3d50_K_200ep.pth' +from .R2p1D.opts import parse_opts +from .R2p1D.model import (generate_model, load_pretrained_model, make_data_parallel, + get_fine_tuning_parameters) +from .R2p1D.mean import get_mean_std +from .R2p1D.utils import get_lr + + +__all__ = ('R3DPrimitive',) +Inputs = container.DataFrame +Outputs = container.DataFrame + +class Params(SupervisedParamsBase): + pass + +class Hyperparams(SupervisedHyperparamsBase): + num_workers = hyperparams.Hyperparameter[int]( + semantic_types=['https://metadata.datadrivendiscovery.org/types/ResourcesUseParameter'], + default=4, + description='The number of subprocesses to use for data loading. 0 means that the data will be loaded in the ' + 'main process.' + ) + batch_size = hyperparams.Hyperparameter[int]( + default=2, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The batch size of training" + ) + epochs = hyperparams.Hyperparameter[int]( + default=50, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="How many epochs to be trained" + ) + learning_rate = hyperparams.Hyperparameter[float]( + default=0.001, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The learning rate of the optimizer" + ) + momentum = hyperparams.Hyperparameter[float]( + default=0.9, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The momentum of the optimizer" + ) + weight_decay = hyperparams.Hyperparameter[float]( + default=5e-4, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="Weight Decay" + ) + num_segments = hyperparams.Hyperparameter[int]( + default=3, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The number of segments of frames in each video per training loop" + ) + valid_ratio = hyperparams.Hyperparameter[float]( + default=0.05, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The ratio of validation data" + ) + modality = hyperparams.Enumeration( + values=['RGB', 'RGBDiff', 'Flow'], + default='RGB', + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="The modality of input data to be used for the model", + ) + + +class R3DPrimitive(SupervisedPrimitiveBase[Inputs, Outputs, Params, Hyperparams]): + """ + Implementation of R3D + """ + + metadata = construct_primitive_metadata('recognition', 'r3d') + + def get_params(self) -> Params: + return super().get_params() + + def set_params(self, *, params: Params) -> None: + super().set_params(params=params) + + def _init_model(self, pretrained): + """ + Initialize the model. Loading the weights if pretrained is True + """ + + self.opt = self._get_opt() + self.opt.device = self.device + self.opt.n_finetune_classes = len(np.unique(self._outputs.values)) + + if pretrained: + self.model = generate_model(self.opt) + self.model = load_pretrained_model(self.model, self.opt.pretrain_path, self.opt.model,self.opt.n_finetune_classes) + else: + self.model = generate_model(self.opt) + + #For pre-trained model modify the last layer to output 51 for HMDB, 101 for UCF and so on. + #num_classes = len(np.unique(self._outputs.values)) + #self.model.fc = nn.Linear(2048, num_classes) + + self.model = self.model.to(self.device) + + def _fit(self, *, timeout: float = None, iterations: int = None): + """ + Training + """ + #Randomly split 5% data for validation + frame_list = np.array(get_frame_list(self._media_dir, self._inputs, self._outputs)) + idx = np.array([i for i in range(len(frame_list))]) + np.random.shuffle(idx) + train_idx, valid_idx = idx[:int(len(idx)*(1-self.hyperparams['valid_ratio']))], idx[int(len(idx)*(1-self.hyperparams['valid_ratio'])):] + train_list, valid_list = frame_list[train_idx], frame_list[valid_idx] + + # Get optimizer and loss + parameters = self.model.parameters() + finetune = False + if finetune == True: + self.opt.ft_begin_module = 'fc' + print("FINE TUNING ONLY") + parameters = get_fine_tuning_parameters(self.model, self.opt.ft_begin_module) + optimizer = torch.optim.SGD(parameters, + self.hyperparams['learning_rate'], + momentum=self.hyperparams['momentum'], + weight_decay=self.hyperparams['weight_decay'], + nesterov=self.opt.nesterov) + + if self.opt.lr_scheduler == 'plateau': + scheduler = lr_scheduler.ReduceLROnPlateau( + optimizer, 'min', patience=self.opt.plateau_patience) + else: + scheduler = lr_scheduler.MultiStepLR(optimizer, + self.opt.multistep_milestones) + criterion = nn.CrossEntropyLoss() + #Create Dataloaders + train_loader = get_video_loader(video_list=train_list, + crop_size=self.opt.sample_size, + scale_size=112, + input_mean=self.opt.mean, + input_std=self.opt.std, + train_augmentation=True, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=True, + input_format="NCTHW") + valid_loader = get_video_loader(video_list=valid_list, + crop_size=self.opt.sample_size, + scale_size=112, + input_mean=self.opt.mean, + input_std=self.opt.std, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=False, + input_format="NCTHW") + best_valid_acc = 0.0 + tmp_file_path = os.path.join(self.tmp_dir, str(uuid.uuid4())) + + #Training Loop + for epoch in range(self.hyperparams['epochs']): + current_lr = get_lr(optimizer) + #print(epoch, "EPOCH") + #Iterate over a batch of videos with num_segments in each video + self.model.train() + for i, (inputs,target) in enumerate(train_loader): + inputs, target = inputs.to(self.device), target.to(self.device) + output = self.model(inputs) + loss = criterion(output, target) + optimizer.zero_grad() + loss.backward() + optimizer.step() + if self.opt.lr_scheduler == 'multistep': + scheduler.step() + # Evaluation + self.model.eval() + train_acc = compute_accuracy(train_loader, self.model, self.device) + valid_acc = compute_accuracy(valid_loader, self.model, self.device) + logger.info('Epoch {}, training accuracy {:5.4f}, validation accuracy {:5.4f}'.format(epoch, train_acc*100, valid_acc*100)) + #Save best model + if valid_acc >= best_valid_acc: + best_valid_acc = valid_acc + torch.save(self.model.state_dict(), tmp_file_path) + + # Load the best model with the highest accuracy on validation data + self.model.load_state_dict(torch.load(tmp_file_path)) + self.model.eval() + os.remove(tmp_file_path) + + def produce(self, *, inputs: container.DataFrame, timeout: float=None, iterations: int=None) -> CallResult[container.DataFrame]: + """ + make the predictions + """ + #mean,std = get_mean_std(self.opt.value_scale, dataset=self.opt.mean_dataset) + #Create DataLoader + media_dir = urlparse(inputs.metadata.query_column(0)['location_base_uris'][0]).path + test_list = get_frame_list(media_dir, inputs, test_mode=True) + test_loader = get_video_loader(video_list=test_list, + crop_size=112, + scale_size=112, + input_mean=[0.4345, 0.4051, 0.3775], + input_std=[0.2768, 0.2713, 0.2737], + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=False, + test_mode=True, + input_format="NCTHW") + + # Make predictions + self.model.eval() + preds = make_predictions(test_loader, self.model, self.device) + outputs = wrap_predictions(inputs, preds, self.__class__.metadata.query()['name']) + + return CallResult(outputs) + + + + + + def _get_opt(self): + opt = parse_opts() + opt.dataset='hmdb51' + opt.n_pretrain_classes = 700 + #opt.n_classes = 51 + opt.resnet_shortcut = 'B' + self.model_name = 'r3d' + if self.model_name=='r3d': + print("Loaded R3D") + opt.pretrain_path = pretrained_path + opt.model = 'resnet' + opt.model_depth = 50 + if opt.pretrain_path is not None: + opt.n_finetune_classes = opt.n_classes + opt.n_classes = opt.n_pretrain_classes + + opt.multistep_milestones = [20, 40, 60] #LR decay ;default for kinetics?: [50, 100, 150] + opt.arch = '{}-{}'.format(opt.model, opt.model_depth) + opt.begin_epoch = 1 + opt.mean, opt.std = get_mean_std(opt.value_scale, dataset=opt.mean_dataset) + opt.n_input_channels = 3 + return opt + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +class SpatioTemporalConv(nn.Module): + r"""Applies a factored 3D convolution over an input signal composed of several input + planes with distinct spatial and time axes, by performing a 2D convolution over the + spatial axes to an intermediate subspace, followed by a 1D convolution over the time + axis to produce the final output. + Args: + in_channels (int): Number of channels in the input tensor + out_channels (int): Number of channels produced by the convolution + kernel_size (int or tuple): Size of the convolving kernel + stride (int or tuple, optional): Stride of the convolution. Default: 1 + padding (int or tuple, optional): Zero-padding added to the sides of the input during their respective convolutions. Default: 0 + bias (bool, optional): If ``True``, adds a learnable bias to the output. Default: ``True`` + """ + + def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, bias=False, first_conv=False): + super(SpatioTemporalConv, self).__init__() + + # if ints are entered, convert them to iterables, 1 -> [1, 1, 1] + kernel_size = _triple(kernel_size) + stride = _triple(stride) + padding = _triple(padding) + + if first_conv: + # decomposing the parameters into spatial and temporal components by + # masking out the values with the defaults on the axis that + # won't be convolved over. This is necessary to avoid unintentional + # behavior such as padding being added twice + spatial_kernel_size = kernel_size + spatial_stride = (1, stride[1], stride[2]) + spatial_padding = padding + + temporal_kernel_size = (3, 1, 1) + temporal_stride = (stride[0], 1, 1) + temporal_padding = (1, 0, 0) + + # from the official code, first conv's intermed_channels = 45 + intermed_channels = 45 + + # the spatial conv is effectively a 2D conv due to the + # spatial_kernel_size, followed by batch_norm and ReLU + self.spatial_conv = nn.Conv3d(in_channels, intermed_channels, spatial_kernel_size, + stride=spatial_stride, padding=spatial_padding, bias=bias) + self.bn1 = nn.BatchNorm3d(intermed_channels) + # the temporal conv is effectively a 1D conv, but has batch norm + # and ReLU added inside the model constructor, not here. This is an + # intentional design choice, to allow this module to externally act + # identical to a standard Conv3D, so it can be reused easily in any + # other codebase + self.temporal_conv = nn.Conv3d(intermed_channels, out_channels, temporal_kernel_size, + stride=temporal_stride, padding=temporal_padding, bias=bias) + self.bn2 = nn.BatchNorm3d(out_channels) + self.relu = nn.ReLU() + else: + # decomposing the parameters into spatial and temporal components by + # masking out the values with the defaults on the axis that + # won't be convolved over. This is necessary to avoid unintentional + # behavior such as padding being added twice + spatial_kernel_size = (1, kernel_size[1], kernel_size[2]) + spatial_stride = (1, stride[1], stride[2]) + spatial_padding = (0, padding[1], padding[2]) + + temporal_kernel_size = (kernel_size[0], 1, 1) + temporal_stride = (stride[0], 1, 1) + temporal_padding = (padding[0], 0, 0) + + # compute the number of intermediary channels (M) using formula + # from the paper section 3.5 + intermed_channels = int(math.floor((kernel_size[0] * kernel_size[1] * kernel_size[2] * in_channels * out_channels)/ \ + (kernel_size[1] * kernel_size[2] * in_channels + kernel_size[0] * out_channels))) + + # the spatial conv is effectively a 2D conv due to the + # spatial_kernel_size, followed by batch_norm and ReLU + self.spatial_conv = nn.Conv3d(in_channels, intermed_channels, spatial_kernel_size, + stride=spatial_stride, padding=spatial_padding, bias=bias) + self.bn1 = nn.BatchNorm3d(intermed_channels) + + # the temporal conv is effectively a 1D conv, but has batch norm + # and ReLU added inside the model constructor, not here. This is an + # intentional design choice, to allow this module to externally act + # identical to a standard Conv3D, so it can be reused easily in any + # other codebase + self.temporal_conv = nn.Conv3d(intermed_channels, out_channels, temporal_kernel_size, + stride=temporal_stride, padding=temporal_padding, bias=bias) + self.bn2 = nn.BatchNorm3d(out_channels) + self.relu = nn.ReLU() + + + + def forward(self, x): + x = self.relu(self.bn1(self.spatial_conv(x))) + x = self.relu(self.bn2(self.temporal_conv(x))) + return x + + +class SpatioTemporalResBlock(nn.Module): + r"""Single block for the ResNet network. Uses SpatioTemporalConv in + the standard ResNet block layout (conv->batchnorm->ReLU->conv->batchnorm->sum->ReLU) + + Args: + in_channels (int): Number of channels in the input tensor. + out_channels (int): Number of channels in the output produced by the block. + kernel_size (int or tuple): Size of the convolving kernels. + downsample (bool, optional): If ``True``, the output size is to be smaller than the input. Default: ``False`` + """ + + def __init__(self, in_channels, out_channels, kernel_size, downsample=False): + super(SpatioTemporalResBlock, self).__init__() + + # If downsample == True, the first conv of the layer has stride = 2 + # to halve the residual output size, and the input x is passed + # through a seperate 1x1x1 conv with stride = 2 to also halve it. + + # no pooling layers are used inside ResNet + self.downsample = downsample + + # to allow for SAME padding + padding = kernel_size // 2 + + if self.downsample: + # downsample with stride =2 the input x + self.downsampleconv = SpatioTemporalConv(in_channels, out_channels, 1, stride=2) + self.downsamplebn = nn.BatchNorm3d(out_channels) + + # downsample with stride = 2when producing the residual + self.conv1 = SpatioTemporalConv(in_channels, out_channels, kernel_size, padding=padding, stride=2) + else: + self.conv1 = SpatioTemporalConv(in_channels, out_channels, kernel_size, padding=padding) + + self.bn1 = nn.BatchNorm3d(out_channels) + self.relu = nn.ReLU() + + # standard conv->batchnorm->ReLU + self.conv2 = SpatioTemporalConv(out_channels, out_channels, kernel_size, padding=padding) + self.bn2 = nn.BatchNorm3d(out_channels) + + def forward(self, x): + res = self.relu(self.bn1(self.conv1(x))) + res = self.bn2(self.conv2(res)) + + if self.downsample: + x = self.downsamplebn(self.downsampleconv(x)) + + return self.relu(x + res) + + +class SpatioTemporalResLayer(nn.Module): + r"""Forms a single layer of the ResNet network, with a number of repeating + blocks of same output size stacked on top of each other + + Args: + in_channels (int): Number of channels in the input tensor. + out_channels (int): Number of channels in the output produced by the layer. + kernel_size (int or tuple): Size of the convolving kernels. + layer_size (int): Number of blocks to be stacked to form the layer + block_type (Module, optional): Type of block that is to be used to form the layer. Default: SpatioTemporalResBlock. + downsample (bool, optional): If ``True``, the first block in layer will implement downsampling. Default: ``False`` + """ + + def __init__(self, in_channels, out_channels, kernel_size, layer_size, block_type=SpatioTemporalResBlock, + downsample=False): + + super(SpatioTemporalResLayer, self).__init__() + + # implement the first block + self.block1 = block_type(in_channels, out_channels, kernel_size, downsample) + + # prepare module list to hold all (layer_size - 1) blocks + self.blocks = nn.ModuleList([]) + for i in range(layer_size - 1): + # all these blocks are identical, and have downsample = False by default + self.blocks += [block_type(out_channels, out_channels, kernel_size)] + + def forward(self, x): + x = self.block1(x) + for block in self.blocks: + x = block(x) + + return x + + +class R2Plus1DNet(nn.Module): + r"""Forms the overall ResNet feature extractor by initializng 5 layers, with the number of blocks in + each layer set by layer_sizes, and by performing a global average pool at the end producing a + 512-dimensional vector for each element in the batch. + + Args: + layer_sizes (tuple): An iterable containing the number of blocks in each layer + block_type (Module, optional): Type of block that is to be used to form the layers. Default: SpatioTemporalResBlock. + """ + + def __init__(self, layer_sizes, block_type=SpatioTemporalResBlock): + super(R2Plus1DNet, self).__init__() + + # first conv, with stride 1x2x2 and kernel size 1x7x7 + self.conv1 = SpatioTemporalConv(3, 64, (1, 7, 7), stride=(1, 2, 2), padding=(0, 3, 3), first_conv=True) + # output of conv2 is same size as of conv1, no downsampling needed. kernel_size 3x3x3 + self.conv2 = SpatioTemporalResLayer(64, 64, 3, layer_sizes[0], block_type=block_type) + # each of the final three layers doubles num_channels, while performing downsampling + # inside the first block + self.conv3 = SpatioTemporalResLayer(64, 128, 3, layer_sizes[1], block_type=block_type, downsample=True) + self.conv4 = SpatioTemporalResLayer(128, 256, 3, layer_sizes[2], block_type=block_type, downsample=True) + self.conv5 = SpatioTemporalResLayer(256, 512, 3, layer_sizes[3], block_type=block_type, downsample=True) + + # global average pooling of the output + self.pool = nn.AdaptiveAvgPool3d(1) + + def forward(self, x): + x = self.conv1(x) + x = self.conv2(x) + x = self.conv3(x) + x = self.conv4(x) + x = self.conv5(x) + + x = self.pool(x) + + return x.view(-1, 512) + + +class R2Plus1DClassifier(nn.Module): + r"""Forms a complete ResNet classifier producing vectors of size num_classes, by initializng 5 layers, + with the number of blocks in each layer set by layer_sizes, and by performing a global average pool + at the end producing a 512-dimensional vector for each element in the batch, + and passing them through a Linear layer. + + Args: + num_classes(int): Number of classes in the data + layer_sizes (tuple): An iterable containing the number of blocks in each layer + block_type (Module, optional): Type of block that is to be used to form the layers. Default: SpatioTemporalResBlock. + """ + + def __init__(self, num_classes, layer_sizes, block_type=SpatioTemporalResBlock, pretrained=False): + super(R2Plus1DClassifier, self).__init__() + + self.res2plus1d = R2Plus1DNet(layer_sizes, block_type) + self.linear = nn.Linear(512, num_classes) + + self.__init_weight() + + if pretrained: + self.__load_pretrained_weights() + + def forward(self, x): + x = self.res2plus1d(x) + logits = self.linear(x) + + return logits + + def __load_pretrained_weights(self): + s_dict = self.state_dict() + for name in s_dict: + print(name) + print(s_dict[name].size()) + + def __init_weight(self): + for m in self.modules(): + if isinstance(m, nn.Conv3d): + # n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + # m.weight.data.normal_(0, math.sqrt(2. / n)) + nn.init.kaiming_normal_(m.weight) + elif isinstance(m, nn.BatchNorm3d): + m.weight.data.fill_(1) + m.bias.data.zero_() + + +def get_1x_lr_params(model): + """ + This generator returns all the parameters for the conv layer of the net. + """ + b = [model.res2plus1d] + for i in range(len(b)): + for k in b[i].parameters(): + if k.requires_grad: + yield k + + +def get_10x_lr_params(model): + """ + This generator returns all the parameters for the fc layer of the net. + """ + b = [model.linear] + for j in range(len(b)): + for k in b[j].parameters(): + if k.requires_grad: + yield k + diff --git a/autovideo/recognition/tsm_primitive.py b/autovideo/recognition/tsm_primitive.py new file mode 100644 index 0000000..3b2cf2f --- /dev/null +++ b/autovideo/recognition/tsm_primitive.py @@ -0,0 +1,645 @@ +#References : https://github.com/mit-han-lab/temporal-shift-module +import os +import math +import numpy as np +import uuid +from urllib.parse import urlparse + +from d3m import container +from d3m.metadata import hyperparams +from d3m.primitive_interfaces.base import CallResult + +import torch +from torch import nn +from torch.nn.init import normal, constant +from torch.hub import load_state_dict_from_url +import torchvision +from torch.nn.init import normal_, constant_ + +from autovideo.base.supervised_base import SupervisedParamsBase, SupervisedHyperparamsBase, SupervisedPrimitiveBase +from autovideo.utils.transforms import * +from autovideo.utils import wrap_predictions, construct_primitive_metadata, compute_accuracy, make_predictions, get_frame_list, get_video_loader, adjust_learning_rate, logger + +pretrained_url = "https://file.lzhu.me/projects/tsm/models/TSM_kinetics_RGB_resnet50_shift8_blockres_avg_segment16_e50.pth" + +__all__ = ('TSMPrimitive',) +Inputs = container.DataFrame +Outputs = container.DataFrame + +class Params(SupervisedParamsBase): + pass + +class Hyperparams(SupervisedHyperparamsBase): + num_workers = hyperparams.Hyperparameter[int]( + semantic_types=['https://metadata.datadrivendiscovery.org/types/ResourcesUseParameter'], + default=2, + description='The number of subprocesses to use for data loading. 0 means that the data will be loaded in the ' + 'main process.' + ) + batch_size = hyperparams.Hyperparameter[int]( + default=2, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The batch size of training" + ) + epochs = hyperparams.Hyperparameter[int]( + default=50, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="How many epochs to be trained" + ) + learning_rate = hyperparams.Hyperparameter[float]( + default=0.0001, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The learning rate of the optimizer" + ) + momentum = hyperparams.Hyperparameter[float]( + default=0.9, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The momentum of the optimizer" + ) + weight_decay = hyperparams.Hyperparameter[float]( + default=5e-4, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The learning rate of the optimizer" + ) + num_segments = hyperparams.Hyperparameter[int]( + default=3, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The number of segments of frames in each video per training loop" + ) + valid_ratio = hyperparams.Hyperparameter[float]( + default=0.05, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The ratio of validation data" + ) + modality = hyperparams.Enumeration( + values=['RGB', 'RGBDiff', 'Flow'], + default='RGB', + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="The modality of input data to be used for the model", + ) + +class TSMPrimitive(SupervisedPrimitiveBase[Inputs, Outputs, Params, Hyperparams]): + """ + Implementation of TSM + """ + + metadata = construct_primitive_metadata('recognition', 'tsm') + + def get_params(self) -> Params: + return super().get_params() + + def set_params(self, *, params: Params) -> None: + super().set_params(params=params) + + + def _fit(self, *, timeout: float = None, iterations: int = None): + """ + Training + """ + #Randomly split 5% data for validation + frame_list = np.array(get_frame_list(self._media_dir, self._inputs, self._outputs)) + idx = np.array([i for i in range(len(frame_list))]) + np.random.shuffle(idx) + train_idx, valid_idx = idx[:int(len(idx)*(1-self.hyperparams['valid_ratio']))], idx[int(len(idx)*(1-self.hyperparams['valid_ratio'])):] + train_list, valid_list = frame_list[train_idx], frame_list[valid_idx] + + # Get optimizer and loss + optimizer = torch.optim.SGD(self.model.get_optim_policies(), + self.hyperparams['learning_rate'], + momentum=self.hyperparams['momentum'], + weight_decay=self.hyperparams['weight_decay']) + criterion = nn.CrossEntropyLoss() + + #Create Dataloaders + train_loader = get_video_loader(video_list=train_list, + crop_size=self.model.crop_size, + scale_size=self.model.scale_size, + input_mean=self.model.input_mean, + input_std=self.model.input_std, + train_augmentation=True, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=True) + valid_loader = get_video_loader(video_list=valid_list, + crop_size=self.model.crop_size, + scale_size=self.model.scale_size, + input_mean=self.model.input_mean, + input_std=self.model.input_std, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=False) + + best_valid_acc = 0.0 + lr_steps = [20,40] #Steps after which lr decays by a factor of 10 + tmp_file_path = os.path.join(self.tmp_dir, str(uuid.uuid4())) + + #Training Loop + for epoch in range(self.hyperparams['epochs']): + adjust_learning_rate(self.hyperparams['learning_rate'], + self.hyperparams['weight_decay'], + optimizer, + epoch, + lr_steps) #lr decay + #Iterate over a batch of videos with num_segments in each video + self.model.train() + for i, (inputs,target) in enumerate(train_loader): + inputs, target = inputs.to(self.device), target.to(self.device) + output = self.model(inputs) + loss = criterion(output, target) + optimizer.zero_grad() + loss.backward() + optimizer.step() + + # Evaluation + self.model.eval() + train_acc = compute_accuracy(train_loader, self.model, self.device) + valid_acc = compute_accuracy(valid_loader, self.model, self.device) + logger.info('Epoch {}, training accuracy {:5.4f}, validation accuracy {:5.4f}'.format(epoch, train_acc*100, valid_acc*100)) + #Save best model + if valid_acc >= best_valid_acc: + best_valid_acc = valid_acc + torch.save(self.model.state_dict(), tmp_file_path) + + # Load the best model with the highest accuracy on validation data + self.model.load_state_dict(torch.load(tmp_file_path)) + self.model.eval() + os.remove(tmp_file_path) + + def _init_model(self, pretrained): + """ + Initialize the model. Loading the weights if pretrained is True + """ + + if pretrained: + logger.info("Loading pre-trained weights") + + this_arch = pretrained_url.split('TSM_')[1].split('_')[2] #Gets the base_model name from the url + #Load TSM model + self.model = TSM(400, self.hyperparams['num_segments'], self.hyperparams['modality'], base_model=this_arch, consensus_type='avg', img_feature_dim=256, dropout=0.5 ) + checkpoint = load_state_dict_from_url(pretrained_url) + """if torch.__version__ < '1.6.0': + raise ValueError('Torch version too low for loading checkpoint. Need torch >= 1.6.0') + checkpoint = load_state_dict_from_url(pretrained_url)""" + state_dict = {k.replace('net.weight', 'weight'): v for k, v in checkpoint['state_dict'].items()} + checkpoint['state_dict']= state_dict + checkpoint = checkpoint['state_dict'] + base_dict = {'.'.join(k.split('.')[1:]): v for k, v in list(checkpoint.items())} + replace_dict = {'base_model.classifier.weight': 'new_fc.weight', + 'base_model.classifier.bias': 'new_fc.bias', + } + for k, v in replace_dict.items(): + if k in base_dict: + base_dict[v] = base_dict.pop(k) + self.model.load_state_dict(base_dict) + else: + self.model = TSM(400, self.hyperparams['num_segments'], self.hyperparams['modality'], base_model = 'resnet50', consensus_type = 'avg', img_feature_dim = 256 ) + + #For pre-trained model modify the last layer to output 51 for HMDB, 101 for UCF and so on. + num_classes = len(np.unique(self._outputs.values)) + self.model.fc = nn.Linear(2048, num_classes) + """for name, param in self.model.named_parameters(): + if not 'fc' in name: + param.requires_grad = False""" + + """for name, param in self.model.named_parameters(): + print(name, param.requires_grad)""" + self.model = self.model.to(self.device) + + def produce(self, *, inputs: container.DataFrame, timeout: float=None, iterations: int=None) -> CallResult[container.DataFrame]: + """ + make the predictions + """ + #Create DataLoader + media_dir = urlparse(inputs.metadata.query_column(0)['location_base_uris'][0]).path + test_list = get_frame_list(media_dir, inputs, test_mode=True) + test_loader = get_video_loader(video_list=test_list, + crop_size=self.model.crop_size, + scale_size=self.model.scale_size, + input_mean=self.model.input_mean, + input_std=self.model.input_std, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=False, + test_mode=True) + + # Make predictions + self.model.eval() + preds = make_predictions(test_loader, self.model, self.device) + outputs = wrap_predictions(inputs, preds, self.__class__.metadata.query()['name']) + + return CallResult(outputs) + + + + + +class TSM(nn.Module): + def __init__(self, num_class, num_segments, modality, + base_model='resnet101', new_length=None, + consensus_type='avg', before_softmax=True, + dropout=0.8, img_feature_dim=256, + crop_num=1, partial_bn=True, print_spec=True, pretrain='imagenet', + is_shift=False, shift_div=8, shift_place='blockres', fc_lr5=False, + temporal_pool=False, non_local=False): + super(TSM, self).__init__() + self.modality = modality + self.num_segments = num_segments + self.reshape = True + self.before_softmax = before_softmax + self.dropout = dropout + self.crop_num = crop_num + self.consensus_type = consensus_type + self.img_feature_dim = img_feature_dim # the dimension of the CNN feature to represent each frame + self.pretrain = pretrain + + self.is_shift = is_shift + self.shift_div = shift_div + self.shift_place = shift_place + self.base_model_name = base_model + self.fc_lr5 = fc_lr5 + self.temporal_pool = temporal_pool + self.non_local = non_local + + if not before_softmax and consensus_type != 'avg': + raise ValueError("Only avg consensus can be used after Softmax") + + if new_length is None: + self.new_length = 1 if modality == "RGB" else 5 + else: + self.new_length = new_length + if print_spec: + print((""" + Initializing TSM with base model: {}. + TSM Configurations: + input_modality: {} + num_segments: {} + new_length: {} + consensus_module: {} + dropout_ratio: {} + img_feature_dim: {} + """.format(base_model, self.modality, self.num_segments, self.new_length, consensus_type, self.dropout, self.img_feature_dim))) + + self._prepare_base_model(base_model) + + feature_dim = self._prepare_tsn(num_class) + + if self.modality == 'Flow': + print("Converting the ImageNet model to a flow init model") + self.base_model = self._construct_flow_model(self.base_model) + print("Done. Flow model ready...") + elif self.modality == 'RGBDiff': + print("Converting the ImageNet model to RGB+Diff init model") + self.base_model = self._construct_diff_model(self.base_model) + print("Done. RGBDiff model ready.") + + self.consensus = ConsensusModule(consensus_type) + + if not self.before_softmax: + self.softmax = nn.Softmax() + + self._enable_pbn = partial_bn + if partial_bn: + self.partialBN(True) + + def _prepare_tsn(self, num_class): + feature_dim = getattr(self.base_model, self.base_model.last_layer_name).in_features + if self.dropout == 0: + setattr(self.base_model, self.base_model.last_layer_name, nn.Linear(feature_dim, num_class)) + self.new_fc = None + else: + setattr(self.base_model, self.base_model.last_layer_name, nn.Dropout(p=self.dropout)) + self.new_fc = nn.Linear(feature_dim, num_class) + + std = 0.001 + if self.new_fc is None: + normal_(getattr(self.base_model, self.base_model.last_layer_name).weight, 0, std) + constant_(getattr(self.base_model, self.base_model.last_layer_name).bias, 0) + else: + if hasattr(self.new_fc, 'weight'): + normal_(self.new_fc.weight, 0, std) + constant_(self.new_fc.bias, 0) + return feature_dim + + def _prepare_base_model(self, base_model): + print('=> base model: {}'.format(base_model)) + + if 'resnet' in base_model: + self.base_model = getattr(torchvision.models, base_model)(True if self.pretrain == 'imagenet' else False) + if self.is_shift: + print('Adding temporal shift...') + from .TSM.ops.temporal_shift import make_temporal_shift + make_temporal_shift(self.base_model, self.num_segments, + n_div=self.shift_div, place=self.shift_place, temporal_pool=self.temporal_pool) + + if self.non_local: + print('Adding non-local module...') + from .TSM.ops.non_local import make_non_local + make_non_local(self.base_model, self.num_segments) + + self.base_model.last_layer_name = 'fc' + self.input_size = 224 + self.input_mean = [0.485, 0.456, 0.406] + self.input_std = [0.229, 0.224, 0.225] + + self.base_model.avgpool = nn.AdaptiveAvgPool2d(1) + + if self.modality == 'Flow': + self.input_mean = [0.5] + self.input_std = [np.mean(self.input_std)] + elif self.modality == 'RGBDiff': + self.input_mean = [0.485, 0.456, 0.406] + [0] * 3 * self.new_length + self.input_std = self.input_std + [np.mean(self.input_std) * 2] * 3 * self.new_length + + elif base_model == 'mobilenetv2': + from .archs.mobilenet_v2 import mobilenet_v2, InvertedResidual + self.base_model = mobilenet_v2(True if self.pretrain == 'imagenet' else False) + + self.base_model.last_layer_name = 'classifier' + self.input_size = 224 + self.input_mean = [0.485, 0.456, 0.406] + self.input_std = [0.229, 0.224, 0.225] + + self.base_model.avgpool = nn.AdaptiveAvgPool2d(1) + if self.is_shift: + from .TSM.ops.temporal_shift import TemporalShift + for m in self.base_model.modules(): + if isinstance(m, InvertedResidual) and len(m.conv) == 8 and m.use_res_connect: + if self.print_spec: + print('Adding temporal shift... {}'.format(m.use_res_connect)) + m.conv[0] = TemporalShift(m.conv[0], n_segment=self.num_segments, n_div=self.shift_div) + if self.modality == 'Flow': + self.input_mean = [0.5] + self.input_std = [np.mean(self.input_std)] + elif self.modality == 'RGBDiff': + self.input_mean = [0.485, 0.456, 0.406] + [0] * 3 * self.new_length + self.input_std = self.input_std + [np.mean(self.input_std) * 2] * 3 * self.new_length + + elif base_model == 'BNInception': + from .archs.bn_inception import bninception + self.base_model = bninception(pretrained=self.pretrain) + self.input_size = self.base_model.input_size + self.input_mean = self.base_model.mean + self.input_std = self.base_model.std + self.base_model.last_layer_name = 'fc' + if self.modality == 'Flow': + self.input_mean = [128] + elif self.modality == 'RGBDiff': + self.input_mean = self.input_mean * (1 + self.new_length) + if self.is_shift: + print('Adding temporal shift...') + self.base_model.build_temporal_ops( + self.num_segments, is_temporal_shift=self.shift_place, shift_div=self.shift_div) + else: + raise ValueError('Unknown base model: {}'.format(base_model)) + + def train(self, mode=True): + """ + Override the default train() to freeze the BN parameters + :return: + """ + super(TSM, self).train(mode) + count = 0 + if self._enable_pbn and mode: + #print("Freezing BatchNorm2D except the first one.") + for m in self.base_model.modules(): + if isinstance(m, nn.BatchNorm2d): + count += 1 + if count >= (2 if self._enable_pbn else 1): + m.eval() + # shutdown update in frozen mode + m.weight.requires_grad = False + m.bias.requires_grad = False + + def partialBN(self, enable): + self._enable_pbn = enable + + def get_optim_policies(self): + first_conv_weight = [] + first_conv_bias = [] + normal_weight = [] + normal_bias = [] + lr5_weight = [] + lr10_bias = [] + bn = [] + custom_ops = [] + + conv_cnt = 0 + bn_cnt = 0 + for m in self.modules(): + if isinstance(m, torch.nn.Conv2d) or isinstance(m, torch.nn.Conv1d) or isinstance(m, torch.nn.Conv3d): + ps = list(m.parameters()) + conv_cnt += 1 + if conv_cnt == 1: + first_conv_weight.append(ps[0]) + if len(ps) == 2: + first_conv_bias.append(ps[1]) + else: + normal_weight.append(ps[0]) + if len(ps) == 2: + normal_bias.append(ps[1]) + elif isinstance(m, torch.nn.Linear): + ps = list(m.parameters()) + if self.fc_lr5: + lr5_weight.append(ps[0]) + else: + normal_weight.append(ps[0]) + if len(ps) == 2: + if self.fc_lr5: + lr10_bias.append(ps[1]) + else: + normal_bias.append(ps[1]) + + elif isinstance(m, torch.nn.BatchNorm2d): + bn_cnt += 1 + # later BN's are frozen + if not self._enable_pbn or bn_cnt == 1: + bn.extend(list(m.parameters())) + elif isinstance(m, torch.nn.BatchNorm3d): + bn_cnt += 1 + # later BN's are frozen + if not self._enable_pbn or bn_cnt == 1: + bn.extend(list(m.parameters())) + elif len(m._modules) == 0: + if len(list(m.parameters())) > 0: + raise ValueError("New atomic module type: {}. Need to give it a learning policy".format(type(m))) + + return [ + {'params': first_conv_weight, 'lr_mult': 5 if self.modality == 'Flow' else 1, 'decay_mult': 1, + 'name': "first_conv_weight"}, + {'params': first_conv_bias, 'lr_mult': 10 if self.modality == 'Flow' else 2, 'decay_mult': 0, + 'name': "first_conv_bias"}, + {'params': normal_weight, 'lr_mult': 1, 'decay_mult': 1, + 'name': "normal_weight"}, + {'params': normal_bias, 'lr_mult': 2, 'decay_mult': 0, + 'name': "normal_bias"}, + {'params': bn, 'lr_mult': 1, 'decay_mult': 0, + 'name': "BN scale/shift"}, + {'params': custom_ops, 'lr_mult': 1, 'decay_mult': 1, + 'name': "custom_ops"}, + # for fc + {'params': lr5_weight, 'lr_mult': 5, 'decay_mult': 1, + 'name': "lr5_weight"}, + {'params': lr10_bias, 'lr_mult': 10, 'decay_mult': 0, + 'name': "lr10_bias"}, + ] + + def forward(self, input, no_reshape=False): + if not no_reshape: + sample_len = (3 if self.modality == "RGB" else 2) * self.new_length + + if self.modality == 'RGBDiff': + sample_len = 3 * self.new_length + input = self._get_diff(input) + + base_out = self.base_model(input.view((-1, sample_len) + input.size()[-2:])) + else: + base_out = self.base_model(input) + + if self.dropout > 0: + base_out = self.new_fc(base_out) + + if not self.before_softmax: + base_out = self.softmax(base_out) + + if self.reshape: + if self.is_shift and self.temporal_pool: + base_out = base_out.view((-1, self.num_segments // 2) + base_out.size()[1:]) + else: + base_out = base_out.view((-1, self.num_segments) + base_out.size()[1:]) + output = self.consensus(base_out) + return output.squeeze(1) + + def _get_diff(self, input, keep_rgb=False): + input_c = 3 if self.modality in ["RGB", "RGBDiff"] else 2 + input_view = input.view((-1, self.num_segments, self.new_length + 1, input_c,) + input.size()[2:]) + if keep_rgb: + new_data = input_view.clone() + else: + new_data = input_view[:, :, 1:, :, :, :].clone() + + for x in reversed(list(range(1, self.new_length + 1))): + if keep_rgb: + new_data[:, :, x, :, :, :] = input_view[:, :, x, :, :, :] - input_view[:, :, x - 1, :, :, :] + else: + new_data[:, :, x - 1, :, :, :] = input_view[:, :, x, :, :, :] - input_view[:, :, x - 1, :, :, :] + + return new_data + + def _construct_flow_model(self, base_model): + # modify the convolution layers + # Torch models are usually defined in a hierarchical way. + # nn.modules.children() return all sub modules in a DFS manner + modules = list(self.base_model.modules()) + first_conv_idx = list(filter(lambda x: isinstance(modules[x], nn.Conv2d), list(range(len(modules)))))[0] + conv_layer = modules[first_conv_idx] + container = modules[first_conv_idx - 1] + + # modify parameters, assume the first blob contains the convolution kernels + params = [x.clone() for x in conv_layer.parameters()] + kernel_size = params[0].size() + new_kernel_size = kernel_size[:1] + (2 * self.new_length, ) + kernel_size[2:] + new_kernels = params[0].data.mean(dim=1, keepdim=True).expand(new_kernel_size).contiguous() + + new_conv = nn.Conv2d(2 * self.new_length, conv_layer.out_channels, + conv_layer.kernel_size, conv_layer.stride, conv_layer.padding, + bias=True if len(params) == 2 else False) + new_conv.weight.data = new_kernels + if len(params) == 2: + new_conv.bias.data = params[1].data # add bias if neccessary + layer_name = list(container.state_dict().keys())[0][:-7] # remove .weight suffix to get the layer name + + # replace the first convlution layer + setattr(container, layer_name, new_conv) + + if self.base_model_name == 'BNInception': + import torch.utils.model_zoo as model_zoo + sd = model_zoo.load_url('https://www.dropbox.com/s/35ftw2t4mxxgjae/BNInceptionFlow-ef652051.pth.tar?dl=1') + base_model.load_state_dict(sd) + print('=> Loading pretrained Flow weight done...') + else: + print('#' * 30, 'Warning! No Flow pretrained model is found') + return base_model + + def _construct_diff_model(self, base_model, keep_rgb=False): + # modify the convolution layers + # Torch models are usually defined in a hierarchical way. + # nn.modules.children() return all sub modules in a DFS manner + modules = list(self.base_model.modules()) + first_conv_idx = filter(lambda x: isinstance(modules[x], nn.Conv2d), list(range(len(modules))))[0] + conv_layer = modules[first_conv_idx] + container = modules[first_conv_idx - 1] + + # modify parameters, assume the first blob contains the convolution kernels + params = [x.clone() for x in conv_layer.parameters()] + kernel_size = params[0].size() + if not keep_rgb: + new_kernel_size = kernel_size[:1] + (3 * self.new_length,) + kernel_size[2:] + new_kernels = params[0].data.mean(dim=1, keepdim=True).expand(new_kernel_size).contiguous() + else: + new_kernel_size = kernel_size[:1] + (3 * self.new_length,) + kernel_size[2:] + new_kernels = torch.cat((params[0].data, params[0].data.mean(dim=1, keepdim=True).expand(new_kernel_size).contiguous()), + 1) + new_kernel_size = kernel_size[:1] + (3 + 3 * self.new_length,) + kernel_size[2:] + + new_conv = nn.Conv2d(new_kernel_size[1], conv_layer.out_channels, + conv_layer.kernel_size, conv_layer.stride, conv_layer.padding, + bias=True if len(params) == 2 else False) + new_conv.weight.data = new_kernels + if len(params) == 2: + new_conv.bias.data = params[1].data # add bias if neccessary + layer_name = list(container.state_dict().keys())[0][:-7] # remove .weight suffix to get the layer name + + # replace the first convolution layer + setattr(container, layer_name, new_conv) + return base_model + + @property + def crop_size(self): + return self.input_size + + @property + def scale_size(self): + return self.input_size * 256 // 224 + + + +class Identity(torch.nn.Module): + def forward(self, input): + return input + + +class SegmentConsensus(torch.nn.Module): + + def __init__(self, consensus_type, dim=1): + super(SegmentConsensus, self).__init__() + self.consensus_type = consensus_type + self.dim = dim + self.shape = None + + def forward(self, input_tensor): + self.shape = input_tensor.size() + if self.consensus_type == 'avg': + output = input_tensor.mean(dim=self.dim, keepdim=True) + elif self.consensus_type == 'identity': + output = input_tensor + else: + output = None + + return output + + +class ConsensusModule(torch.nn.Module): + + def __init__(self, consensus_type, dim=1): + super(ConsensusModule, self).__init__() + self.consensus_type = consensus_type if consensus_type != 'rnn' else 'identity' + self.dim = dim + + def forward(self, input): + return SegmentConsensus(self.consensus_type, self.dim)(input) diff --git a/autovideo/recognition/tsn_primitive.py b/autovideo/recognition/tsn_primitive.py new file mode 100644 index 0000000..dba08a1 --- /dev/null +++ b/autovideo/recognition/tsn_primitive.py @@ -0,0 +1,551 @@ +# References : https://github.com/yjxiong/temporal-segment-networks +import os +import math +import numpy as np +import uuid +from urllib.parse import urlparse + +from d3m import container +from d3m.metadata import hyperparams +from d3m.primitive_interfaces.base import CallResult + +import torch +from torch import nn +from torch.nn.init import normal, constant +from torch.hub import load_state_dict_from_url +import torchvision + +from autovideo.base.supervised_base import SupervisedParamsBase, SupervisedHyperparamsBase, SupervisedPrimitiveBase +#from autovideo.utils.transforms import * +from autovideo.utils import wrap_predictions, construct_primitive_metadata, compute_accuracy, make_predictions, get_frame_list, get_video_loader, adjust_learning_rate, logger + +pretrained_url = "https://open-mmlab.s3.ap-northeast-2.amazonaws.com/mmaction/models/kinetics400/tsn2d_kinetics400_rgb_r50_seg3_f1s1-b702e12f.pth" + +__all__ = ('TSNPrimitive',) +Inputs = container.DataFrame +Outputs = container.DataFrame + +class Params(SupervisedParamsBase): + pass + +class Hyperparams(SupervisedHyperparamsBase): + num_workers = hyperparams.Hyperparameter[int]( + semantic_types=['https://metadata.datadrivendiscovery.org/types/ResourcesUseParameter'], + default=2, + description='The number of subprocesses to use for data loading. 0 means that the data will be loaded in the ' + 'main process.' + ) + batch_size = hyperparams.Hyperparameter[int]( + default=2, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The batch size of training" + ) + epochs = hyperparams.Hyperparameter[int]( + default=15, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="How many epochs to be trained" + ) + learning_rate = hyperparams.Hyperparameter[float]( + default=0.001, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The learning rate of the optimizer" + ) + momentum = hyperparams.Hyperparameter[float]( + default=0.9, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The momentum of the optimizer" + ) + weight_decay = hyperparams.Hyperparameter[float]( + default=5e-4, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The learning rate of the optimizer" + ) + num_segments = hyperparams.Hyperparameter[int]( + default=3, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The number of segments of frames in each video per training loop" + ) + valid_ratio = hyperparams.Hyperparameter[float]( + default=0.05, + semantic_types=['https://metadata.datadrivendiscovery.org/types/TuningParameter'], + description="The ratio of validation data" + ) + modality = hyperparams.Enumeration( + values=['RGB', 'RGBDiff', 'Flow'], + default='RGB', + semantic_types=['https://metadata.datadrivendiscovery.org/types/ControlParameter'], + description="The modality of input data to be used for the model", + ) + +class TSNPrimitive(SupervisedPrimitiveBase[Inputs, Outputs, Params, Hyperparams]): + """ + Implementation of TSN + """ + metadata = construct_primitive_metadata('recognition', 'tsn') + + def get_params(self) -> Params: + return super().get_params() + + def set_params(self, *, params: Params) -> None: + super().set_params(params=params) + + def _fit(self, *, timeout: float = None, iterations: int = None): + """ + Training + """ + #Randomly split 5% data for validation + frame_list = np.array(get_frame_list(self._media_dir, self._inputs, self._outputs)) + idx = np.array([i for i in range(len(frame_list))]) + np.random.shuffle(idx) + train_idx, valid_idx = idx[:int(len(idx)*(1-self.hyperparams['valid_ratio']))], idx[int(len(idx)*(1-self.hyperparams['valid_ratio'])):] + train_list, valid_list = frame_list[train_idx], frame_list[valid_idx] + + # Get optimizer and loss + optimizer = torch.optim.SGD(self.model.get_optim_policies(), + self.hyperparams['learning_rate'], + momentum=self.hyperparams['momentum'], + weight_decay=self.hyperparams['weight_decay']) + criterion = nn.CrossEntropyLoss() + + #Create Dataloaders + train_loader = get_video_loader(video_list=train_list, + crop_size=self.model.crop_size, + scale_size=self.model.scale_size, + input_mean=self.model.input_mean, + input_std=self.model.input_std, + train_augmentation=True, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=True) + valid_loader = get_video_loader(video_list=valid_list, + crop_size=self.model.crop_size, + scale_size=self.model.scale_size, + input_mean=self.model.input_mean, + input_std=self.model.input_std, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=False) + + best_valid_acc = 0.0 + lr_steps = [20,40] #Steps after which lr decays by a factor of 10 + tmp_file_path = os.path.join(self.tmp_dir, str(uuid.uuid4())) + #print("LEARNING RATE: ", self.hyperparams['learning_rate']) + #Training Loop + for epoch in range(self.hyperparams['epochs']): + adjust_learning_rate(self.hyperparams['learning_rate'], + self.hyperparams['weight_decay'], + optimizer, + epoch, + lr_steps) #lr decay + #Iterate over a batch of videos with num_segments in each video + self.model.train() + for i, (inputs,target) in enumerate(train_loader): + inputs, target = inputs.to(self.device), target.to(self.device) + output = self.model(inputs) + loss = criterion(output, target) + optimizer.zero_grad() + loss.backward() + optimizer.step() + + # Evaluation + self.model.eval() + train_acc = compute_accuracy(train_loader, self.model, self.device) + valid_acc = compute_accuracy(valid_loader, self.model, self.device) + logger.info('Epoch {}, training accuracy {:5.4f}, validation accuracy {:5.4f}'.format(epoch, train_acc*100, valid_acc*100)) + #Save best model + if valid_acc >= best_valid_acc: + best_valid_acc = valid_acc + torch.save(self.model.state_dict(), tmp_file_path) + + # Load the best model with the highest accuracy on validation data + self.model.load_state_dict(torch.load(tmp_file_path)) + self.model.eval() + os.remove(tmp_file_path) + + def _init_model(self, pretrained): + """ + Initialize the model. Loading the weights if pretrained is True + """ + #Load TSN model + self.model = TSN(400, self.hyperparams['num_segments'], self.hyperparams['modality'], base_model='resnet50', consensus_type='avg', dropout=0.8) + if pretrained: + model_data = load_state_dict_from_url(pretrained_url) + # Modify the layer names to match the pre-trained model and the loaded TSN model for succesfull loading + state_dict = {k.replace('backbone.', 'base_model.'): v for k, v in model_data['state_dict'].items()} + count = 0 + base_dict = {} + for k, v in state_dict.items(): + count = count + 1 + if count<415: + base_dict.setdefault(k, state_dict[k]) + base_dict.setdefault('new_fc.weight', state_dict['cls_head.fc_cls.weight']) + base_dict.setdefault('new_fc.bias', state_dict['cls_head.fc_cls.bias']) + del base_dict['cls_head.fc_cls.weight'] + del base_dict['cls_head.fc_cls.bias'] + self.model.load_state_dict(base_dict) + logger.info("Loaded from pre-trained weights") + #For pre-trained model modify the last layer to output 51 for HMDB, 101 for UCF and so on. + num_classes = len(np.unique(self._outputs.values)) + self.model.new_fc = nn.Linear(2048, num_classes) + self.model = self.model.to(self.device) + + def produce(self, *, inputs: container.DataFrame, timeout: float=None, iterations: int=None) -> CallResult[container.DataFrame]: + """ + make the predictions + """ + #Create DataLoader + media_dir = urlparse(inputs.metadata.query_column(0)['location_base_uris'][0]).path + test_list = get_frame_list(media_dir, inputs, test_mode=True) + test_loader = get_video_loader(video_list=test_list, + crop_size=self.model.crop_size, + scale_size=self.model.scale_size, + input_mean=self.model.input_mean, + input_std=self.model.input_std, + modality=self.hyperparams['modality'], + num_segments=self.hyperparams['num_segments'], + batch_size=self.hyperparams['batch_size'], + num_workers=self.hyperparams['num_workers'], + shuffle=False, + test_mode=True) + + # Make predictions + self.model.eval() + preds = make_predictions(test_loader, self.model, self.device) + outputs = wrap_predictions(inputs, preds, self.__class__.metadata.query()['name']) + + return CallResult(outputs) + + +class TSN(nn.Module): + def __init__(self, num_class, num_segments, modality, + base_model='resnet50', new_length=None, + consensus_type='avg', before_softmax=True, + dropout=0.8, + crop_num=1, partial_bn=True): + super(TSN, self).__init__() + self.modality = modality + self.num_segments = num_segments + self.reshape = True + self.before_softmax = before_softmax + self.dropout = dropout + self.crop_num = crop_num + self.consensus_type = consensus_type + if not before_softmax and consensus_type != 'avg': + raise ValueError("Only avg consensus can be used after Softmax") + + if new_length is None: + self.new_length = 1 if modality == "RGB" else 5 + else: + self.new_length = new_length + + print((""" +Initializing TSN with base model: {}. +TSN Configurations: + input_modality: {} + num_segments: {} + new_length: {} + consensus_module: {} + dropout_ratio: {} + """.format(base_model, self.modality, self.num_segments, self.new_length, consensus_type, self.dropout))) + + self._prepare_base_model(base_model) + + feature_dim = self._prepare_tsn(num_class) + + if self.modality == 'Flow': + print("Converting the ImageNet model to a flow init model") + self.base_model = self._construct_flow_model(self.base_model) + print("Done. Flow model ready...") + elif self.modality == 'RGBDiff': + print("Converting the ImageNet model to RGB+Diff init model") + self.base_model = self._construct_diff_model(self.base_model) + print("Done. RGBDiff model ready.") + + self.consensus = ConsensusModule(consensus_type) + + if not self.before_softmax: + self.softmax = nn.Softmax() + + self._enable_pbn = partial_bn + if partial_bn: + self.partialBN(True) + + def _prepare_tsn(self, num_class): + feature_dim = getattr(self.base_model, self.base_model.last_layer_name).in_features + if self.dropout == 0: + setattr(self.base_model, self.base_model.last_layer_name, nn.Linear(feature_dim, num_class)) + self.new_fc = None + else: + setattr(self.base_model, self.base_model.last_layer_name, nn.Dropout(p=self.dropout)) + self.new_fc = nn.Linear(feature_dim, num_class) + + std = 0.001 + if self.new_fc is None: + normal(getattr(self.base_model, self.base_model.last_layer_name).weight, 0, std) + constant(getattr(self.base_model, self.base_model.last_layer_name).bias, 0) + else: + normal(self.new_fc.weight, 0, std) + constant(self.new_fc.bias, 0) + return feature_dim + + def _prepare_base_model(self, base_model): + + if 'resnet' in base_model or 'vgg' in base_model: + self.base_model = getattr(torchvision.models, base_model)(True) + self.base_model.last_layer_name = 'fc' + self.input_size = 224 + self.input_mean = [0.485, 0.456, 0.406] + self.input_std = [0.229, 0.224, 0.225] + + if self.modality == 'Flow': + self.input_mean = [0.5] + self.input_std = [np.mean(self.input_std)] + elif self.modality == 'RGBDiff': + self.input_mean = [0.485, 0.456, 0.406] + [0] * 3 * self.new_length + self.input_std = self.input_std + [np.mean(self.input_std) * 2] * 3 * self.new_length + elif base_model == 'BNInception': + #import tf_model_zoo + from .archs.bn_inception import bninception + #self.base_model = getattr(tf_model_zoo, base_model)() + self.base_model = bninception(pretrained='imagenet') + self.base_model.last_layer_name = 'fc' + self.input_size = 224 + self.input_mean = [104, 117, 128] + self.input_std = [1] + + if self.modality == 'Flow': + self.input_mean = [128] + elif self.modality == 'RGBDiff': + self.input_mean = self.input_mean * (1 + self.new_length) + + elif 'inception' in base_model: + import tf_model_zoo + self.base_model = getattr(tf_model_zoo, base_model)() + self.base_model.last_layer_name = 'classif' + self.input_size = 299 + self.input_mean = [0.5] + self.input_std = [0.5] + else: + raise ValueError('Unknown base model: {}'.format(base_model)) + + def train(self, mode=True): + """ + Override the default train() to freeze the BN parameters + :return: + """ + super(TSN, self).train(mode) + count = 0 + if self._enable_pbn: + #print("Freezing BatchNorm2D except the first one.") + for m in self.base_model.modules(): + if isinstance(m, nn.BatchNorm2d): + count += 1 + if count >= (2 if self._enable_pbn else 1): + m.eval() + + # shutdown update in frozen mode + m.weight.requires_grad = False + m.bias.requires_grad = False + + def partialBN(self, enable): + self._enable_pbn = enable + + def get_optim_policies(self): + first_conv_weight = [] + first_conv_bias = [] + normal_weight = [] + normal_bias = [] + bn = [] + + conv_cnt = 0 + bn_cnt = 0 + for m in self.modules(): + if isinstance(m, torch.nn.Conv2d) or isinstance(m, torch.nn.Conv1d): + ps = list(m.parameters()) + conv_cnt += 1 + if conv_cnt == 1: + first_conv_weight.append(ps[0]) + if len(ps) == 2: + first_conv_bias.append(ps[1]) + else: + normal_weight.append(ps[0]) + if len(ps) == 2: + normal_bias.append(ps[1]) + elif isinstance(m, torch.nn.Linear): + ps = list(m.parameters()) + normal_weight.append(ps[0]) + if len(ps) == 2: + normal_bias.append(ps[1]) + + elif isinstance(m, torch.nn.BatchNorm1d): + bn.extend(list(m.parameters())) + elif isinstance(m, torch.nn.BatchNorm2d): + bn_cnt += 1 + # later BN's are frozen + if not self._enable_pbn or bn_cnt == 1: + bn.extend(list(m.parameters())) + elif len(m._modules) == 0: + if len(list(m.parameters())) > 0: + raise ValueError("New atomic module type: {}. Need to give it a learning policy".format(type(m))) + + return [ + {'params': first_conv_weight, 'lr_mult': 5 if self.modality == 'Flow' else 1, 'decay_mult': 1, + 'name': "first_conv_weight"}, + {'params': first_conv_bias, 'lr_mult': 10 if self.modality == 'Flow' else 2, 'decay_mult': 0, + 'name': "first_conv_bias"}, + {'params': normal_weight, 'lr_mult': 1, 'decay_mult': 1, + 'name': "normal_weight"}, + {'params': normal_bias, 'lr_mult': 2, 'decay_mult': 0, + 'name': "normal_bias"}, + {'params': bn, 'lr_mult': 1, 'decay_mult': 0, + 'name': "BN scale/shift"}, + ] + + def forward(self, input): + sample_len = (3 if self.modality == "RGB" else 2) * self.new_length + + if self.modality == 'RGBDiff': + sample_len = 3 * self.new_length + input = self._get_diff(input) + + base_out = self.base_model(input.view((-1, sample_len) + input.size()[-2:])) + + if self.dropout > 0: + base_out = self.new_fc(base_out) + + if not self.before_softmax: + base_out = self.softmax(base_out) + if self.reshape: + base_out = base_out.view((-1, self.num_segments) + base_out.size()[1:]) + + output = self.consensus(base_out) + return output.squeeze(1) + + def _get_diff(self, input, keep_rgb=False): + input_c = 3 if self.modality in ["RGB", "RGBDiff"] else 2 + input_view = input.view((-1, self.num_segments, self.new_length + 1, input_c,) + input.size()[2:]) + if keep_rgb: + new_data = input_view.clone() + else: + new_data = input_view[:, :, 1:, :, :, :].clone() + + for x in reversed(list(range(1, self.new_length + 1))): + if keep_rgb: + new_data[:, :, x, :, :, :] = input_view[:, :, x, :, :, :] - input_view[:, :, x - 1, :, :, :] + else: + new_data[:, :, x - 1, :, :, :] = input_view[:, :, x, :, :, :] - input_view[:, :, x - 1, :, :, :] + + return new_data + + def _construct_flow_model(self, base_model): + # modify the convolution layers + # Torch models are usually defined in a hierarchical way. + # nn.modules.children() return all sub modules in a DFS manner + modules = list(self.base_model.modules()) + first_conv_idx = list(filter(lambda x: isinstance(modules[x], nn.Conv2d), list(range(len(modules)))))[0] + conv_layer = modules[first_conv_idx] + container = modules[first_conv_idx - 1] + + # modify parameters, assume the first blob contains the convolution kernels + params = [x.clone() for x in conv_layer.parameters()] + kernel_size = params[0].size() + new_kernel_size = kernel_size[:1] + (2 * self.new_length, ) + kernel_size[2:] + new_kernels = params[0].data.mean(dim=1, keepdim=True).expand(new_kernel_size).contiguous() + + new_conv = nn.Conv2d(2 * self.new_length, conv_layer.out_channels, + conv_layer.kernel_size, conv_layer.stride, conv_layer.padding, + bias=True if len(params) == 2 else False) + new_conv.weight.data = new_kernels + if len(params) == 2: + new_conv.bias.data = params[1].data # add bias if neccessary + layer_name = list(container.state_dict().keys())[0][:-7] # remove .weight suffix to get the layer name + + # replace the first convlution layer + setattr(container, layer_name, new_conv) + return base_model + + def _construct_diff_model(self, base_model, keep_rgb=False): + # modify the convolution layers + # Torch models are usually defined in a hierarchical way. + # nn.modules.children() return all sub modules in a DFS manner + modules = list(self.base_model.modules()) + first_conv_idx = list(filter(lambda x: isinstance(modules[x], nn.Conv2d), list(range(len(modules)))))[0] + conv_layer = modules[first_conv_idx] + container = modules[first_conv_idx - 1] + + # modify parameters, assume the first blob contains the convolution kernels + params = [x.clone() for x in conv_layer.parameters()] + kernel_size = params[0].size() + if not keep_rgb: + new_kernel_size = kernel_size[:1] + (3 * self.new_length,) + kernel_size[2:] + new_kernels = params[0].data.mean(dim=1, keepdim=True).expand(new_kernel_size).contiguous() + else: + new_kernel_size = kernel_size[:1] + (3 * self.new_length,) + kernel_size[2:] + new_kernels = torch.cat((params[0].data, params[0].data.mean(dim=1, keepdim=True).expand(new_kernel_size).contiguous()), + 1) + new_kernel_size = kernel_size[:1] + (3 + 3 * self.new_length,) + kernel_size[2:] + + new_conv = nn.Conv2d(new_kernel_size[1], conv_layer.out_channels, + conv_layer.kernel_size, conv_layer.stride, conv_layer.padding, + bias=True if len(params) == 2 else False) + new_conv.weight.data = new_kernels + if len(params) == 2: + new_conv.bias.data = params[1].data # add bias if neccessary + layer_name = list(container.state_dict().keys())[0][:-7] # remove .weight suffix to get the layer name + + # replace the first convolution layer + setattr(container, layer_name, new_conv) + return base_model + + @property + def crop_size(self): + return self.input_size + + @property + def scale_size(self): + return self.input_size * 256 // 224 + +class Identity(torch.nn.Module): + def forward(self, input): + return input + +class SegmentConsensus(torch.nn.Module): + def __init__(self, consensus_type, dim=1): + super(SegmentConsensus, self).__init__() + self.consensus_type = consensus_type + self.dim = dim + self.shape = None + + def forward(self, input_tensor): + self.shape = input_tensor.size() + if self.consensus_type == 'avg': + output = input_tensor.mean(dim=self.dim, keepdim=True) + elif self.consensus_type == 'identity': + output = input_tensor + else: + output = None + + return output + + def backward(self, grad_output): + if self.consensus_type == 'avg': + grad_in = grad_output.expand(self.shape) / float(self.shape[self.dim]) + elif self.consensus_type == 'identity': + grad_in = grad_output + else: + grad_in = None + + return grad_in + +class ConsensusModule(torch.nn.Module): + def __init__(self, consensus_type, dim=1): + super(ConsensusModule, self).__init__() + self.consensus_type = consensus_type if consensus_type != 'rnn' else 'identity' + self.dim = dim + + def forward(self, input): + return SegmentConsensus(self.consensus_type, self.dim)(input) diff --git a/autovideo/searcher/__init__.py b/autovideo/searcher/__init__.py new file mode 100644 index 0000000..ffb51cf --- /dev/null +++ b/autovideo/searcher/__init__.py @@ -0,0 +1 @@ +from .ray_searcher import RaySearcher diff --git a/autovideo/searcher/base.py b/autovideo/searcher/base.py new file mode 100644 index 0000000..a18dafc --- /dev/null +++ b/autovideo/searcher/base.py @@ -0,0 +1,20 @@ +# Base searcher class + +import os + +class BaseSearcher: + def __init__( + self, + train_dataset, + train_media_dir, + valid_dataset, + valid_media_dir, + ): + self.train_dataset = train_dataset + self.train_media_dir = os.path.abspath(train_media_dir) + self.valid_dataset = valid_dataset + self.valid_media_dir = os.path.abspath(valid_media_dir) + self.target_index = 2 + + def search(self, search_space, config): + raise NotImplementedError diff --git a/autovideo/searcher/ray_searcher.py b/autovideo/searcher/ray_searcher.py new file mode 100644 index 0000000..ddb6404 --- /dev/null +++ b/autovideo/searcher/ray_searcher.py @@ -0,0 +1,70 @@ +import pandas as pd + +from ray import tune + +from autovideo.utils import build_pipeline, fit_produce, extract_frames, compute_accuracy_with_preds +from .base import BaseSearcher + +class RaySearcher(BaseSearcher): + def __init__( + self, + train_dataset, + train_media_dir, + valid_dataset, + valid_media_dir, + ): + super().__init__( + train_dataset=train_dataset, + train_media_dir=train_media_dir, + valid_dataset=valid_dataset, + valid_media_dir=valid_media_dir + ) + + def search(self, search_space, config): + if config["searching_algorithm"] == "random": + from ray.tune.suggest.basic_variant import BasicVariantGenerator + searcher = BasicVariantGenerator() #Random/Grid Searcher + elif config["searching_algorithm"] == "hyperopt": + from ray.tune.suggest.hyperopt import HyperOptSearch + searcher = HyperOptSearch(max_concurrent=2, metric="accuracy") #HyperOpt Searcher + else: + raise ValueError("Searching algorithm not supported.") + + self.valid_labels = self.valid_dataset['label'] + self.valid_dataset = self.valid_dataset.drop(['label'], axis=1) + + # Extract frames from the video + video_ext = self.train_dataset.iloc[0, 1].split('.')[-1] + extract_frames(self.train_media_dir, video_ext) + extract_frames(self.valid_media_dir, video_ext) + + analysis = tune.run( + self._evaluate, + config=search_space, + num_samples=config["num_samples"], + resources_per_trial={"cpu": 2, "gpu": 1}, + mode='max', + search_alg=searcher, + name=config["searching_algorithm"]+"_"+str(config["num_samples"]) + ) + best_config = analysis.get_best_config(metric="accuracy") + + return best_config + + def _evaluate(self, config): + pipeline = build_pipeline(config) + + # Fit and produce + predictions = fit_produce( + train_dataset=self.train_dataset, + train_media_dir=self.train_media_dir, + test_dataset=self.valid_dataset, + test_media_dir=self.valid_media_dir, + target_index=self.target_index, + pipeline=pipeline + ) + + # Get accuracy + valid_acc = compute_accuracy_with_preds(predictions['label'], valid_labels) + tune.report(accuracy=valid_acc) + diff --git a/autovideo/utils/__init__.py b/autovideo/utils/__init__.py new file mode 100644 index 0000000..15a16e3 --- /dev/null +++ b/autovideo/utils/__init__.py @@ -0,0 +1,5 @@ +from .d3m_utils import * +from .axolotl_utils import * +from .training_utils import * +from .frames_utils import * +from .logging_utils import logger, set_log_path diff --git a/autovideo/utils/axolotl_utils.py b/autovideo/utils/axolotl_utils.py new file mode 100644 index 0000000..8897525 --- /dev/null +++ b/autovideo/utils/axolotl_utils.py @@ -0,0 +1,117 @@ +import os +import uuid +import shutil +import pathlib + +import pandas as pd + +from d3m.metadata.problem import TaskKeyword, PerformanceMetric +from d3m.metadata import base as metadata_base +from axolotl.utils import pipeline as pipeline_utils +from axolotl.utils import data_problem +from axolotl.backend.simple import SimpleRunner + +from .frames_utils import dump_frames + + +def generate_classification_dataset_problem(df, target_index, media_dir): + if not os.path.isabs(medVia_dir): + media_dir = os.path.abspath(media_dir) + dataset, problem = data_problem.generate_dataset_problem(df, + target_index=target_index, + media_dir=media_dir, + performance_metrics=[{'metric': PerformanceMetric.ACCURACY}], + task_keywords=[TaskKeyword.CLASSIFICATION,]) + + return dataset, problem + +def generate_dataset(df, target_index, media_dir): + if not os.path.isabs(media_dir): + media_dir = os.path.abspath(media_dir) + dataset = data_problem.import_input_data(df, + y=None, + target_index=target_index, + media_dir=media_dir) + + return dataset + +def generate_classification_problem(dataset): + problem = data_problem.generate_problem_description(dataset, + performance_metrics=[{'metric': PerformanceMetric.ACCURACY}], + task_keywords=[TaskKeyword.CLASSIFICATION,]) + + return problem + +def fit(train_dataset, train_media_dir, target_index, pipeline): + train_dataset = generate_dataset(train_dataset, target_index, train_media_dir) + problem = generate_classification_problem(train_dataset) + + # Start backend + backend = SimpleRunner(random_seed=0) + + # Fit + pipeline_result = backend.fit_pipeline(problem, pipeline, [train_dataset]) + if pipeline_result.status == "ERRORED": + raise pipeline_result.error + + # Fetch the runtime and dataaset metadata + fitted_pipeline = { + 'runtime': backend.fitted_pipelines[pipeline_result.fitted_pipeline_id], + 'dataset_metadata': train_dataset.metadata + } + + return pipeline_result.output, fitted_pipeline + +def produce(test_dataset, test_media_dir, target_index, fitted_pipeline): + test_dataset['label'] = -1 + test_dataset = generate_dataset(test_dataset, target_index, test_media_dir) + test_dataset.metadata = fitted_pipeline['dataset_metadata'] + + metadata_dict = test_dataset.metadata.query(('learningData', metadata_base.ALL_ELEMENTS, 1)) + metadata_dict = {key: metadata_dict[key] for key in metadata_dict} + metadata_dict['location_base_uris'] = [pathlib.Path(os.path.abspath(test_media_dir)).as_uri()+'/'] + test_dataset.metadata = test_dataset.metadata.update(('learningData', metadata_base.ALL_ELEMENTS, 1), metadata_dict) + + # Start backend + backend = SimpleRunner(random_seed=0) + + _id = str(uuid.uuid4()) + backend.fitted_pipelines[_id] = fitted_pipeline['runtime'] + + # Produce + pipeline_result = backend.produce_pipeline(_id, [test_dataset]) + if pipeline_result.status == "ERRORED": + raise pipeline_result.error + return pipeline_result.output + +def fit_produce(train_dataset, train_media_dir, test_dataset, test_media_dir, target_index, pipeline): + _, fitted_pipeline = fit(train_dataset, train_media_dir, target_index, pipeline) + output = produce(test_dataset, test_media_dir, target_index, fitted_pipeline) + + return output + +def produce_by_path(fitted_pipeline, video_path): + tmp_dir = os.path.join("tmp", str(uuid.uuid4())) + frame_dir = os.path.join(tmp_dir, "frames") + video_name = video_path.split('/')[-1] + dump_frames((video_path, video_name, 0, frame_dir)) + + dataset = { + 'd3mIndex': [0], + 'video': [video_name] + } + dataset = pd.DataFrame(data=dataset) + + # Produce + predictions = produce(test_dataset=dataset, + test_media_dir=tmp_dir, + target_index=2, + fitted_pipeline=fitted_pipeline) + + shutil.rmtree(tmp_dir) + + return predictions + + + + diff --git a/autovideo/utils/d3m_utils.py b/autovideo/utils/d3m_utils.py new file mode 100644 index 0000000..87710cb --- /dev/null +++ b/autovideo/utils/d3m_utils.py @@ -0,0 +1,129 @@ +from typing import List, Optional +from collections import OrderedDict +import uuid + +import numpy as np + +from d3m.container import DataFrame as d3m_dataframe +from d3m.primitive_interfaces.base import Hyperparams +from d3m.metadata import base as metadata_base + +Inputs = d3m_dataframe +Outputs = d3m_dataframe + +def construct_primitive_metadata(module, name): + metadata = metadata_base.PrimitiveMetadata( + { + 'id': str(uuid.uuid3(uuid.NAMESPACE_DNS, name)), + 'version': '0.0.1', + "name": "Implementation of " + name, + 'python_path': 'd3m.primitives.autovideo.' + module + '.' + name, + 'algorithm_types': [ + metadata_base.PrimitiveAlgorithmType.CONVOLUTIONAL_NEURAL_NETWORK, + ], + 'primitive_family': metadata_base.PrimitiveFamily.FEATURE_EXTRACTION, + }, + ) + return metadata + +def wrap_predictions(inputs: Inputs, predictions: np.ndarray, primitive_name: str) -> Outputs: + outputs = d3m_dataframe(predictions, generate_metadata=True) + target_columns_metadata = _add_target_columns_metadata(outputs.metadata, primitive_name) + outputs.metadata = _update_predictions_metadata(inputs.metadata, outputs, target_columns_metadata) + + return outputs + +def _add_target_columns_metadata(outputs_metadata: metadata_base.DataMetadata, primitive_name): + outputs_length = outputs_metadata.query((metadata_base.ALL_ELEMENTS,))['dimension']['length'] + target_columns_metadata: List[OrderedDict] = [] + for column_index in range(outputs_length): + column_name = "{0}{1}_{2}".format(primitive_name, 0, column_index) + column_metadata = OrderedDict() + semantic_types = set() + semantic_types.add('https://metadata.datadrivendiscovery.org/types/Attribute') + column_metadata['semantic_types'] = list(semantic_types) + + column_metadata["name"] = str(column_name) + target_columns_metadata.append(column_metadata) + + return target_columns_metadata + +def _update_predictions_metadata(inputs_metadata: metadata_base.DataMetadata, outputs: Optional[Outputs], + target_columns_metadata: List[OrderedDict]) -> metadata_base.DataMetadata: + outputs_metadata = metadata_base.DataMetadata().generate(value=outputs) + + for column_index, column_metadata in enumerate(target_columns_metadata): + column_metadata.pop("structural_type", None) + outputs_metadata = outputs_metadata.update_column(column_index, column_metadata) + + return outputs_metadata + +def build_pipeline(config): + """Build a pipline based on the config + """ + from d3m import index + from d3m.metadata.base import ArgumentType + from d3m.metadata.pipeline import Pipeline, PrimitiveStep + # Creating pipeline + pipeline_description = Pipeline() + pipeline_description.add_input(name='inputs') + + #Step 0: Denormalise + step_0 = PrimitiveStep(primitive=index.get_primitive('d3m.primitives.autovideo.common.denormalize')) + step_0.add_argument(name='inputs', argument_type=ArgumentType.CONTAINER, data_reference='inputs.0') + step_0.add_output('produce') + pipeline_description.add_step(step_0) + + #Step 1: Dataset to DataFrame + step_1 = PrimitiveStep(primitive=index.get_primitive('d3m.primitives.autovideo.common.dataset_to_dataframe')) + step_1.add_argument(name='inputs', argument_type=ArgumentType.CONTAINER, data_reference='steps.0.produce') + step_1.add_output('produce') + pipeline_description.add_step(step_1) + + #Step 2: Column Parser + step_2 = PrimitiveStep(primitive=index.get_primitive('d3m.primitives.autovideo.common.column_parser')) + step_2.add_argument(name='inputs', argument_type=ArgumentType.CONTAINER, data_reference='steps.1.produce') + step_2.add_output('produce') + pipeline_description.add_step(step_2) + + #Step 3: Extract columns by semantic types - Attributes + step_3 = PrimitiveStep(primitive=index.get_primitive('d3m.primitives.autovideo.common.extract_columns_by_semantic_types')) + step_3.add_argument(name='inputs', argument_type=ArgumentType.CONTAINER, data_reference='steps.2.produce') + step_3.add_output('produce') + step_3.add_hyperparameter(name='semantic_types', argument_type=ArgumentType.VALUE, + data=['https://metadata.datadrivendiscovery.org/types/Attribute']) + pipeline_description.add_step(step_3) + + #Step 4: Extract Columns by semantic types - Target + step_4 = PrimitiveStep(primitive=index.get_primitive('d3m.primitives.autovideo.common.extract_columns_by_semantic_types')) + step_4.add_argument(name='inputs', argument_type=ArgumentType.CONTAINER, data_reference='steps.1.produce') + step_4.add_output('produce') + step_4.add_hyperparameter(name='semantic_types', argument_type=ArgumentType.VALUE, + data=['https://metadata.datadrivendiscovery.org/types/TrueTarget']) + pipeline_description.add_step(step_4) + + #Step 5: Video primitive + algorithm = config.pop('algorithm', None) + alg_python_path = 'd3m.primitives.autovideo.recognition.' + algorithm + step_5 = PrimitiveStep(primitive=index.get_primitive(alg_python_path)) + step_5.add_argument(name='inputs', argument_type=ArgumentType.CONTAINER, data_reference='steps.3.produce') + step_5.add_argument(name='outputs', argument_type=ArgumentType.CONTAINER, data_reference='steps.4.produce') + # Add hyperparameters + for key, value in config.items(): + step_5.add_hyperparameter(name=key, argument_type=ArgumentType.VALUE, data=value) + step_5.add_output('produce') + pipeline_description.add_step(step_5) + + #Step 6: Construct the predictions + step_6 = PrimitiveStep(primitive=index.get_primitive('d3m.primitives.autovideo.common.construct_predictions')) + step_6.add_argument(name='inputs', argument_type=ArgumentType.CONTAINER, data_reference='steps.5.produce') + step_6.add_argument(name='reference', argument_type=ArgumentType.CONTAINER, data_reference='steps.2.produce') + step_6.add_output('produce') + step_6.add_hyperparameter(name = 'use_columns', argument_type=ArgumentType.VALUE, data = [0,1]) + pipeline_description.add_step(step_6) + + # Final Output + pipeline_description.add_output(name='output predictions', data_reference='steps.6.produce') + + return pipeline_description + diff --git a/autovideo/utils/dataset.py b/autovideo/utils/dataset.py new file mode 100644 index 0000000..e727f62 --- /dev/null +++ b/autovideo/utils/dataset.py @@ -0,0 +1,142 @@ +import torch.utils.data as data + +from PIL import Image +import os +import os.path +import numpy as np +from numpy.random import randint + +class VideoRecord(object): + def __init__(self, row): + self._data = row + + @property + def path(self): + return self._data[0] + + @property + def num_frames(self): + return int(self._data[1]) + + @property + def label(self): + return int(self._data[2]) + +class VideoRecordTest(object): + def __init__(self, row): + self._data = row + + @property + def path(self): + return self._data[0] + + @property + def num_frames(self): + return int(self._data[1]) + + +class VideoDataSet(data.Dataset): + def __init__(self, root_path, video_list, + num_segments=3, new_length=1, modality='RGB', + image_tmpl='img_{:05d}.jpg', transform=None, + force_grayscale=False, random_shift=True, test_mode=False, input_format="NCHW"): + + self.root_path = root_path + self.video_list = video_list + self.num_segments = num_segments + self.new_length = new_length + self.modality = modality + self.image_tmpl = image_tmpl + self.transform = transform + self.random_shift = random_shift + self.test_mode = test_mode + test_mode_g = self.test_mode + self.input_format = input_format + if self.modality == 'RGBDiff': + self.new_length += 1# Diff needs one more image to calculate diff + + self._parse_list() + + def _load_image(self, directory, idx): + + if self.modality == 'RGB' or self.modality == 'RGBDiff': + return [Image.open(os.path.join(directory, self.image_tmpl.format(idx))).convert('RGB')] + elif self.modality == 'Flow': + x_img = Image.open(os.path.join(directory, self.image_tmpl.format('x', idx))).convert('L') + y_img = Image.open(os.path.join(directory, self.image_tmpl.format('y', idx))).convert('L') + + return [x_img, y_img] + + def _parse_list(self): + if self.test_mode == False: + self.video_list = [VideoRecord(x) for x in self.video_list] + else: + self.video_list = [VideoRecordTest(x) for x in self.video_list] + + def _sample_indices(self, record): + """ + + :param record: VideoRecord + :return: list + """ + + average_duration = (record.num_frames - self.new_length + 1) // self.num_segments + if average_duration > 0: + offsets = np.multiply(list(range(self.num_segments)), average_duration) + randint(average_duration, size=self.num_segments) + elif record.num_frames > self.num_segments: + offsets = np.sort(randint(record.num_frames - self.new_length + 1, size=self.num_segments)) + else: + offsets = np.zeros((self.num_segments,)) + return offsets + 1 + + def _get_val_indices(self, record): + if record.num_frames > self.num_segments + self.new_length - 1: + tick = (record.num_frames - self.new_length + 1) / float(self.num_segments) + offsets = np.array([int(tick / 2.0 + tick * x) for x in range(self.num_segments)]) + else: + offsets = np.zeros((self.num_segments,)) + return offsets + 1 + + def _get_test_indices(self, record): + + tick = (record.num_frames - self.new_length + 1) / float(self.num_segments) + + offsets = np.array([int(tick / 2.0 + tick * x) for x in range(self.num_segments)]) + + return offsets + 1 + + def __getitem__(self, index): + record = self.video_list[index] + + if not self.test_mode: + segment_indices = self._sample_indices(record) if self.random_shift else self._get_val_indices(record) + else: + segment_indices = self._get_test_indices(record) + + return self.get(record, segment_indices) + + def get(self, record, indices): + + images = list() + for seg_ind in indices: + p = int(seg_ind) + for i in range(self.new_length): + seg_imgs = self._load_image(record.path, p) + images.extend(seg_imgs) + if p < record.num_frames: + p += 1 + + process_data = self.transform(images) + if self.input_format == "NCTHW": + #Reshape in the format C x Segments x Height x Width + c, h, w = process_data.shape + c = int(c/self.num_segments) + process_data = process_data.reshape((c,self.num_segments)+process_data.shape[1:]) + if self.test_mode==False: + return process_data, record.label + else: + return process_data + + + def __len__(self): + return len(self.video_list) diff --git a/autovideo/utils/frames_utils.py b/autovideo/utils/frames_utils.py new file mode 100644 index 0000000..3020e5d --- /dev/null +++ b/autovideo/utils/frames_utils.py @@ -0,0 +1,65 @@ +""" Some utils to to process frames +""" +import sys +import os +import glob +from multiprocessing import Pool + +import mmcv + + +def dump_frames(vid_item): + """ Dump frames for one video + """ + full_path, vid_path, vid_id, out_dir = vid_item + vid_name = vid_path.split('.')[0] + out_full_path = os.path.join(out_dir, vid_name) + if not os.path.exists(out_full_path): + os.makedirs(out_full_path) + vr = mmcv.VideoReader(full_path) + for i in range(len(vr)): + if vr[i] is not None: + mmcv.imwrite( + vr[i], '{}/img_{:05d}.jpg'.format(out_full_path, i + 1)) + else: + print('[Warning] length inconsistent!' + 'Early stop with {} out of {} frames'.format(i + 1, len(vr))) + break + print('{} done with {} frames'.format(vid_name, len(vr))) + sys.stdout.flush() + return True + +def extract_frames(media_dir, ext, num_worker=8): + out_dir = os.path.join(media_dir, 'frames') + if not os.path.exists(out_dir): + os.makedirs(out_dir) + fullpath_list = glob.glob(media_dir + '/*' + ext) + done_list = [p.split('/')[-1] for p in glob.glob(out_dir + '/*')] + _fullpath_list = [] + for p in fullpath_list: + if os.path.splitext(os.path.basename(p))[0] not in done_list: + _fullpath_list.append(p) + fullpath_list = _fullpath_list + if len(fullpath_list) == 0: + return + vid_list = list(map(lambda p: p.split('/')[-1], fullpath_list)) + pool = Pool(num_worker) + pool.map(dump_frames, zip( + fullpath_list, vid_list, range(len(vid_list)), [out_dir]*len(vid_list))) + +def get_frame_list(media_dir, inputs, outputs=None, test_mode=False): + """Returns the frame list with frame directory, #frames, label for each video for training data and frame directory, #frames for test data""" + frame_root_dir = os.path.join(media_dir, 'frames') + video_list = [] + for i in range(len(inputs)): + video_name = os.path.splitext(inputs.iloc[i, 0])[0] + frame_dir = os.path.join(frame_root_dir, video_name) + num_frames = len(os.listdir(frame_dir)) + if test_mode == False: + label = outputs.iloc[i,0] + video_list.append((frame_dir, num_frames, label)) + else: + video_list.append((frame_dir, num_frames)) + + return video_list + diff --git a/autovideo/utils/logging_utils.py b/autovideo/utils/logging_utils.py new file mode 100644 index 0000000..cc2ef34 --- /dev/null +++ b/autovideo/utils/logging_utils.py @@ -0,0 +1,23 @@ +import logging + +def _get_logger(log_path=None): + if log_path is None: + shandle = logging.StreamHandler() + else: + shandle = logging.FileHandler(log_path, 'w') + shandle.setFormatter( + logging.Formatter( + '[%(levelname)s:%(process)d %(module)s:%(lineno)d %(asctime)s] ' + '%(message)s')) + logger = logging.getLogger('autovideo') + logger.propagate = False + logger.addHandler(shandle) + logger.setLevel(logging.INFO) + + return logger + +logger = _get_logger() + +def set_log_path(log_path): + global logger + logger = _get_logger(log_path) diff --git a/autovideo/utils/models/densenet.py b/autovideo/utils/models/densenet.py new file mode 100644 index 0000000..6e4a616 --- /dev/null +++ b/autovideo/utils/models/densenet.py @@ -0,0 +1,151 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from collections import OrderedDict +import math + +__all__ = ['DenseNet', 'densenet121', 'densenet169', 'densenet201', 'densenet264'] + + +def densenet121(**kwargs): + model = DenseNet(num_init_features=64, growth_rate=32, block_config=(6, 12, 24, 16), + **kwargs) + return model + + +def densenet169(**kwargs): + model = DenseNet(num_init_features=64, growth_rate=32, block_config=(6, 12, 32, 32), + **kwargs) + return model + + +def densenet201(**kwargs): + model = DenseNet(num_init_features=64, growth_rate=32, block_config=(6, 12, 48, 32), + **kwargs) + return model + + +def densenet264(**kwargs): + model = DenseNet(num_init_features=64, growth_rate=32, block_config=(6, 12, 64, 48), + **kwargs) + return model + + +def get_fine_tuning_parameters(model, ft_begin_index): + if ft_begin_index == 0: + return model.parameters() + + ft_module_names = [] + for i in range(ft_begin_index, 5): + ft_module_names.append('denseblock{}'.format(ft_begin_index)) + ft_module_names.append('transition{}'.format(ft_begin_index)) + ft_module_names.append('norm5') + ft_module_names.append('classifier') + + parameters = [] + for k, v in model.named_parameters(): + for ft_module in ft_module_names: + if ft_module in k: + parameters.append({'params': v}) + break + else: + parameters.append({'params': v, 'lr': 0.0}) + + return parameters + + +class _DenseLayer(nn.Sequential): + def __init__(self, num_input_features, growth_rate, bn_size, drop_rate): + super(_DenseLayer, self).__init__() + self.add_module('norm.1', nn.BatchNorm3d(num_input_features)) + self.add_module('relu.1', nn.ReLU(inplace=True)) + self.add_module('conv.1', nn.Conv3d(num_input_features, bn_size * growth_rate, + kernel_size=1, stride=1, bias=False)) + self.add_module('norm.2', nn.BatchNorm3d(bn_size * growth_rate)) + self.add_module('relu.2', nn.ReLU(inplace=True)) + self.add_module('conv.2', nn.Conv3d(bn_size * growth_rate, growth_rate, + kernel_size=3, stride=1, padding=1, bias=False)) + self.drop_rate = drop_rate + + def forward(self, x): + new_features = super(_DenseLayer, self).forward(x) + if self.drop_rate > 0: + new_features = F.dropout(new_features, p=self.drop_rate, training=self.training) + return torch.cat([x, new_features], 1) + + +class _DenseBlock(nn.Sequential): + def __init__(self, num_layers, num_input_features, bn_size, growth_rate, drop_rate): + super(_DenseBlock, self).__init__() + for i in range(num_layers): + layer = _DenseLayer(num_input_features + i * growth_rate, growth_rate, bn_size, drop_rate) + self.add_module('denselayer%d' % (i + 1), layer) + + +class _Transition(nn.Sequential): + def __init__(self, num_input_features, num_output_features): + super(_Transition, self).__init__() + self.add_module('norm', nn.BatchNorm3d(num_input_features)) + self.add_module('relu', nn.ReLU(inplace=True)) + self.add_module('conv', nn.Conv3d(num_input_features, num_output_features, + kernel_size=1, stride=1, bias=False)) + self.add_module('pool', nn.AvgPool3d(kernel_size=2, stride=2)) + + +class DenseNet(nn.Module): + """Densenet-BC model class + Args: + growth_rate (int) - how many filters to add each layer (k in paper) + block_config (list of 4 ints) - how many layers in each pooling block + num_init_features (int) - the number of filters to learn in the first convolution layer + bn_size (int) - multiplicative factor for number of bottle neck layers + (i.e. bn_size * k features in the bottleneck layer) + drop_rate (float) - dropout rate after each dense layer + num_classes (int) - number of classification classes + """ + def __init__(self, sample_size, sample_duration, growth_rate=32, block_config=(6, 12, 24, 16), + num_init_features=64, bn_size=4, drop_rate=0, num_classes=1000, last_fc=True): + + super(DenseNet, self).__init__() + + self.last_fc = last_fc + + self.sample_size = sample_size + self.sample_duration = sample_duration + + # First convolution + self.features = nn.Sequential(OrderedDict([ + ('conv0', nn.Conv3d(3, num_init_features, kernel_size=7, + stride=(1, 2, 2), padding=(3, 3, 3), bias=False)), + ('norm0', nn.BatchNorm3d(num_init_features)), + ('relu0', nn.ReLU(inplace=True)), + ('pool0', nn.MaxPool3d(kernel_size=3, stride=2, padding=1)), + ])) + + # Each denseblock + num_features = num_init_features + for i, num_layers in enumerate(block_config): + block = _DenseBlock(num_layers=num_layers, num_input_features=num_features, + bn_size=bn_size, growth_rate=growth_rate, drop_rate=drop_rate) + self.features.add_module('denseblock%d' % (i + 1), block) + num_features = num_features + num_layers * growth_rate + if i != len(block_config) - 1: + trans = _Transition(num_input_features=num_features, num_output_features=num_features // 2) + self.features.add_module('transition%d' % (i + 1), trans) + num_features = num_features // 2 + + # Final batch norm + self.features.add_module('norm5', nn.BatchNorm2d(num_features)) + + # Linear layer + self.classifier = nn.Linear(num_features, num_classes) + + def forward(self, x): + features = self.features(x) + out = F.relu(features, inplace=True) + last_duration = math.ceil(self.sample_duration / 16) + last_size = math.floor(self.sample_size / 32) + out = F.avg_pool3d(out, kernel_size=(last_duration, last_size, last_size)).view(features.size(0), -1) + if self.last_fc: + out = self.classifier(out) + return out diff --git a/autovideo/utils/models/pre_act_resnet.py b/autovideo/utils/models/pre_act_resnet.py new file mode 100644 index 0000000..0c48b8a --- /dev/null +++ b/autovideo/utils/models/pre_act_resnet.py @@ -0,0 +1,226 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.autograd import Variable +import math +from functools import partial + +__all__ = ['PreActivationResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101', 'resnet152', 'resnet200'] + + +def conv3x3x3(in_planes, out_planes, stride=1): + # 3x3x3 convolution with padding + return nn.Conv3d(in_planes, out_planes, kernel_size=3, + stride=stride, padding=1, bias=False) + + +def downsample_basic_block(x, planes, stride): + out = F.avg_pool3d(x, kernel_size=1, stride=stride) + zero_pads = torch.Tensor(out.size(0), planes - out.size(1), + out.size(2), out.size(3), + out.size(4)).zero_() + if isinstance(out.data, torch.cuda.FloatTensor): + zero_pads = zero_pads.cuda() + + out = Variable(torch.cat([out.data, zero_pads], dim=1)) + + return out + + +class PreActivationBasicBlock(nn.Module): + expansion = 1 + + def __init__(self, inplanes, planes, stride=1, downsample=None): + super(PreActivationBasicBlock, self).__init__() + self.bn1 = nn.BatchNorm3d(inplanes) + self.conv1 = conv3x3x3(inplanes, planes, stride) + self.bn2 = nn.BatchNorm3d(planes) + self.conv2 = conv3x3x3(planes, planes) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.bn1(x) + out = self.relu(out) + out = self.conv1(out) + + out = self.bn2(out) + out = self.relu(out) + out = self.conv2(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + + return out + + +class PreActivationBottleneck(nn.Module): + expansion = 4 + + def __init__(self, inplanes, planes, stride=1, downsample=None): + super(PreActivationBottleneck, self).__init__() + self.bn1 = nn.BatchNorm3d(inplanes) + self.conv1 = nn.Conv3d(inplanes, planes, kernel_size=1, bias=False) + self.bn2 = nn.BatchNorm3d(planes) + self.conv2 = nn.Conv3d(planes, planes, kernel_size=3, stride=stride, + padding=1, bias=False) + self.bn3 = nn.BatchNorm3d(planes) + self.conv3 = nn.Conv3d(planes, planes * 4, kernel_size=1, bias=False) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.bn1(x) + out = self.relu(out) + out = self.conv1(out) + + out = self.bn2(out) + out = self.relu(out) + out = self.conv2(out) + + out = self.bn3(out) + out = self.relu(out) + out = self.conv3(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + + return out + + +class PreActivationResNet(nn.Module): + + def __init__(self, block, layers, sample_size, sample_duration, shortcut_type='B', num_classes=400, last_fc=True): + self.last_fc = last_fc + + self.inplanes = 64 + super(PreActivationResNet, self).__init__() + self.conv1 = nn.Conv3d(3, 64, kernel_size=7, stride=(1, 2, 2), + padding=(3, 3, 3), bias=False) + self.bn1 = nn.BatchNorm3d(64) + self.relu = nn.ReLU(inplace=True) + self.maxpool = nn.MaxPool3d(kernel_size=(3, 3, 3), stride=2, padding=1) + self.layer1 = self._make_layer(block, 64, layers[0], shortcut_type) + self.layer2 = self._make_layer(block, 128, layers[1], shortcut_type, stride=2) + self.layer3 = self._make_layer(block, 256, layers[2], shortcut_type, stride=2) + self.layer4 = self._make_layer(block, 512, layers[3], shortcut_type, stride=2) + last_duration = math.ceil(sample_duration / 16) + last_size = math.ceil(sample_size / 32) + self.avgpool = nn.AvgPool3d((last_duration, last_size, last_size), stride=1) + self.fc = nn.Linear(512 * block.expansion, num_classes) + + for m in self.modules(): + if isinstance(m, nn.Conv3d): + n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + m.weight.data.normal_(0, math.sqrt(2. / n)) + elif isinstance(m, nn.BatchNorm3d): + m.weight.data.fill_(1) + m.bias.data.zero_() + + def _make_layer(self, block, planes, blocks, shortcut_type, stride=1): + downsample = None + if stride != 1 or self.inplanes != planes * block.expansion: + if shortcut_type == 'A': + downsample = partial(downsample_basic_block, + planes=planes * block.expansion, + stride=stride) + else: + downsample = nn.Sequential( + nn.Conv3d(self.inplanes, planes * block.expansion, + kernel_size=1, stride=stride, bias=False), + nn.BatchNorm3d(planes * block.expansion) + ) + + layers = [] + layers.append(block(self.inplanes, planes, stride, downsample)) + self.inplanes = planes * block.expansion + for i in range(1, blocks): + layers.append(block(self.inplanes, planes)) + + return nn.Sequential(*layers) + + def forward(self, x): + x = self.conv1(x) + x = self.bn1(x) + x = self.relu(x) + x = self.maxpool(x) + + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + + x = self.avgpool(x) + + x = x.view(x.size(0), -1) + if self.last_fc: + x = self.fc(x) + + return x + +def get_fine_tuning_parameters(model, ft_begin_index): + if ft_begin_index == 0: + return model.parameters() + + ft_module_names = [] + for i in range(ft_begin_index, 5): + ft_module_names.append('layer{}'.format(ft_begin_index)) + ft_module_names.append('fc') + + parameters = [] + for k, v in model.named_parameters(): + for ft_module in ft_module_names: + if ft_module in k: + parameters.append({'params': v}) + break + else: + parameters.append({'params': v, 'lr': 0.0}) + + return parameters + +def resnet18(**kwargs): + """Constructs a ResNet-18 model. + """ + model = PreActivationResNet(PreActivationBasicBlock, [2, 2, 2, 2], **kwargs) + return model + +def resnet34(**kwargs): + """Constructs a ResNet-34 model. + """ + model = PreActivationResNet(PreActivationBasicBlock, [3, 4, 6, 3], **kwargs) + return model + + +def resnet50(**kwargs): + """Constructs a ResNet-50 model. + """ + model = PreActivationResNet(PreActivationBottleneck, [3, 4, 6, 3], **kwargs) + return model + +def resnet101(**kwargs): + """Constructs a ResNet-101 model. + """ + model = PreActivationResNet(PreActivationBottleneck, [3, 4, 23, 3], **kwargs) + return model + +def resnet152(**kwargs): + """Constructs a ResNet-101 model. + """ + model = PreActivationResNet(PreActivationBottleneck, [3, 8, 36, 3], **kwargs) + return model + +def resnet200(**kwargs): + """Constructs a ResNet-101 model. + """ + model = PreActivationResNet(PreActivationBottleneck, [3, 24, 36, 3], **kwargs) + return model diff --git a/autovideo/utils/models/resnet.py b/autovideo/utils/models/resnet.py new file mode 100644 index 0000000..adf8a10 --- /dev/null +++ b/autovideo/utils/models/resnet.py @@ -0,0 +1,233 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.autograd import Variable +import math +from functools import partial + +__all__ = ['ResNet', 'resnet10', 'resnet18', 'resnet34', 'resnet50', 'resnet101', 'resnet152', 'resnet200'] + + +def conv3x3x3(in_planes, out_planes, stride=1): + # 3x3x3 convolution with padding + return nn.Conv3d(in_planes, out_planes, kernel_size=3, + stride=stride, padding=1, bias=False) + + +def downsample_basic_block(x, planes, stride): + out = F.avg_pool3d(x, kernel_size=1, stride=stride) + zero_pads = torch.Tensor(out.size(0), planes - out.size(1), + out.size(2), out.size(3), + out.size(4)).zero_() + if isinstance(out.data, torch.cuda.FloatTensor): + zero_pads = zero_pads.cuda() + + out = Variable(torch.cat([out.data, zero_pads], dim=1)) + + return out + + +class BasicBlock(nn.Module): + expansion = 1 + + def __init__(self, inplanes, planes, stride=1, downsample=None): + super(BasicBlock, self).__init__() + self.conv1 = conv3x3x3(inplanes, planes, stride) + self.bn1 = nn.BatchNorm3d(planes) + self.relu = nn.ReLU(inplace=True) + self.conv2 = conv3x3x3(planes, planes) + self.bn2 = nn.BatchNorm3d(planes) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, inplanes, planes, stride=1, downsample=None): + super(Bottleneck, self).__init__() + self.conv1 = nn.Conv3d(inplanes, planes, kernel_size=1, bias=False) + self.bn1 = nn.BatchNorm3d(planes) + self.conv2 = nn.Conv3d(planes, planes, kernel_size=3, stride=stride, + padding=1, bias=False) + self.bn2 = nn.BatchNorm3d(planes) + self.conv3 = nn.Conv3d(planes, planes * 4, kernel_size=1, bias=False) + self.bn3 = nn.BatchNorm3d(planes * 4) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + out = self.relu(out) + + out = self.conv3(out) + out = self.bn3(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class ResNet(nn.Module): + + def __init__(self, block, layers, sample_size, sample_duration, shortcut_type='B', num_classes=400, last_fc=True): + self.last_fc = last_fc + + self.inplanes = 64 + super(ResNet, self).__init__() + self.conv1 = nn.Conv3d(3, 64, kernel_size=7, stride=(1, 2, 2), + padding=(3, 3, 3), bias=False) + self.bn1 = nn.BatchNorm3d(64) + self.relu = nn.ReLU(inplace=True) + self.maxpool = nn.MaxPool3d(kernel_size=(3, 3, 3), stride=2, padding=1) + self.layer1 = self._make_layer(block, 64, layers[0], shortcut_type) + self.layer2 = self._make_layer(block, 128, layers[1], shortcut_type, stride=2) + self.layer3 = self._make_layer(block, 256, layers[2], shortcut_type, stride=2) + self.layer4 = self._make_layer(block, 512, layers[3], shortcut_type, stride=2) + last_duration = math.ceil(sample_duration / 16) + last_size = math.ceil(sample_size / 32) + self.avgpool = nn.AvgPool3d((last_duration, last_size, last_size), stride=1) + self.fc = nn.Linear(512 * block.expansion, num_classes) + + for m in self.modules(): + if isinstance(m, nn.Conv3d): + n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + m.weight.data.normal_(0, math.sqrt(2. / n)) + elif isinstance(m, nn.BatchNorm3d): + m.weight.data.fill_(1) + m.bias.data.zero_() + + def _make_layer(self, block, planes, blocks, shortcut_type, stride=1): + downsample = None + if stride != 1 or self.inplanes != planes * block.expansion: + if shortcut_type == 'A': + downsample = partial(downsample_basic_block, + planes=planes * block.expansion, + stride=stride) + else: + downsample = nn.Sequential( + nn.Conv3d(self.inplanes, planes * block.expansion, + kernel_size=1, stride=stride, bias=False), + nn.BatchNorm3d(planes * block.expansion) + ) + + layers = [] + layers.append(block(self.inplanes, planes, stride, downsample)) + self.inplanes = planes * block.expansion + for i in range(1, blocks): + layers.append(block(self.inplanes, planes)) + + return nn.Sequential(*layers) + + def forward(self, x): + x = self.conv1(x) + x = self.bn1(x) + x = self.relu(x) + x = self.maxpool(x) + + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + + x = self.avgpool(x) + + x = x.view(x.size(0), -1) + if self.last_fc: + x = self.fc(x) + + return x + + +def get_fine_tuning_parameters(model, ft_begin_index): + if ft_begin_index == 0: + return model.parameters() + + ft_module_names = [] + for i in range(ft_begin_index, 5): + ft_module_names.append('layer{}'.format(ft_begin_index)) + ft_module_names.append('fc') + + parameters = [] + for k, v in model.named_parameters(): + for ft_module in ft_module_names: + if ft_module in k: + parameters.append({'params': v}) + break + else: + parameters.append({'params': v, 'lr': 0.0}) + + return parameters + + +def resnet10(**kwargs): + """Constructs a ResNet-18 model. + """ + model = ResNet(BasicBlock, [1, 1, 1, 1], **kwargs) + return model + +def resnet18(**kwargs): + """Constructs a ResNet-18 model. + """ + model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs) + return model + +def resnet34(**kwargs): + """Constructs a ResNet-34 model. + """ + model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs) + return model + +def resnet50(**kwargs): + """Constructs a ResNet-50 model. + """ + model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs) + return model + +def resnet101(**kwargs): + """Constructs a ResNet-101 model. + """ + model = ResNet(Bottleneck, [3, 4, 23, 3], **kwargs) + return model + +def resnet152(**kwargs): + """Constructs a ResNet-101 model. + """ + model = ResNet(Bottleneck, [3, 8, 36, 3], **kwargs) + return model + +def resnet200(**kwargs): + """Constructs a ResNet-101 model. + """ + model = ResNet(Bottleneck, [3, 24, 36, 3], **kwargs) + return model diff --git a/autovideo/utils/models/resnext.py b/autovideo/utils/models/resnext.py new file mode 100644 index 0000000..0ed2dc1 --- /dev/null +++ b/autovideo/utils/models/resnext.py @@ -0,0 +1,176 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.autograd import Variable +import math +from functools import partial + +__all__ = ['ResNeXt', 'resnet50', 'resnet101'] + + +def conv3x3x3(in_planes, out_planes, stride=1): + # 3x3x3 convolution with padding + return nn.Conv3d(in_planes, out_planes, kernel_size=3, + stride=stride, padding=1, bias=False) + + +def downsample_basic_block(x, planes, stride): + out = F.avg_pool3d(x, kernel_size=1, stride=stride) + zero_pads = torch.Tensor(out.size(0), planes - out.size(1), + out.size(2), out.size(3), + out.size(4)).zero_() + if isinstance(out.data, torch.cuda.FloatTensor): + zero_pads = zero_pads.cuda() + + out = Variable(torch.cat([out.data, zero_pads], dim=1)) + + return out + + +class ResNeXtBottleneck(nn.Module): + expansion = 2 + + def __init__(self, inplanes, planes, cardinality, stride=1, downsample=None): + super(ResNeXtBottleneck, self).__init__() + mid_planes = cardinality * int(planes / 32) + self.conv1 = nn.Conv3d(inplanes, mid_planes, kernel_size=1, bias=False) + self.bn1 = nn.BatchNorm3d(mid_planes) + self.conv2 = nn.Conv3d(mid_planes, mid_planes, kernel_size=3, stride=stride, + padding=1, groups=cardinality, bias=False) + self.bn2 = nn.BatchNorm3d(mid_planes) + self.conv3 = nn.Conv3d(mid_planes, planes * self.expansion, kernel_size=1, bias=False) + self.bn3 = nn.BatchNorm3d(planes * self.expansion) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + out = self.relu(out) + + out = self.conv3(out) + out = self.bn3(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class ResNeXt(nn.Module): + + def __init__(self, block, layers, sample_size, sample_duration, shortcut_type='B', cardinality=32, num_classes=400, last_fc=True): + self.last_fc = last_fc + + self.inplanes = 64 + super(ResNeXt, self).__init__() + self.conv1 = nn.Conv3d(3, 64, kernel_size=7, stride=(1, 2, 2), + padding=(3, 3, 3), bias=False) + self.bn1 = nn.BatchNorm3d(64) + self.relu = nn.ReLU(inplace=True) + self.maxpool = nn.MaxPool3d(kernel_size=(3, 3, 3), stride=2, padding=1) + self.layer1 = self._make_layer(block, 128, layers[0], shortcut_type, cardinality) + self.layer2 = self._make_layer(block, 256, layers[1], shortcut_type, cardinality, stride=2) + self.layer3 = self._make_layer(block, 512, layers[2], shortcut_type, cardinality, stride=2) + self.layer4 = self._make_layer(block, 1024, layers[3], shortcut_type, cardinality, stride=2) + last_duration = math.ceil(sample_duration / 16) + last_size = math.ceil(sample_size / 32) + self.avgpool = nn.AvgPool3d((last_duration, last_size, last_size), stride=1) + self.fc = nn.Linear(cardinality * 32 * block.expansion, num_classes) + + for m in self.modules(): + if isinstance(m, nn.Conv3d): + n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + m.weight.data.normal_(0, math.sqrt(2. / n)) + elif isinstance(m, nn.BatchNorm3d): + m.weight.data.fill_(1) + m.bias.data.zero_() + + def _make_layer(self, block, planes, blocks, shortcut_type, cardinality, stride=1): + downsample = None + if stride != 1 or self.inplanes != planes * block.expansion: + if shortcut_type == 'A': + downsample = partial(downsample_basic_block, + planes=planes * block.expansion, + stride=stride) + else: + downsample = nn.Sequential( + nn.Conv3d(self.inplanes, planes * block.expansion, + kernel_size=1, stride=stride, bias=False), + nn.BatchNorm3d(planes * block.expansion) + ) + + layers = [] + layers.append(block(self.inplanes, planes, cardinality, stride, downsample)) + self.inplanes = planes * block.expansion + for i in range(1, blocks): + layers.append(block(self.inplanes, planes, cardinality)) + + return nn.Sequential(*layers) + + def forward(self, x): + x = self.conv1(x) + x = self.bn1(x) + x = self.relu(x) + x = self.maxpool(x) + + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + + x = self.avgpool(x) + + x = x.view(x.size(0), -1) + if self.last_fc: + x = self.fc(x) + + return x + +def get_fine_tuning_parameters(model, ft_begin_index): + if ft_begin_index == 0: + return model.parameters() + + ft_module_names = [] + for i in range(ft_begin_index, 5): + ft_module_names.append('layer{}'.format(ft_begin_index)) + ft_module_names.append('fc') + + parameters = [] + for k, v in model.named_parameters(): + for ft_module in ft_module_names: + if ft_module in k: + parameters.append({'params': v}) + break + else: + parameters.append({'params': v, 'lr': 0.0}) + + return parameters + +def resnet50(**kwargs): + """Constructs a ResNet-50 model. + """ + model = ResNeXt(ResNeXtBottleneck, [3, 4, 6, 3], **kwargs) + return model + +def resnet101(**kwargs): + """Constructs a ResNet-101 model. + """ + model = ResNeXt(ResNeXtBottleneck, [3, 4, 23, 3], **kwargs) + return model + +def resnet152(**kwargs): + """Constructs a ResNet-101 model. + """ + model = ResNeXt(ResNeXtBottleneck, [3, 8, 36, 3], **kwargs) + return model diff --git a/autovideo/utils/models/wide_resnet.py b/autovideo/utils/models/wide_resnet.py new file mode 100644 index 0000000..816ce22 --- /dev/null +++ b/autovideo/utils/models/wide_resnet.py @@ -0,0 +1,163 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.autograd import Variable +import math +from functools import partial + +__all__ = ['WideResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101'] + + +def conv3x3x3(in_planes, out_planes, stride=1): + # 3x3x3 convolution with padding + return nn.Conv3d(in_planes, out_planes, kernel_size=3, + stride=stride, padding=1, bias=False) + + +def downsample_basic_block(x, planes, stride): + out = F.avg_pool3d(x, kernel_size=1, stride=stride) + zero_pads = torch.Tensor(out.size(0), planes - out.size(1), + out.size(2), out.size(3), + out.size(4)).zero_() + if isinstance(out.data, torch.cuda.FloatTensor): + zero_pads = zero_pads.cuda() + + out = Variable(torch.cat([out.data, zero_pads], dim=1)) + + return out + + +class WideBottleneck(nn.Module): + expansion = 2 + + def __init__(self, inplanes, planes, stride=1, downsample=None): + super(WideBottleneck, self).__init__() + self.conv1 = nn.Conv3d(inplanes, planes, kernel_size=1, bias=False) + self.bn1 = nn.BatchNorm3d(planes) + self.conv2 = nn.Conv3d(planes, planes, kernel_size=3, stride=stride, + padding=1, bias=False) + self.bn2 = nn.BatchNorm3d(planes) + self.conv3 = nn.Conv3d(planes, planes * self.expansion, kernel_size=1, bias=False) + self.bn3 = nn.BatchNorm3d(planes * self.expansion) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + out = self.relu(out) + + out = self.conv3(out) + out = self.bn3(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class WideResNet(nn.Module): + + def __init__(self, block, layers, sample_size, sample_duration, k=1, shortcut_type='B', num_classes=400, last_fc=True): + self.last_fc = last_fc + + self.inplanes = 64 + super(WideResNet, self).__init__() + self.conv1 = nn.Conv3d(3, 64, kernel_size=7, stride=(1, 2, 2), + padding=(3, 3, 3), bias=False) + self.bn1 = nn.BatchNorm3d(64) + self.relu = nn.ReLU(inplace=True) + self.maxpool = nn.MaxPool3d(kernel_size=(3, 3, 3), stride=2, padding=1) + self.layer1 = self._make_layer(block, 64 * k, layers[0], shortcut_type) + self.layer2 = self._make_layer(block, 128 * k, layers[1], shortcut_type, stride=2) + self.layer3 = self._make_layer(block, 256 * k, layers[2], shortcut_type, stride=2) + self.layer4 = self._make_layer(block, 512 * k, layers[3], shortcut_type, stride=2) + last_duration = math.ceil(sample_duration / 16) + last_size = math.ceil(sample_size / 32) + self.avgpool = nn.AvgPool3d((last_duration, last_size, last_size), stride=1) + self.fc = nn.Linear(512 * k * block.expansion, num_classes) + + for m in self.modules(): + if isinstance(m, nn.Conv3d): + n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + m.weight.data.normal_(0, math.sqrt(2. / n)) + elif isinstance(m, nn.BatchNorm3d): + m.weight.data.fill_(1) + m.bias.data.zero_() + + def _make_layer(self, block, planes, blocks, shortcut_type, stride=1): + downsample = None + if stride != 1 or self.inplanes != planes * block.expansion: + if shortcut_type == 'A': + downsample = partial(downsample_basic_block, + planes=planes * block.expansion, + stride=stride) + else: + downsample = nn.Sequential( + nn.Conv3d(self.inplanes, planes * block.expansion, + kernel_size=1, stride=stride, bias=False), + nn.BatchNorm3d(planes * block.expansion) + ) + + layers = [] + layers.append(block(self.inplanes, planes, stride, downsample)) + self.inplanes = planes * block.expansion + for i in range(1, blocks): + layers.append(block(self.inplanes, planes)) + + return nn.Sequential(*layers) + + def forward(self, x): + x = self.conv1(x) + x = self.bn1(x) + x = self.relu(x) + x = self.maxpool(x) + + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + + x = self.avgpool(x) + + x = x.view(x.size(0), -1) + if self.last_fc: + x = self.fc(x) + + return x + +def get_fine_tuning_parameters(model, ft_begin_index): + if ft_begin_index == 0: + return model.parameters() + + ft_module_names = [] + for i in range(ft_begin_index, 5): + ft_module_names.append('layer{}'.format(ft_begin_index)) + ft_module_names.append('fc') + + parameters = [] + for k, v in model.named_parameters(): + for ft_module in ft_module_names: + if ft_module in k: + parameters.append({'params': v}) + break + else: + parameters.append({'params': v, 'lr': 0.0}) + + return parameters + +def resnet50(**kwargs): + """Constructs a ResNet-50 model. + """ + model = WideResNet(WideBottleneck, [3, 4, 6, 3], **kwargs) + return model diff --git a/autovideo/utils/training_utils.py b/autovideo/utils/training_utils.py new file mode 100644 index 0000000..a4c7183 --- /dev/null +++ b/autovideo/utils/training_utils.py @@ -0,0 +1,106 @@ +import numpy as np +import torch +import torchvision + +from .dataset import VideoDataSet +from .transforms import * + +from .logging_utils import logger + +def compute_accuracy(loader, model, device): + """Compute accuracy""" + correct = 0 + total = 0 + with torch.no_grad(): + for data in loader: + inputs, labels = data + inputs, labels = inputs.to(device), labels.to(device) + outputs = model(inputs) + _, predicted = torch.max(outputs.data, 1) + total += labels.size(0) + correct += (predicted == labels).sum().item() + acc = correct / total + return acc + +def compute_accuracy_with_preds(preds, labels): + """Compute accuracy with predictions and labels""" + correct = 0 + for i in range(len(preds)): + if preds[i] == labels[i]: + correct += 1 + return float(correct) / len(preds) + +def make_predictions(loader, model, device): + preds = [] + confidences = [] + with torch.no_grad(): + for i, (inputs) in enumerate(loader): + inputs = inputs.to(device) + outputs = model(inputs) + softmax = torch.nn.Softmax(dim =1) + outputs = softmax(outputs) + _, predicted = torch.max(outputs.data, 1) + preds.append(predicted) + confidences.append(outputs) + + preds = torch.cat(preds).cpu().detach().numpy() + confidences = torch.cat(confidences).cpu().detach().numpy() + logger.info("Confidence Scores: {}".format(confidences)) + return preds + +def get_video_loader(video_list, modality, num_segments, batch_size, num_workers, crop_size=None, scale_size=None, input_mean=None, input_std=None, shuffle=False, test_mode=False, train_augmentation=False, input_format="NCHW"): + #TODO: Modify Stack in transforms according to the architectures used. For now default value is False + if modality != 'RGBDiff': + normalize = GroupNormalize(input_mean, input_std) + else: + normalize = IdentityTransform() + if modality == 'RGB': + data_length = 1 + elif modality in ['Flow', 'RGBDiff']: + data_length = 5 + + + if train_augmentation == False: #shuffle false for validation and test set + augmentation = torchvision.transforms.Compose([ + GroupScale(int(scale_size)), + GroupCenterCrop(crop_size),]) + else: + if modality == 'RGB': + augmentation = torchvision.transforms.Compose([GroupMultiScaleCrop(crop_size, [1, .875, .75, .66]), + GroupRandomHorizontalFlip(is_flow=False)]) + elif modality == 'Flow': + augmentation = torchvision.transforms.Compose([GroupMultiScaleCrop(crop_size, [1, .875, .75]), + GroupRandomHorizontalFlip(is_flow=True)]) + elif modality == 'RGBDiff': + augmentation = torchvision.transforms.Compose([GroupMultiScaleCrop(crop_size, [1, .875, .75]), + GroupRandomHorizontalFlip(is_flow=False)]) + + data_loader = torch.utils.data.DataLoader( + VideoDataSet("", + video_list, + num_segments=num_segments, #Number of frames per video.(if >#actual frames, repeats first frame throughout) + new_length=data_length, + modality=modality, + test_mode=test_mode, + input_format=input_format, + image_tmpl="img_{:05d}.jpg",# if self.hyperparams['modality'] in ["RGB", "RGBDiff"] else args.flow_prefix+"{}_{:05d}.jpg" + transform=torchvision.transforms.Compose([ + augmentation, + Stack(roll=False), + ToTorchFormatTensor(), + normalize, + ])), + batch_size=batch_size, + shuffle=shuffle, + num_workers=num_workers, + pin_memory=True) + return data_loader + +def adjust_learning_rate(learning_rate, weight_decay, optimizer, epoch, lr_steps): + """Sets the learning rate to the initial LR decayed by 10 every 20 or 30 epochs""" + decay = 0.1 ** (sum(epoch >= np.array(lr_steps))) + lr = learning_rate * decay + for param_group in optimizer.param_groups: + param_group['lr'] = lr * param_group['lr_mult'] + param_group['weight_decay'] = weight_decay * param_group['decay_mult'] + diff --git a/autovideo/utils/transforms.py b/autovideo/utils/transforms.py new file mode 100644 index 0000000..3d9bdf9 --- /dev/null +++ b/autovideo/utils/transforms.py @@ -0,0 +1,368 @@ +import torchvision +import random +from PIL import Image, ImageOps +import numpy as np +import numbers +import math +import torch + + +class GroupRandomCrop(object): + def __init__(self, size): + if isinstance(size, numbers.Number): + self.size = (int(size), int(size)) + else: + self.size = size + + def __call__(self, img_group): + + w, h = img_group[0].size + th, tw = self.size + + out_images = list() + + x1 = random.randint(0, w - tw) + y1 = random.randint(0, h - th) + + for img in img_group: + assert(img.size[0] == w and img.size[1] == h) + if w == tw and h == th: + out_images.append(img) + else: + out_images.append(img.crop((x1, y1, x1 + tw, y1 + th))) + + return out_images + + +class GroupCenterCrop(object): + def __init__(self, size): + self.worker = torchvision.transforms.CenterCrop(size) + + def __call__(self, img_group): + return [self.worker(img) for img in img_group] + + +class GroupRandomHorizontalFlip(object): + """Randomly horizontally flips the given PIL.Image with a probability of 0.5 + """ + def __init__(self, is_flow=False): + self.is_flow = is_flow + + def __call__(self, img_group, is_flow=False): + v = random.random() + if v < 0.5: + ret = [img.transpose(Image.FLIP_LEFT_RIGHT) for img in img_group] + if self.is_flow: + for i in range(0, len(ret), 2): + ret[i] = ImageOps.invert(ret[i]) # invert flow pixel values when flipping + return ret + else: + return img_group + + +class GroupNormalize(object): + def __init__(self, mean, std): + self.mean = mean + self.std = std + + def __call__(self, tensor): + rep_mean = self.mean * (tensor.size()[0]//len(self.mean)) + rep_std = self.std * (tensor.size()[0]//len(self.std)) + + # TODO: make efficient + for t, m, s in zip(tensor, rep_mean, rep_std): + t.sub_(m).div_(s) + + return tensor + + +class GroupScale(object): + """ Rescales the input PIL.Image to the given 'size'. + 'size' will be the size of the smaller edge. + For example, if height > width, then image will be + rescaled to (size * height / width, size) + size: size of the smaller edge + interpolation: Default: PIL.Image.BILINEAR + """ + + def __init__(self, size, interpolation=Image.BILINEAR): + self.worker = torchvision.transforms.Scale(size, interpolation) + + def __call__(self, img_group): + return [self.worker(img) for img in img_group] + + +class GroupOverSample(object): + def __init__(self, crop_size, scale_size=None): + self.crop_size = crop_size if not isinstance(crop_size, int) else (crop_size, crop_size) + + if scale_size is not None: + self.scale_worker = GroupScale(scale_size) + else: + self.scale_worker = None + + def __call__(self, img_group): + + if self.scale_worker is not None: + img_group = self.scale_worker(img_group) + + image_w, image_h = img_group[0].size + crop_w, crop_h = self.crop_size + + offsets = GroupMultiScaleCrop.fill_fix_offset(False, image_w, image_h, crop_w, crop_h) + oversample_group = list() + for o_w, o_h in offsets: + normal_group = list() + flip_group = list() + for i, img in enumerate(img_group): + crop = img.crop((o_w, o_h, o_w + crop_w, o_h + crop_h)) + normal_group.append(crop) + flip_crop = crop.copy().transpose(Image.FLIP_LEFT_RIGHT) + + if img.mode == 'L' and i % 2 == 0: + flip_group.append(ImageOps.invert(flip_crop)) + else: + flip_group.append(flip_crop) + + oversample_group.extend(normal_group) + oversample_group.extend(flip_group) + return oversample_group + + + +class GroupFullResSample(object): + def __init__(self, crop_size, scale_size=None, flip=True): + self.crop_size = crop_size if not isinstance(crop_size, int) else (crop_size, crop_size) + + if scale_size is not None: + self.scale_worker = GroupScale(scale_size) + else: + self.scale_worker = None + self.flip = flip + + def __call__(self, img_group): + + if self.scale_worker is not None: + img_group = self.scale_worker(img_group) + + image_w, image_h = img_group[0].size + crop_w, crop_h = self.crop_size + + w_step = (image_w - crop_w) // 4 + h_step = (image_h - crop_h) // 4 + + offsets = list() + offsets.append((0 * w_step, 2 * h_step)) # left + offsets.append((4 * w_step, 2 * h_step)) # right + offsets.append((2 * w_step, 2 * h_step)) # center + + oversample_group = list() + for o_w, o_h in offsets: + normal_group = list() + flip_group = list() + for i, img in enumerate(img_group): + crop = img.crop((o_w, o_h, o_w + crop_w, o_h + crop_h)) + normal_group.append(crop) + if self.flip: + flip_crop = crop.copy().transpose(Image.FLIP_LEFT_RIGHT) + + if img.mode == 'L' and i % 2 == 0: + flip_group.append(ImageOps.invert(flip_crop)) + else: + flip_group.append(flip_crop) + + oversample_group.extend(normal_group) + oversample_group.extend(flip_group) + return oversample_group + +class GroupMultiScaleCrop(object): + + def __init__(self, input_size, scales=None, max_distort=1, fix_crop=True, more_fix_crop=True): + self.scales = scales if scales is not None else [1, .875, .75, .66] + self.max_distort = max_distort + self.fix_crop = fix_crop + self.more_fix_crop = more_fix_crop + self.input_size = input_size if not isinstance(input_size, int) else [input_size, input_size] + self.interpolation = Image.BILINEAR + + def __call__(self, img_group): + + im_size = img_group[0].size + + crop_w, crop_h, offset_w, offset_h = self._sample_crop_size(im_size) + crop_img_group = [img.crop((offset_w, offset_h, offset_w + crop_w, offset_h + crop_h)) for img in img_group] + ret_img_group = [img.resize((self.input_size[0], self.input_size[1]), self.interpolation) + for img in crop_img_group] + return ret_img_group + + def _sample_crop_size(self, im_size): + image_w, image_h = im_size[0], im_size[1] + + # find a crop size + base_size = min(image_w, image_h) + crop_sizes = [int(base_size * x) for x in self.scales] + crop_h = [self.input_size[1] if abs(x - self.input_size[1]) < 3 else x for x in crop_sizes] + crop_w = [self.input_size[0] if abs(x - self.input_size[0]) < 3 else x for x in crop_sizes] + + pairs = [] + for i, h in enumerate(crop_h): + for j, w in enumerate(crop_w): + if abs(i - j) <= self.max_distort: + pairs.append((w, h)) + + crop_pair = random.choice(pairs) + if not self.fix_crop: + w_offset = random.randint(0, image_w - crop_pair[0]) + h_offset = random.randint(0, image_h - crop_pair[1]) + else: + w_offset, h_offset = self._sample_fix_offset(image_w, image_h, crop_pair[0], crop_pair[1]) + + return crop_pair[0], crop_pair[1], w_offset, h_offset + + def _sample_fix_offset(self, image_w, image_h, crop_w, crop_h): + offsets = self.fill_fix_offset(self.more_fix_crop, image_w, image_h, crop_w, crop_h) + return random.choice(offsets) + + @staticmethod + def fill_fix_offset(more_fix_crop, image_w, image_h, crop_w, crop_h): + w_step = (image_w - crop_w) // 4 + h_step = (image_h - crop_h) // 4 + + ret = list() + ret.append((0, 0)) # upper left + ret.append((4 * w_step, 0)) # upper right + ret.append((0, 4 * h_step)) # lower left + ret.append((4 * w_step, 4 * h_step)) # lower right + ret.append((2 * w_step, 2 * h_step)) # center + + if more_fix_crop: + ret.append((0, 2 * h_step)) # center left + ret.append((4 * w_step, 2 * h_step)) # center right + ret.append((2 * w_step, 4 * h_step)) # lower center + ret.append((2 * w_step, 0 * h_step)) # upper center + + ret.append((1 * w_step, 1 * h_step)) # upper left quarter + ret.append((3 * w_step, 1 * h_step)) # upper right quarter + ret.append((1 * w_step, 3 * h_step)) # lower left quarter + ret.append((3 * w_step, 3 * h_step)) # lower righ quarter + + return ret + + +class GroupRandomSizedCrop(object): + """Random crop the given PIL.Image to a random size of (0.08 to 1.0) of the original size + and and a random aspect ratio of 3/4 to 4/3 of the original aspect ratio + This is popularly used to train the Inception networks + size: size of the smaller edge + interpolation: Default: PIL.Image.BILINEAR + """ + def __init__(self, size, interpolation=Image.BILINEAR): + self.size = size + self.interpolation = interpolation + + def __call__(self, img_group): + for attempt in range(10): + area = img_group[0].size[0] * img_group[0].size[1] + target_area = random.uniform(0.08, 1.0) * area + aspect_ratio = random.uniform(3. / 4, 4. / 3) + + w = int(round(math.sqrt(target_area * aspect_ratio))) + h = int(round(math.sqrt(target_area / aspect_ratio))) + + if random.random() < 0.5: + w, h = h, w + + if w <= img_group[0].size[0] and h <= img_group[0].size[1]: + x1 = random.randint(0, img_group[0].size[0] - w) + y1 = random.randint(0, img_group[0].size[1] - h) + found = True + break + else: + found = False + x1 = 0 + y1 = 0 + + if found: + out_group = list() + for img in img_group: + img = img.crop((x1, y1, x1 + w, y1 + h)) + assert(img.size == (w, h)) + out_group.append(img.resize((self.size, self.size), self.interpolation)) + return out_group + else: + # Fallback + scale = GroupScale(self.size, interpolation=self.interpolation) + crop = GroupRandomCrop(self.size) + return crop(scale(img_group)) + + +class Stack(object): + + def __init__(self, roll=False): + self.roll = roll + + def __call__(self, img_group): + if img_group[0].mode == 'L': + return np.concatenate([np.expand_dims(x, 2) for x in img_group], axis=2) + elif img_group[0].mode == 'RGB': + if self.roll: + return np.concatenate([np.array(x)[:, :, ::-1] for x in img_group], axis=2) + else: + return np.concatenate(img_group, axis=2) + + +class ToTorchFormatTensor(object): + """ Converts a PIL.Image (RGB) or numpy.ndarray (H x W x C) in the range [0, 255] + to a torch.FloatTensor of shape (C x H x W) in the range [0.0, 1.0] """ + def __init__(self, div=True): + self.div = div + + def __call__(self, pic): + if isinstance(pic, np.ndarray): + # handle numpy array + img = torch.from_numpy(pic).permute(2, 0, 1).contiguous() + else: + # handle PIL Image + img = torch.ByteTensor(torch.ByteStorage.from_buffer(pic.tobytes())) + img = img.view(pic.size[1], pic.size[0], len(pic.mode)) + # put it from HWC to CHW format + # yikes, this transpose takes 80% of the loading time/CPU + img = img.transpose(0, 1).transpose(0, 2).contiguous() + return img.float().div(255) if self.div else img.float() + + +class IdentityTransform(object): + + def __call__(self, data): + return data + + +if __name__ == "__main__": + trans = torchvision.transforms.Compose([ + GroupScale(256), + GroupRandomCrop(224), + Stack(), + ToTorchFormatTensor(), + GroupNormalize( + mean=[.485, .456, .406], + std=[.229, .224, .225] + )] + ) + + im = Image.open('../tensorflow-model-zoo.torch/lena_299.png') + + color_group = [im] * 3 + rst = trans(color_group) + + gray_group = [im.convert('L')] * 9 + gray_rst = trans(gray_group) + + trans2 = torchvision.transforms.Compose([ + GroupRandomSizedCrop(256), + Stack(), + ToTorchFormatTensor(), + GroupNormalize( + mean=[.485, .456, .406], + std=[.229, .224, .225]) + ]) + print(trans2(color_group)) diff --git a/datasets/put_datasets_here b/datasets/put_datasets_here new file mode 100644 index 0000000..e69de29 diff --git a/docs/autovideo_logo.png b/docs/autovideo_logo.png new file mode 100644 index 0000000000000000000000000000000000000000..5541596ceaaeb3ac2a32913a729524eb48f71aec GIT binary patch literal 28454 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 literal 0 HcmV?d00001 diff --git a/docs/benchmark.md b/docs/benchmark.md new file mode 100644 index 0000000..edaea86 --- /dev/null +++ b/docs/benchmark.md @@ -0,0 +1,23 @@ +# Benchmarks + +## Hyperparameters to obtain the results +| Hyperparameters | TSN | TSM | ECO | I3D | R3D | R2P1D | +| :---------------: | :-----: | :-----: | :---------------------: | :---: | :----: | :-----------: | +| Number of Segments| 16 | 16 | 8 | 16 | 32 | 32 | +| Epochs | 50 | 50 | 100 | 50 | 80 | 80 | +| Weight Decay | 5e-4 | 5e-4 | 5e-4 | 5e-4 | 5e-4 | 5e-4 | +| Learning Rate | 0.001 | 0.0001 | 0.0001 | 0.01 | 0.001 | 0.001 | +| Batch Size | 4 | 4 | 8 | 20 | 16 | 16 | +| Momentum | 0.9 | 0.9 | (Adam) | 0.9 | 0.9 | 0.9 | +| Modality | RGB | RGB | RGB | RGB | RGB | RGB | +| Dropout | 0.8 | 0.5 | 0.8 | 0.5 | 0.5 | 0.5 | +| Backbone |ResNet-50|ResNet-50| BN-Inception, ResNet-18 | Inception |ResNet-50|ResNet-34| + +## Results +| Datasets | TSN | TSM | ECO | I3D | R3D | R2P1D | +| :--------: | :-----: | :----: | :-------: | :---: | :----: | :-----: | +| HMDB51-1 | 48.6% | 58.17% | 44.4% | 48.43%| 54.77% | 60.26% | +| HMDB51-2 | 50.3% | 55% | 44.8% | 47.97%| 52.02% | 59.01% | +| HMDB51-3 | 48.76% | 57.65% | 41.5% | 45.56%| 52.3% | 59.9% | +| UCF | 81.97% | 88.47% | | 75.51%| 83.74% | 86.92% | + diff --git a/docs/demo.gif b/docs/demo.gif new file mode 100644 index 0000000000000000000000000000000000000000..864a6ac61dce485a0a3fd1b73aa7658bcad22c1b GIT binary patch literal 2036789 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¥+N*sSGj8KIj^ojN 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¬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 ITy4(y`+|*63rjC-QJ=tY_4b}y40 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

VlCOmWI{{%y9)j2e~QX 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μUzJS2K-ForQ zH~I=@sC6c~dIX08jtW&gMh})Mah{7N73&lYhnC#Xp%-!~ZF`Q3{*r~9Qdj#jPmGLY zh~~F)Nb{X3jij++n?K87#2Q~@ zfRoHkAJkwYo2aZ5s=uIWt)5)5oPzm3Y~6)VTv6LD{23T*aCdiim*U0UrKPyLyW8OI z#ob+7thg7qQrx{rfzHSCyl+mvoSgL+?49iFtX%h6*U#o#pc!uSp7Z|s4EWss#J&;6 zp(xhj*M-^pzvIq&%IHRYM=lsBcdSZNx6nPs*H6(Z=AbWPZ=sP87OWVhQFn9*l`)eh z&h)iW9yeY|LBuKrsR-b!;)o*(445SS(5bD0i2V*I-@omvqitrPtN)=s&qU#E%6WYD z4V-N)gUWOtB8kiB%6E0^C=q+UJgjdVQH5bep{p=QL>&B46{$W-;_`=RnYpA?u-eIi zX+2A6!{7DKQZsU#-`HPO9FDtJf7qT`4U+1`(qg@SJ@vhU_B)<&44q@i1XS0>@fBP; zn%(@Xce=HnUWmL|*IX==eYb7z*p837f-^9f8@n7MEJFX(OJi3h;EjclG-^Nc(LLE7 zrLs8;Wi&iX)}b^wwQR+W86TF8G+;>VcNo~4xma{$M4LrO=%IyR5(D+6X;{(x2GCO{cE@vR!nPWD?|&BiA0^uEJ3B*W+_N9 ztq~~U=clM3Fbp{;%;3z6p!)7Q>1VJb~~3SB!_vgg{5Z< zgaKrKbfdd(Zl4}jY8)_~yHTdNA7;FlokkQ_i%jM!b5iqr}ruw5~44ytMKW#Nh2mn z(u`TxBn_#iE!a?!R!wBXh-w=x{#Geu4sG4GFUGt&AMSMApdK{de~wk$sOWFdy)mFU zDssrdgE0eSdUE>1m3;q}42SH5?tT^&WIX(cc--;;9eOZb@qWH*{k*|#f=mqS4Df1w zh%_JkLfuYMOEOt?X(sg`iOy|d^+QX_*7CEBj1wRFN&}Tw9Y)XqmIw%SXO%j2hvV7l z*VeQjsR9$?kRklC{T_W;n>#+O+V_H#sdW$M2cu8hwO<2&RsQjyMDHMsW+Z)o$XAKa2c|f?`yu3 zbeQk^)V=dV3kAjCYa~OpVXkh*Q?(Sm`zNq$FSMIS7J!v?O}_k>Zo50+N-$~j*yeeJ zPCV(;(<2^wS0lRc0?;RfxMvW(1IHv*xXn@RD!ziL&5c~v6v7BUEIvkZk#6rid}>9RZ!*1uto z`4RUu5zhM)R?jV)NHeTpD02uxt=#aLwAxMot+%usM`Y>M0A`O7%Jh<61^Y>k!0D*$y-bZb-uBX2ZoL@+x#B?ozqtDogznn&SX>Z&vQ=JQ1f zoxPF#b%EZWoI<#GCFFCe1XiQLQUzMW093d*dE^H+50*6`dlMBAB|*c~$2_xd&8w5$ z-*3I7eb$oB94X-)a&}bP3-cKWqx%@``fT?OUgMw~oxABh0008h0ebE3C$|I0WSWC0z7fb)Ggf=s<9;1%TOGFR(Ri$fQ`XI&dQEv9 zx);-nL!tpbgBGaAoi4Ip1%+)Fq1r4T&B)WseEHN2+O)P<2zQHsq3~|#{dt9<28R7W(DDu%qD{|B=lIl?ym&RX0EA2+U@>?+#QY^0$vZV&j!}^CE4jZp6jce zOEvmeu5U!1Z2B!WHCz@G&`b` zsIe|+HN>C%_Qo^GRf9v6sC7W`gW1F@GhT;*@G=vBnAOXa@*h6(rZd$vPJq9^ zc7q`-EiC#Nb#1GzHLz*NLM*-TlKqNsNE)}ujVFLTAX^3&;5P`F2!iqh2Uy6`g2(HJ z*-9W2HquI@u2|PbVwPG5ZD03(!R(~qB*aSDjg!6ypnC0Vy2knI$Nkk=Y{l zFo|)&AYOFSz$m3s2&e+?rg{-Xu|E;OAPH|mPQO2SSF2XO^morPn?9X|&q7~~6vgXW znHrhjFqG5=gi%~EFomZ$1|zTbiGpOdS%B&E!#o01%cgWeiWV08Kz0EV^VtoQA>xQ#YF;Yum625>eh;b0lGDz(9m8 zC!k@9ds2}bL>R|Gjit@Uh>R=Pvd*O1u%Jx0CHiu|Kik5Bq@^Y~u#2q@j|-Ra&M<5x zEhx|fB;YW<)m%g2RVw@)QOKwewHIM1WYbMEw2a%dXJ_&_mx-;)(w7aLhy`_xA^Y0$ zpAq!457NTo&65vFz(|TQDcbGSiSG4OaZHhoMQ~1CAgcA^3e?|U96E3TAz-0vyv@on zF8&(Z)jlEBPmP|BTi(FuZll`P=18?>^x;gS7QD8wdG7M3A~;0A$g&28coGGh`e#6# zUL>o^V%myf@2hxFbIK#uBM4+_9m5bgOPq^y_Ef9YsdW6r){JfvuHdM&Lj@OHpIcNm zzDoE&zkIqQ*>5LIqHs#D#!;%w>@yXu@GFG*^*GG`Z72jj;6(G+-_;edM^eT>mZ30= z6aHZpP8N%;YBlnWZs(vJOM&8i6svaYbZS(bYtjk^YfAl<}?%C?CaK zqgtUmU(f>x^2Yx#MN9J(yLCPenljF7N)2z$mFl$?rthRxrXiIl@%2Ts?f`L<25_^u z>#I9=ng760!?DVZa1Bm+eJ&xrNpXd|z7EDyfpXUmJK+N_YG~Nz#F3c~fhx4>N!!fk zKhS)#r32lPYosa@>7)rgkLScUQx}IBGQ}UV1nQi@ z6HGw1zzmd#=JSS9X%npP^)Kv>@tJ)%$nYV8gKR1BSsytMbrWt!q_+l84X;Cq@!*u@ zEP``z&VnC6)KQV5_PLwqbOJW90xlUp^Nyq|9He#R6}x|0T$^u9n&ORR&!bqCNf|?1 z)S~hOV62j8&zVDb}#jaJA~7SWkPAhiDZwjQgYDy={#ubJvR5nexYi{qaC|a5{~(eAw_Uf z%*85uI{V{${G}1d=#j0QuPqPJt}oDmH6S@HHj;oep;gzaR_*9>>KTfUafaV8DsXx% z%$qPZpxYxcetMKy5bC{v^QYaf`qwRbiR9TBnOF4%9kQBt%444J=S1~Amu*`GHcYH< zT70b(yh~V7DuJuZ+$?Tk_^YXWqm2!J+yktb4;D>;IiWUqF?f@^XFLxD8#q9bHH7xt z)!`mxr+$M!T=fsq0 ztKa=?6RcS&fQ8Ua`yjENuXI(wBGkU!9@(t<_;M4?zok8LhB*uA-|j=W<0~Y!ohLM2 z?!#n6ZIc$}7tuKiKl>D(YU3X+HOeN}e(?Whuwf9@wcJMYUJc8C_jiRcBOx!s14&BD zijr6Hbgq*J#AkswIv$*W`r6#s-J@L9zo$=e9k0(=|g;Xfu7}K9#nL zE&kB4gtV=UV~y&RhUUwUQo5lz#bO|MD!1zo8j@UIA%5wZpY!YGqq0=XVg9!HP6m%a z9=0P1ZWu7=?_#Zns+SN^CaHmquHR@p-7hSGI=Bz3DRL*luIYwQ);J@xXK8v;H;e@d z)cy9@X~BHA{2-iCF$5vfX^M}$$ammgSoNXylt;ub5m#|*#A?yPV9J;vPj zh-g?|XDN7Em9cyFGsTM~wem|i5O&?LQaa=EXG|!pZWJcJ@JoNVra_&D5XY(5HTNP5NEh~Awh^T4eBVloc{q2k(+GEh08goc9uKF_ z2iZ*nYos}>xz4REmtGXd*T~L{1kRv7DRv|zeMnJ5Vvj}|pGJyd2A5$RIjUsWCq0LA zfXBp<-QW|uIh?;;BPqZjvdto)454Vkp^Ao`E~|aC9zq>beN~t}JHJNz)sJtMB#3ue zAoo!}u78)$v09COuhil}%e`vAPf*JYmm2RGGH;y=a-T^Fqwktct8f&{jWg_)jMNR!2Jd@|#jJ_e#4S8; zDtwdlgGZ9uat?k7>jEYjq;V#qJuV96O)w}$ZObbcMc_ojalm$#=R0uybk3c1+{}ic zM)T;}UqB@uq)CFj7!=28fVGIs4zeNQLDVvVVQ7Swl-tQyegg<_UkeiUypsv`vWo(nJLT#T;?6j;pLvZ_^K-b$zj8?CEV(d$NWK_0UvQvgyXvlG4`d!otvJuQIy&u__+yd@V95#TzsS`-!Iw?-)4} zMNCD)@~W-<_RrNTj{p$Ye#}J;=qZPgL5IwTgTI6je0YKLfCD??Tb^!Ev&7)CZ|cGc z$Dd&~kk-`$kqKy&8O^Z&l}7#RCyFz#Zj^`aO)B5p@J|$$`PbWj zu3EYQ8U1YPq;=~0U%~0nI7i?uYdOsoZvI30l)Ou^j%`JTZ5y_cnRAS7lJ^P(X1l0UAn{otM&XW?q)B%|3zmE14Go9V`xVllhGGVg|XY%O=L z?P1Zpuu$%I;OS`0|I=jUlU1h4bNg=GgS88PIT{7fAc}p;*{kkeA&B3w3*zmE$uz*D z6qSrKyJ!xPh0UxVG2*5Evc%G`Vr=+O)1Ile(XRU4OH5eZ-|&(BXQ983ne?#_6OGzw{vFRvm;2j#i<@Z2 zdYZTUm4_z~!=D(1-%SUxrqigN0Ftfegq#6+iPK>h-|i>S9`2084o;h1)u{4_w>#!$ zXpi4|iofH>=Zv8UFL8b9ND$6ol3H$-ZMPeBYkjJX9^iB1<%f@5v)@ZYaM%gK?<&ri zMf$4enaG<0MdHJWnN7LEP3_PN7ZhwOMo43xi;(YPQ+iHQ&yKHIO#htC)#i9+u1{f| z{hHvVe@!p)nZ?Z(1z`itVkuR*q{9~#e5q!WJ*1oSl`yBxJ12|}?EWxbPnf&mxw+t# z8uBbHoZ_eg=e(n=EMu8MW~jJ?s7V*xGd!RU2%;jtxi zZJXJgj%uNmaQv)_2L85H^GX2drgSyAhrbBdsR*vINbxp>k_efXP`hibST&1Q{J%c$ z2ZPd&Ii)3crRu&eNX=&n_>@C4N`3?tZBi(`;WCM9#ePB|N&2#wFlv!GmH7f6OP--w zP9LDOJ}JaaDT=p6`Q37U6xC(E)dK=G?>=vnZ%tQsDf(m0lAtb(YuR3{cYKE}DeWVS zH(?3u#o~JKICc#2YIGUrr;{9ta|6I5ZbPQk(_bRBH{bS5q0lqz;x{gR^d1px!$czD z&M-qmbMHtyy|Sa#4AK>R?$9Xug{~Fm;IXsj#n#j?{rU>bPZ9cs2kD;yAX3APwoFFH zM4~D?;YRf$K0hm#d(T|-9^JN4=qk#HT+m^Lq)qJks23{(yP&M*&>ThDeVeW89&o`)Y zPUMwv?FJ$DJI?FoJ;+zld@lGPm;3brNfi6F72_G`yE#fo0oj=uAZ#e}Q5hT({%o2n z&h9^+s=dfS7>ghrEA=!ayp|i(Gu*P-q$=WaC0wQ``+fB94<~&=ijKE-Gm+bD3{@nm zTxE+e!ukNA>?jhZ7@m1LquvNeLv|iY&gMApYFJrsHg3|yhu+)<|A3)%omoqIqUJTEGPn5%MH*E-u5#d z4(Xc;H%^CattM{WrIBW2Z><@3e}C)f0xI}Q5r3U`Tu0k#RlncpsixlZtv9>Q4zJ%l zxom?iJ>oE0hGKy?-?p%&Jr44>RktVDiGF!_ty1Rlyl$BS#dhF61s0I5JFQVZKKZ~R zeqGyygSXyoFdV>ttqUP33YFbdv_%z9J)x{!(oNd36kQbmv~Pp=S+QWwi}avIc=)@| z0fOSM*{(bqKf(zz+aUgW%Ys9@?L((e>t1w0-8y}r($`9r|ABpu!~Tszfq(ZSMs|rC zPYhR1jE!e)i2tsWPTc%Cbr3BMLbL8Cz194;{avhlaQgtVV5VVoDCM+Zre7=g^CGcE z_>Yy(37KDVV0C4@D1Pq-p@8fg86}3p$&lhT0{K?N%=L$Y*i88w`GOlDyEXZTThdPl zjO6Er|87SM&Ku6=Y5VTrTt#y7FC;$Pzn@2?LtEVHy5D5FUT4(gc@21|(QBYl7<>9+9+TE) z(%ZQOlgXOh_7~9@DLnRit5OdWdXc#DF?ARv*dg+28HoL>)WMdNY)eC?weK&` zmraSF(L0Pt*Y-WNk+FbNkUbzXyuGnrHF|iv&j@;f(;<96Nvc;E;-ywT6pHHj5Nw6@ zNzN+Y!#3Kg0M0|t@GI4B%NgVgG)?U28`$pf$#6QG_Am`Hn zqoQu@iw$te(rb#3aN++gKy>=Wz_|Htchf&evi{x>kp^|35u8&GHJ{KmpE91= zj}WE8v)a!qyr;^+rnzjF*mBmq z{Z(|YQBfW}aDzh_(HVTI!z|Bg=0jNt2+}i+ArBN-Kv>4cH*ESr;H2c)LhAR*`IRcs zsCj&|z<;45zIl_2jO}}GRiezL(y4~>+uNh&FVw9i?L*x7f;73my)FGfW{Z{qWoDKd z6KPh~ADOyN|30pK;%?Ucto3STA2yy~?0Je`5dQ!zpm=!)nrS-T_%>ZSD!H~iDqe1X zX4UiBC4c;^OB$DS_eNTCCwbCP{Zb$0rY%eP<~R+vp~gHowRWU)kdfL|=$8Fq>iN*n ztPlV5d;01NoUBHJ+SYdb``g+ysnWC2&dl@(VLmIs?y0Kr68cM;BoZNh{>u7EUSlCS zE4=zp@XF_maJKT)1MiH|!dKK5`Eea4vowI+l}m2$$yr;h4wWGw5J>#8fB)@ie2(W% zk$CJ9zw*_i)bqss^C79cUHhLQuS>&9iTU8 zu=JNwco50@S{Z}kFV9tUs8Kn1Uo{({-kk+~F%=jRfT7@d;S@5Ib4H|&NwcLS zODknfMW$u+Nw`1=K_oLgUE?a2Ex>SWT3BKMg^T$gY34cU>Ka`N9K{?Fhq+3K7HhJL zTMHRoixyG7UG1L_XA_5{v(eM#sV(_Z1>yaTG{TPrP`Dg3)@ky-RSWQ7lg!2xzwQc* zSMlh7g7>R6s`%Je&Z{?=%Iz4wC$b0Coee*44t$zAD!T8I3WRq{8WK7D03@30;l=hA zOH%RkFYQ0I;fU4TH~&Tko@WZt_>|pbF3{&bk2%8Siefu}kpthB*zU$f#i}TB;Ilv& z$YKz1tET8+7H1(1D(6UNR93hA`Fo7FLdf9|FF0J6y3?*wWtxzWG*Mn>zK{)`q8l=U(&Q}#D)F|N0Q^8JHyUpwz9 zUyXM#;~VnlYubAM6^+cl@R?Pp6HWn7kW45{Ru?U=O$fi|PV*t>z&8$cCHZ?3M8(w} z>~iObpcHM4YJpC~13Mhix!>q59bE_v{b3?&Y7fW!VuvyZ_BXko9|6y3Z5mTPXU0 zv8MlqA9``%++0{AvS>1)+3c4z6R>~UEcxuFrkzw8Ll4e%D1HhKdcwaytN}JmEIz}m ze5Hg`mxv^O_dG>lNjk2w1(TS82?Y0){|3TBGjGDsuD})4gFreNTbEJ1%u{*36)m%TLG(k=tTZ8kfBKEPN0 zz7D|za|A*xCpkO`<-$wqRCxhjp>;Ul@?= z?TDg{3McTxvi)9$B5YBNdl=s-!w~!K3jz_VS%~~00cYLuf=lw}$2p0&KVA-6{H=SP z3peDCg(A5ioLs18K9q&eNz=uZ$^Sll}+4nPc=~O9S8reR4srHnK$V<3;9b} zyNX^lPt$(9N{_xu@2|PDiM$newatS-`tFtdQSV=V9r6E6%Fv&el<}<>YZ__2U=4Cq z9tf9PzBOP-7a&Mb1nz4F63yvt->7IX9Ho|B1?bxdPg=GgOOfxm?IK6=$-ZqWI_O02 ziC%pO6#eyb>E#N${h$_<#qCz=*wJeE*!v4@@BGhpPE;YIh#D2TGlma800v9kr>4oZ zAKp!s3y6FSb;H+F3DJm~ORj|dFH_a+(@CXHhD zTQ<0Rgk^UXQ66z(5+|dP4KoJ@^CJdBy~3C%g7-uGak&8BNBorsgCE-cvk>s?bn&|p zXs6Rdh!~9LDI#`{LK=0cMEMMA+ud7r{Zza{({=;JzDR!$BOST3vRV~*T2aRGfL)pg zsa}I5i^I6A$tcyrnY}0_7{WU|oF=S%C}s69v;1aOM3^d~R2igJ=rA?qBDAd|h(jW% ztTh!nu*4T5LZjFi2qJ;z@R3$(n<0@!$GSs0q|S&@?|q+1Rv{{@EPltb0SuH)ol(?y zArcbMXoCLOXaT9ken{UjO!zR>xLnM@Z`&%1(CpPfKfVx6UArD# z?uW8~yFnaD)7T1YQa41H-_}uioQ`z_fFlCR4_3jxdJ^*1K^@*9PNfhRP~0DexcK8} z-%(7_WwVgdxH4_4f!}en40b2*BK_2ET2|aG9`a?;aOKglBacBfm6mWjwkV?s7oCQA zQ6YB>A0H4?9tGlt8C=*c;@U8jpbRnNdgioaf%Aw#CwxI{V>oG+9@byr@@|uayQHzI z!hUDDp4?F3A+g;?Clkh4cO55_6Q(H3yVK~W9F8V3R;9eBQLxV`VF>c_I9i1Z{JQDT z)N?9$`O;L(=Ty=p+)aAQ$HM^M<6v3uXhj>vLAgvS!IWXWxRK*T?QDk0)fBc9mxEim z5Jv8Xh%d&{q+bXTAmeQLp`guZI4Q0u>ni6)2FR9IS{7sGjb^5bPo}p|9Gy>!Ukn!W zNoEjIR;Xas{tw~E$8=jtc>6|#aB)Oa!3=zOP#zb2k6{5C!F6F0$a<5ip zxjG}FpBA1^rGEn!mI@Zq85FYE6e7eHhR3k+ zB_m9Lic$eZu1N?zU8w@6@z9Fc&Q5FRXS*{SA3_@^a@*2s>|&}M9nJAlnso;)#==aK zbjIr91;PC4XL!CFI6jx+U@h>>bD?QfNfT1R*WKLe1y=&ww4kS8Z|_p498NNCF9jkL zk9FT9fpqN52;gNopZ-ghAz}zxg|Y<;gLy$}Z(L;8Nm=a&vlGM{q@^ z0llkGg?o3YvTcMaxXgdOBG9&sWxY6nqSBY53=Bkx63RV?sWG#K3mt+cCxfeOeSOe7 z+2NwA`V1&X0ktwK)k6xkc|^6Z)|G8ZwKe^<)2Fpl;Bts_@jslpWRtoTrjjz-e8D4^ z7;*4uAx1+Havnx`Q*4RyT;({dt&>m9g+kT(aLqTShU(uT!v?h@IkjWewUd8qXASCp zGJRQPYFw+Xg9&GYU#aWDKqZ4k`P_|gXj`t=QPVk5-<@NaYhHC%{m$%Gke)TEJvULF znNfD8Fk#l2D3o=>daI5$SDqF}SRszgVW2W29QkI%cX(Xn)LiAHp{A1&_B2T#1E>^R zW$aq1&m2I$%}}PKv!hnl$>y5z9NAKYn#M-tCNM8?)8U$35)m|DzQaze#`Rgg-NLTj z3es-#Qt)xIJ^!>xPO+KFTP~%sRcSIs@5DV6fj1N^ZxG8CZql~vi@3|^)O%QOV&~e= zZ<52<>a^aTh}IP=+8h zT$Z#qAonye_t^N=w%PSO8&r1mH1tgN^uCmRKPwBSsT(rv(Ef{+m8%4*kz;kMR$IZ- z2g~`X!OhD$T^xAp(aFdRbrT5pY@PM}dg<$6{?@7Z?eBWe5pwSUq;lAZrr|;_7n}n7gLcYCJe+#AQT~X-OJz;Qt zuMnkY)R?UE_YBCqv-w!&`Hz_i2X1g}qZ>w~|6S(otLbO#?Vli0LVfLD5UQ?>up+c_ z{2ehM*fFqnB0hMaCe1x4!7>b}O`{WOXbBr8$LvygtzuZnWKr+Ed}&pibP=i;fYX)E z9yCDd#>0^dfj(Gt;SH+t4O1u$$H2GB##PD34LbA=JBcu;qWrjkXU2_Zyq3B3kGoy> z6p+;AvrISx5YTKVD&i)p{3o^<%SBEmwh$+qUZJ2LN2yqhVY|_jT}EWxQ7ISbjs{}D*Sb7US#mS;B?8K>B)5ZdG!0n`2amagN9|FmiyGH z4dCEEJ)kouwKHc^|MhuMW^Y(#@04aw^8oKY?{n=exPSKTd=`o__rfywKR7QiehvwB zj?(gfeO@%yDJ=1Mu*3Yj&r4YMzdkRqD9XFfOXYz4e|%o%=>^t{|DVr``jgV(e|+Ab zq8C5e^4o6!Y#AnmyXU(a z6~7u&x4HuZ8xj0fDG9E9XVC_-5`ju>kp!C%@D9eV!hxcL~o!NIk|t^wVKokLrr03O6|-YfsA*Fgl5 zZD7x=v|rfD$8VDKuSymI8jOGK3<9eh0RC#|wazd~&M>#EJCXoclIwNKKp4SmDvl&r z9<<*->V8qy|GswEgGtycF5HVSL2vH|GKe{{q5YcPv9-Y1!|Mm%IK#ju!3lBzIFe8$ zO@LT|Fam+-SO7M0vAu@?^gV|i9LGaP*1f%Qz;_4aX%0ZG33`j@dv(!%{Rl8(4lVnQ zitXD*y9v6I*d99-XefBiD}Prpa8~eoeTemV2ms4L1@xaoK`Puu7TYIrJ`hgWR_)sh zMFZ%wp=B1Jy08J=zwHT&0V+_bNz~x)3U_y?pdgl+RV$S`hx!lxIHN5DqF3ji!Jxq^u>mJk z<{Q49?j0T@Iisb`o#0(leG)soKs&1C*twZr%@+e)k{!3zUwvT(SD~>*0M13ouGvii z&jn|JWJech*R>SjBaUlvv;%}s7iA9H`!oB?1*jY;s2$%f(0{ECQ5?e8U;Gih{b!8M zK><#iyTD39g;hQL?SNj)ab=NoG}?DQE_(J-fA?wnfPLWKND4cNYL zhB+qPK~O#HO1Q;HSkjx>yA!`MbKHfBK~eI_wlDRs1wSm-_TTorQMClz3tV0zt6WE- z{r(q-?%$7)Uwp{Sts? zG`&1T(NjzD`>}BUW(}=j_NDL2HluHq%yFsX>g7jbd%x4`c*ARp-?K^l>m>TyJp0?v zhW2UIx0S@VwT3sNi(j9WmzT+VcD}#up|28NE#=H!#u?AI8n-uJ7K8*HU+6zS=)ZTI z6aA6Dxmmk-@PPqPo^FeW!XezM1E412Xom2lV!iaBUFld1Y=D}05^hv1si-6gM)Oqv z`=q=;#75#bk`65GbyX%cf{E28gd4pC8WzJTiNGD@LZSu0+1iI| zKsgqR3*4tWwyjfde1S`KoK`I*hJ!%x<1eT6LaPJvA%G%$VLb$Pv%HO$0!SMrc%Ba2 zNG?%}c?5~^$YVr`8d_wDmuXpUuQbD|_Rsl9O5kOq1w63$Up1@b7n7hDc()hsd($G_ zwxURVDdJK}MGKo0bT66&&072}yf4&kxM7hK=+M?WNEtx*wD0Ulc7-j3%fMjsa@hxr zX&J=9%|wc;#8fA?tmWZYhW5%O6A5@zbqY+-MmTjCHF8SOrOD$>P(nro#!!R_F3&2P zhfu&sk=Q7~S7a45JHaW%r!n-Dp;RsX8Ckm%4eZb0TO>A})2;*xxS249R#enVWzIMi zjCY6Hn%ae|Jk9im4E+niWQlL{$t5M6D+5ja7ZvZ*ylXVAWY$-ncfuF3YY$LFvM#tl zh6cbmAb~wDmhUO0;-P@h?}aGBG?n|$z^umcP!!N0D5lD1?F^n*rKaSK$s#nkSNHm@ zXMg18+hZ~(@KaMV;i^FiRYOFOAgQE8I@7N#$e}Q$g&?{Sob|2)IK?8>#@dR4yTW&8(gIp`MG7IxF_ zeu}9ebRRZ}s#LM{c&455`PA&fUs?^!qvC&sCq-?8qy}jlfqc6ZE>+7-hexNV$TKUO&F7 zp{z9%weDx9PWdg|X3AIEV~j3pU)kEAg3T^vso`tx(fAnkSA^xZ(izjD=`O#On~?AT z$1CCVQzF?&%GfGBfZnbUsj@(D+rJ2NfEDuW7hj#m?*Iz>o|oupg2mpNMLEt4%qYF$ zr3@O>A&O>~LWful{IM-Ft&FCfuMC6WXjW?qzTT+d986q8^CFa?o%B7sa0_x3+FH53;=i%vha5j9`biX6Boar31`FyVn1UiM;_n|FUKOqJNl2^RluABrM- z8->`KQ=zF!mWR%bMCO2(YIxECh9Ze{`F4@Ie|3oMZ|0$GOGkLuFB4UKXN+pP- zcolS-Q(kMLNytOx6M5_v0^{~ScFSQ4wZrirA=3KQn?m;DxY8TKEm$lVaSZJvQd{C^ z$c@4k_3M!(dO?;P5rRslct5j7rRgL@vZubB+GbCMTk@0%D%aawou6NBq z-9y0zF84HPu>2$hs;k)hPWu}_PXJjzPvEI-mf6f!W0 zYX?d}1`}0yk@0BYxUxWBjJz0lej=V!iO?Y|yLfF*gM-tDelzu#jQ^$AP$3Wbx{uBgWtN z6Y~j}!F-qpmX|TVXTF7|e7jwu5RRTe(EE*ygHnprkcrv0B(M7h zA6alvJD(zFabpBVGjQTM-hs9E?}n}k1zPu92d94HftM&u zdI;*U!1b^Vw;pqu__)>p>>=1Ms$@9CJS*V{GZdrsu3}jJ3*70K$b_;FyIglE z>dBErIMiGY7NfE>UJzI+r~m%irEg#-y%D2TKVaQM>CZk%Se(VdB2SE6)%p{6g-MUc z;Ks$heK4FXh!%M_T)9?6lC7LzRIQswjws%IV{q$`^^rH*Rn3jF-1H0tUE{zeKT}^w zU0m(@D-Q&>Dkh;9?!d})e#EpCiNYVk>ik?Yjn7IA?&>F`GIofI=mz{&VG4UV@*lw2bvKGUKIU9?4(< zqx!?8F#F2&D%nHcIsL zKgjE=5f+wZJw8}1f$A-+Zxq>X!;=M+5E~=5LoF1r^*H5Hm2#Zovf%GxYk&P@S4q{d zU6cbDfznIodI^5djWzY_%_z!!FvC#yk66OahW&W7bJTm-HsWRimEo(c6A>^GPK)|8 zzZ@R+anfCx@dG=GcEbM7+(XtDc2k6x5s%$>z2!J)^~Z3%E~|LTN=w?W^uN_0t06R2 zEk>hLe@S4?=SBWf_TZ2nX$Bj9T{f;H64 z2$2JSfaC>fAfC%D%wz-z8#~L4;)gH?l6)@3eBsQRis>9X~$g4&$PkZDK}Us zM%91v43_ReT!{W=Uz@Kc!pr18yxC&dCt7B0hsk}QG`K2Hx3B!y*yTVP%A}0fT*)K- zklk{#XGZS%AR`QaofI*RAwa4dJ{L z)Qj+d9ZM4v`!y>XzO@u_xF3^d085EZEQvXcq9Orfz|mF$JA8mZNgOq8fT(qV*uFd! zAb~JEKz2VsPEz^yQv%n202D(jddfkeHAssSOP|e@W|FEj8Tx0a6laqMHyOz_gt^0n z45A1r=^>oKM&&Rcf`_u#b7Kj*&j>$o zgNC&RDdDUmzj&i`6`|$J3B?LVy?1ghC!vcmh{5eZnxV+w@}fl}QSa?DLfxlH@7^IoQbgF@!eLpC;y-_kAs^`$@`&X52_os@@P&Y=Y=T}=d3AZP?+C*?w(tBg*Hx_XJ-hY{=4cxeq{5KkD-Yodxo(7P!K zyw$-j(o%Ar|YjM3tzC^Eg2e*W2CFsLbfD~ql%7xyayOKE}o)2H_XRIM}T ziz*ISH2IWhSDQ1}N|50Hv5*k}PXHFc`?3bA0RLklzeC8#@L&`$JT?f3gA9X*_g@Pc z35JB2n2L&u8U;v=4MRf$q9rF_#(`lWhJCk?Sy6zjEKJ-uKyG4~|KX4Y*zkpzVTD+b zg^7T|G_WGVLhlx`6eWxlH&{x5M#_v|nhQ=^2rMmxCoLr-TWvyHZE8DV7`u1*SQ=!n2>*ZlV+RXW zXCorlL~A#x{}RZWi2oswzp%KQak*QHxVyV}Y2x~6A^I60`5I+S-Tx^^bahxAlT!>Y?2UonGaC}v0qCHir6-uftL8?1Tsvl2k zkYbuEWttE3e<0+b_nR0ZncOGNM@Z&D{)->Sh~>vh z=R>p#Jcz%hc^1YS7DY-GrJ5Hf%a-`ilmsxByhF(E3UVlKX}o-Cieg!sdR2mAO{!8& zy83_o;}ELa5a!w}!`fWs+FZ@LaK5@&;ks<|#zd*+IPT^W?Up#^mK?2?62q3(=GG+P z)_nbrQuFR)mhJ+bo>bwUQvIIZcmJ5XH%q2BTd23jsJGUvx882B+IX<}(@>twaIVmB zo!Ps5JUl!+(q=o-Wiwu?GTv%2zWaTm%W|?>W2!`Q>VFjEZ>}>n2LDx%UH+pW*D5a# zyDk6lTWK{}Z_!+z^xK#Yf47i-{TD*sSql1(g*@!=ZXsVzx!vF2Kdb~pq0s+)@c*xc z2nAdqk{nkQzB8X#p86WF;c$p3cyjiDCaND03?^r}7dq#<>$_xj&2}l7d?qGE3w<#RsV67s$gu75}qQSgPueP|W@J z<@mZ3(!ga~nO03_i%x7}L7?9g{zVGIc>q3JI4mLx#alGVgwpfM7}-Y^F|wxU+9Zk` zi#=oNoUA^pFsVX=-`=XrkNlV5F*5rgxpm)mtC`In9)WZdN@)^zLDsMOp%~?qKU1s*rJOs z!pOxC(EaG6jaGTVmY+P1q6?5gjF90*b1i9P5HYAggIYPBXXJZ)sYTbEEJ!)St5jD1 znQDHs;n%8QUVaH?fV__Bt7H_d+3Bl&(n`Oy4rv{{Hh-aQpRJ$jiDE(&8 zOM!O#$e@C%C@!MPp;7LOjCN6DbW{zZ6?Mo)$kdNP-nS87r8*m>s-?OW>Iia?cWYo_ z$w!!8B@9fTVE?AzFk`yz+UojU>V;3$)OD` zSL<>PFawtD%zxOdxXr|&$l}gC`|NWU>8?v%vX$PLtX5O-KxfkzhBYaUM+W?)zhIgE zEWufOO)Fw!gD891x}J^pueUGI_S?K0JGb0d(5(=9N}j5)-?tG7c;JHR>8pQ+mDHtb1oR^~BNEVvfGesh6S9{j|!8W!ayyD?A{g0ynoZF_p_+q?#MuY4u$8FQ+Z zpy`5u%`A!5vXCGJ7f~rcC837dFDS zqzNCWyJeeH*IZ~ItsK_HE*F9#J3B$3j7H-^MkqA@voW5UWJ%W~;EIl`;AyYGH2c+< z4VT9At*=M(OPd4mxW`vyk(!0aBqA3XxL-js{+7(-CO_GSzhQ(Wtjy^vFHWeYAyk(a zJL)fk83{=kb3tDt<)|9ePYH#>MXk!du{4mhH;m~i>pW8_(LmDeRajnT+}A)0nwx|! zbOH8@Xf+A-Ce0b;t_f`9;3iqgm9{k5Fs&|4clz5B4)-ENUFve1`V2`?wNui}rtf`s zyL+_MRy-HOY?Uh4qcTmSyK1_9Ulcq|>vL-FH*6gg+t|mJm~1Jg>}4~%*=IVlNuPaC zCgm`t>@={EC5`QDD|p+=>-M+7t%;I*OTy#-PC0Q#ZEjPe+73|N&SWX&%ci{W*I5!v z-aLixeB&dB{I>H|XD!5iA+x=IJ~+a+DY0ZjB%BZ@sl+GF9g90~-z~;k>SjEIN@qdA zmkxPBrcQFgUK!;o*D}jnUfnJB!RD5|O42I(s1WnOk*p+Dh0IWv&B;1L+z0_ZJJKWCDZ;XUj)vANPDr2YF6MeVS2u zy@O7Swr}CbRa#d;p=W+1SbCIndidZ6?5BFG7k{ode=gSq_vc@V_F-j~dHwez|3?D> zcREv(fDTlEeg|CaVFc`@XUF$mc}79Z=W)eFffeW&7Z?$Trhy&f5h8d)!>4b%27>ZY z1Va!8=9dO!Sb~5hSY@_?5B7e~wFs^Ef)qx7WMF^X!){Kcg0<%qQ=tpS1XJ*XUib!t z=+z#-<|J8XctezgBSvfzIDt_Acu6^CG1Es|1n_X4VTt0D8#aI%sDx`>*kS@x12&K@ zVweSGScd3#f<{nBYPg1Mcvz_chjB=MbOK;>Xdcv0fu4V1YsbCr)Y+%cn4|N zie|@#Stg4x7!za(}aMqvVa4pj2$Nh z&DeO**K|5IiB)(e)_6r&SVk;HVB2^)Sm%wTIF6@?ilcXi8HA2i)(R+@lB&0ki{pas z_B!Nq|k#Um{T*X`BD30VXxW(l=` zf8Iuu5@#rOa}@o?l~Tzd zRJkBj835Y1nWT}Gjwyi}nND@ZjUPFdWElkpcY;{~3MHkMYUzqB*^+JPmdX*Ab7@j{ zICggFYD?9ZKuK`Fcpj-lgriA1{$^)k(Nag~7X{;s5y+6x>4cE!l+id5P$ZF+sUVq& zncLZ&921>h_nAlkz*nJJo^%0@Vi}SmnVM!q zC@z6{ciCo(@|UbcNbmxb%(nwBH9G0hI)k^ITZ4$Y0j{U|BGZrg@q&`gW{Pqc(b@I0}DmB!7y~r#m_tGTEcRbeHwWp8^32 z#1Lyd2pD_+@q@rvm@xHs&h&4MdW@}8Rg7t+X4rUxHe1rTq1ZX5ph2c#N~$5s8Dpv$ zs#<*`IvVA7rfMpljHd%Fx;#t!?7pl@yThwmGS&VXKfU#1k4G3RMV?RxZru5`^o%%#n2&!Frs;0Ub>58tYx~e?( zaIXrhv07X}Rb`E~jF1Udk6Bhs+`DxW9`umU@<1WT+)KqGYs6gF6s&z4+I@tZ@kSv&VY$_b2f z)@WGrNKndNtaFe{$c*3_vg1m!B`ZZITdFM^EHA6FRGGFeySB_Gv*0?fO?I>DNe5-f zo@qoPQ}(m}Dzt1=v<2H`DiQ~z!3mcladVcNXgPJ#VM6tmOgjfP$N7V|Hk?ansYi)0 zMwfWsdZlJHwq$#qCL2yHYp!Yww`l9OZ@a3ND7SMPyL2l!V@QU0i??5=w^7ELv5=B} ztCD~lxPtqRhnu(?mPJMJpYSPf2q6RfNMa=x71)ZL>eN!1OHqng77l{gXQtGcVpx~U7ZF`KWjIDtjmIqW5<`&;k;d2gwYF-6idCQG`&f=vDuqs-HQYuJ5S&nzT!K+ z7Sl=Qd%g?@Tdm8sr^~)6`=tqTzqTs|HhjZ3e46yT!!?Y%xl2I+v%diRzeF6ssW8Cx zS-|sG9JwWz$ND3D$u75OsO%EK6AUE`x=hxJ!Rd7+@D)}H3Bp@2#;_{FBTT|*Jh~a0 z!Y%7WCIKw!+qN(q!w;7TcDx68{026x$2i=_I&6xvOS@_CqWW4-`U^exH^hqnY{aa9 z#7Qg&ju6R`Jc~5}A^LZN3JVkJ=9e){r_3#5Pxt56A;a0r1=%xl2Mew@R99LR5Kn&Sz?`l~KA zy2y-t#5dZ4f}3)LTew`HYD`r!d^CGirkjxKXUfEL8FyD#`#{2oC9ZOaiwMNs>&i3x zh-iFYvwS;YlERy@0J7W|aLmiQtg>lB4F(Mj#sCYu;LF0?r^E~g$BfL%yu+mTs&M+l z`Fpg9tjI-N&5azqr9rU5dcfVBU8{CEI+A}?W^-=V1QIMm5lcgR2Yhk=6R8sWbC-*2 z)`qC(tfjjpRTM=`hs?Z46fZ3$O6Y4gJs& zeZv$jdSH#Sd3%vNwbA|C(F*O+NNk@jNYdSLDGEFtRfjn*5gj?{tP|>c2KtXeID|F8 zg&(827` z#oWjA9K!fI*797|u296RJ;Z8FpIJ7^BV7j`h7T?T#kjq|Da2i1hESs*b1(!tKNp&W zNj%g0Z$3wS-I|DZ5{o1fiw6l#6Z}-G^l*yG06foyz&D+U~1X_#& zQw!QJ2ri|@2#OGzjA2pO@ExA1Dc%1;-PPSqlZU=e^mORz&+RETB$3Om%d+m&4Am`!s>!QF)zBU9aQ1pLbWaa zWkLiRoam8Ko;8>ZiarkxD_)Cy+FDo79p4u|!WrHrl+8&bT&~#dHxqe@2tWZF&;s|9 ze%}4v1Z_Yp-r_7?-Y|~d#4rq4P2=On)e~)g2IqEW4diJ5-KzskFeQU>u_K?8U!E# zZyx8}ZQ=u+;=FSXzW(bi9_+yW>)}xB#(wNl9phDP3$Wk`&d%NtEzvtA;C+keL2k{k ziR~;Y%-r7Xj4s=JIutI%hnMGlNUG9H&W9+qlX#LBB9Cx+ zs|^g+e(j3B-X!m7-hT4h4DL)^(#A`VujU#mNbY6-AREVZXB!!e(pGJb+Kq!e+z?@RRWWS-ayKk%g6q5X{TtR5K*-|z@B>{f5}6HoD-UGbW|^>{d_+9An)hoU-}}S_G*7KsV{#* zF@ui#OMHo}Ddc}i0cY^@lQpf4w_mx*2M{a-(vVTZpg<4_N376+q{)^mYb1)HSW$}< zj7N&-;FtqP3Xma1j{LB}q)Ct}O0KLR!R5;bF(Je(5CFhUoH_CB+(}>o1Pei1(zKb= z=uxCemEv57&gnU*QKd>9_s!~6tk<+=-P)DfS7>0x5_?vb7%;TMdi}c9maSX3vE;&{ zTelS}ym?c7;@fxAUrm7pKO$Vo@Zm*?6%%4ih76=pktH$eQ(4XBKa?4PlH6HRDPpC{ zB(X7q!|Br_3Oe!9y3A|XPK+cOLeO^q!5%w}EaA;N$Uzbc7rMZGFb464Lmoz)Xz^l3 zjT=3FBw0P=$qg#BuVe`m=1c}Pm*V7!;AhLB3lJ0?-`>5^rtzoFuUelQSNvYPHsjyF znlk_c4Dc*t3ViFpxaP8JLB0HPaIi=sln}ASDrAfh$NCsW7s>GO@G_q8@o+OqIFn45 zXLRwS3nOSSEj8_WP>!`Jx_~XVDQ1(Ahueyq&9~o-8;-bvj0=Dj1ka?k;D!!S_CPB6^@fJM0{v;ZPV6tEUw4jfDE!A z7la#b2PBhZvW@26a54%gqnuLK4@g4kN(!{pQoJ$)sOih~#_V-i0M3NU*fiB-6B}mR zbTdvlk&$*o$N%Jut%)Q&=)NCbn1k zkWE(EWt-K?O_ZUHmfC8qy%t+-xAoK83Jbw74ok)zw-lax=9x1_g3jz*c0>Dv#U8ec zm)=dG`0-wRneLQdPl>eux=7<{D2<~d4xT9Cubq6dqlc-4IO5W*qY2}TfA#odxXTP# z`EF<7RJlKvTXxx&Y+;UB=9w!D(dL_T-g(gyBm3F2MHPKU6g*^eain>v_~J6o zS)`hWA$E+qH&OpBH6g3BF4$`&16eifg{6zq;n~lwm3Fn)X8V9(-;VqD_U5L$?r=)Z zTkpO5_WNbQ2Pd57NDfC_4skmqdPJccciiW)R)kk1dFkzZ{Lgtr6?7SY?2RYYwIkRD zR56lhRo7o%gO1o`uYG?hZ@0mt>R<_DU)q@OfOo*7utR|h6y8&aS3KjTY%IxB-rw#5 zxaK*JThQxPVQhB)hHwqadh1G5X0+$H?v)`&r%Q-~7n%3PFz#iH9b}~$ zA2TR5nv0Djd}AEHw~!$8re05jS{`FK!>S#}eONQd42)?ILNc;-h-79Ex6nvPP7;#Q zksbK{M?13rtsn)K=IsRH{;*8w3o6CNw=k z?JSm%i`=??W~17?h>pA2+-3IYw9wUXbfhcYz*0iY9?FlI6Wv2a70F0wPE(_?n$5)pVt()HbCOE@Mrg2K~ff1D8It9cxQ=T%O^Q31hJ;(<^@$-b8;pt@BRk3C#2JlfW_rMJaxZk@N+!R(e>-~#UB1UpMN zih@J$l7T>7_%!F@vANIHSNTi_$WH}w2%2p~C@Rd|s(SakV}sRr$y?rQa*b@MHLH5p z+updn7rybWt8KYhr)#}4a2m|7e(PD7zXEq>{$~44B z;w{{D&AZ-Y83lpC$J{~tvcY_OS`Hy>HLf8W$_qb5(I0+v?lQ?al^&ZkJK|OJzC?)} z@Ak*t8}iwf+T14RPo3DT@_Dkn_6`^Vr`l z=W;#n>}Z#Rx*n$nx1WwUN%(W1XP9#&-(5#O2SIA!*LUqUn&^bL@GN})@9gbbd69`H z!s0g?b*Vd^q>$GMY@Hw5%8&eoYyd5q2f&qPEdOe@O|2w)jjWf|9isgEJ_=|iU_YFsJP<;AhOc70eZZR zSuKxwJ_&@Y%2OceBRQ`459_-=?AyHUi{2IMvejKB$u!kwTz zth2n!)4&Z>GtKkB4+OywOpFmk!OM?+mJqClWG%Ps((>Z|!R1X}CA4}uG zD8mIj1VR85!XaF?LnuNXlsKk)0s~aSCCruNYeFa7HV8a1DU?Dgtip1-Ld<)yRqH}L z5j%VGmhUr>;2J~Az#g@O1bQp1&Uq}kgQ0$#p;QzYIK&bj^Bs?k0ux0wi0u06k zq>f@V#$#l}l5!jJSVm@SMsYJI>eB{@j7W5wmdwj5OkBDDYlJhhTO4y4J#&POHbRtH z`bhZWrJSRz4(I>}Xd4RnfS~iRG?2%7+(kXC#XbbS?(!~4o3yM-gXhpPt|G)kL_~rt z$P@FD0Z2%NjKWBazWH#-a>F8Y3yX^6!i#hTti(tgYq?J3Mp^@!@>3U({17%2Ns^2d zQL&d?f`JeSfd>E<3CNC@%m}~h!CKr!n#{#~B*H|{$({7aEC@`XtT=(ZL4s67gIq79 zY`&$Gz@~J{m6FQ&qDrc4Cu-!pjKoI6xDYw}O0Y~pv>Oo>a+r| z#JEg>7|6j6OSn+DOT4_zy!5{!)PukDONtQ8!6eN8?${OOb3mh5OvY@?*LqCItQ*N3 zi*>Th%e2VO+e*#kOd#vV6a>vOM86d*%{BZbBikj)3IPky7+*1ucZ5kX=)qH%N8F6h znk2&Btk2K#$)5~P1r(sED^7$wPF^_*<#a9PR541NOv|DMCd(RR0bD~&lb&1!OJlFj5w^q z&-?_+{~1o*NkrxQv;yEAjv3ImD$w^jQ0U~kbbC+`jL-?~%#I|zm=i^EL>IF>OS+3a z)}yQwXw76ij}tgi6xFO1ea{$uQC&P!dz?@IqoYy#>`Q6OQQ)jN9*qg_D9W<}P%l9W zB85JNMA9TpP(clg26a#-eFa2KR5xQQ#1M?qgHoOHu`3Np_xniK`y4!C%aw#c27mzA zJUI4rPkdC87MKiaup4Bb6;c6$>RT zR6{*fMWr!DJq$;s(6Tc@P%OtPeLoJx(o}>2)_lMbwE)!s)%`0|e0))FHPyWALkwG0 zR>jd*-LhCUOj;#Q*EGlp2+;$G01T*BW!zP@szNI?GnN|EEm}}v9ab;g1Sch<6XYpo z^~e!HKh#@A@cg$u3K1WmS4=_x5-E0n(L> zVabdU0xPfr4Hy6o&>R?O%?6kN2N(c*<<&p^RetT)B_-DCY%78dF6}f!?i|GuAxCHh z&+wGl8i;`93sP)Vv}wcGGUeEg&Dv9?1g>p1uB}h8`OT8uPjyAvqU_WLz<>~FSu3Dc z7+?Y`5P}eJfC=b;3CLM^$lJ&4)qIUiiTvB1?b&|?*d{$z#CTMq#n4e48pd7R#(CCg zMMb+40?K;XiIrN|bO<@M+N(`dt<~C_>{_qwuAB^8Oe5QqB}%hhA`EzexTV~;WdbIE z0otWqmBd+l)!V)0+cG1!{6J9upZ!^&?L46s!EKDvW=%WOOFz@JR9{Q5$~sT93Xvdf zfT@)NWW%UHA3so9$8z3F^$lu`TJ@xqF$tCXj#^50Q)t8{MBDS6}e{w z;AtFS0xn?URjXCluLSl?4V6;!GpGoL!PAT(-iYD!+_;U)02atDi`ZTc24ODt)?@f$ zQ^ms>9pUko)HO{1)F|5$qu7;9PkKE746s?=K{5W_-R8VN{jiGalb~tbye?9Z zx)9<;J>boJgn~ul@(WGoZP@pNV#;;PFJ(k*tpV(<%PdyW&h27O4q-6{Su!r+Og`a` zINuvwV>TAiqs$59wBtMOU;iDqsI0`Q1mr*tVrvXLzA9dO5<~4-U>+P*MCjXx^0OY4+k{ zz|A!sV>0eqz;q7(jX0YHL=EncRhKv`3z%WKJ%I5jXG|&3SngqVrV}6*B7JQnu(d&S;Ge z=YWO*Fc5`7V1k_{XOYGSlFnCjR_ApFT;OeIcYbG;o~fFusZR9eu_o)XzU8xCX_kf%#I3apRbtGDqcf6g+Lm4OylXL` zSf4(lunB7a-xgKC7VN<$Y!@}`j~(H_LsfrljdFTYzROA4X^@Hu`r@&gGa%YkFb~OGxCGUgRqMkjzk6rk(ABI_9jNWDVE> zCzv0l`)wO#QQ|Ia4=(WH=Gf!LX2BymiLNq*`Kl^05WdR6q0W&Ct?EdiV z282NX11p$-T-~Jb7Vq%}YZm9@@($LN4p{aMjKqKpMSg93HX-}IZ=8PGaZbh!XFbON z8yhWhX%_C`Ht;iD@WeK{-FtA~2AifXW$U2uQ$7J7u!2Fj>Jn80p2_Yn7X=X~aT5pc z6j$;8&?fJbMsL(kZF$m`8K)!m3r0WXCZC~MlAee18fHuP;^h>Bk zBv10AR`7>r@S=P2-Q2AD34ySxy{`( zNAs_4anderHgEH@e)HAdFGMyGIYiSFxLiP=?LYJ^@ikKfU+8H7 zV^RgeWOs5%?`r_3^k;IU(qafqk7_{A15wBW#R~QL4T>7Z)%IF-R&RA5p2!$?b6qat zIG1y*jBoj#?{FL%JnwZxVS**t?=Ri(CHTH$pR#C1h2UOv&&67V@7N!#s@;1}2aojs zNe`_^y7aT*CLi$jK?tfZD1||AS*d2Pk3n~Q6>V8AIbdb?b`K+Xk9Tfi>lDlbnb&oE zCuSK6D(OYef9C-&D7}Uwcx5l}gjaYp-B@Vn)<+lPfiK;Ozp_Z;pKWKrjJIlz=b10C zT#-*PlHb|UUiSn&@1J#dT~39TclpBzKcYR@dS_spFXlei`DN~JHDHXNzp%mcg=L3P zhE8}F{bYxKbUrL&Nk2S_FCwUqda15}so!`O_=4;P`I2(wtq++MKlxWr`LB=l^bX>8 zFMG4+j5JdF$O-15;q|ufXASp~oxq93^obMb0uQN#z#BXQmxg9<_78SwqXt+1zejrT zm3ZbBMk0Fb;iTlnuX<5{{7*yi$(N$6bM^a({uhrcVL#fC5Vr2oCIebeBFy7Rg?#0Llj0xS5)BPvf1 z8DC0?vQmNpfdCRGP6S}_BF2mwH(rG2@#DLYBH58Fx$Y#&l;~EnJm-=e%x^Ne(X6TM zX0@EucJgfI6B*E;Ky4BIW%MZ0SW1^NeYNXps;E*uQC+3!D%Px8vl4n_2^3gHVkMCk z`{yiLJZjh4X}eZznJ#kY#;r@2Ne~SJ3k=9O5dnuKcq~~(bt)9%!C z;2a=4U|{?K2quFL)^M><)F37>LSVo^eZm9>6*+S6ZV}|j@FrD~Z~5|k%$YWE>g);a z{ZFAmizcn#v?=d4dmCF!Tov9vESeD9{aJ1(sQMz<_sMat9um;*~f5CVJ_qw;p@$!55!= z$k1osQTO4eUsZMbcjqDivZB<01r~T;NM<66DXM5$i!X*oiHtOcW+RTI>bT=;KH3K4khBq5WqQ zsfj0g`YEWENh2z$Y3PBYm!RBAcPfzTp0p!800ES zDK`5Ih7~U~U=g%M8+|lBCQVDNwby2g&9?Ay+pSRFl6y7Q=%%|ayIC>%mArl0doR9Y z?dz`>X{#OZ3=tT7FhziM@kc7ZJS7ZjIHt;Cs1>hx@re^l#<3o0Bm#2CACg+K$vn=O z^2#jBN-L7ZJ%FnZFknEOKpKSLgAhxIE(8-VOg90BNUOej($X?*-b>h?8THgu8*{tW zS?jJf*Ii@vHCSSkZD84GF>~;(|C&?>zFN1f;Bl0b{-+!Z+*<^x? zdf1GIC$2c-udyly`zlKzTja8~%-ae^7Pr?x3tSlgQAEczQ1JiwQm~7#u7E{z-Rqq8 zG}_e;KDc{eoQk45a+!;Fz4Kk3-em~_4Uc$%0#u>yvb?tKPgxZi00e5FhEW*hdb#+_ z3%9qu%yjR2m{F1VUeqyDoevd@E7{3V*1q=*QGP^pUu`INKmIYXfA}-b{@%7715%M$ z2uz>?XBUkvO09ua%iRPicrFWK5Gxr}*9JLgHb~&>gJw})zm}IaA+X?oCftri3SfaA z6e3>6a3Ks)#kUgG@M0>;Ob(Tin#a{BafkU~B7#`ND8LVLM}!sS^!G#yApioO3jruY zS)CG$vO35jU=^!)#ip?`i(2Gj7rh8UFov=Jf@CaXCC-?}v3c-=Z+YXt&^EAw-O(=x z7{L@Qp^Ntb@`ZvFUmG^Hv{4<89hNkXoOl|*6^U-p3tXtHzG$yv>^M7nhf z0R}U}(y>sPO4W&Jm1S~edeX$e+Rc)dwY()Rbt$|K4yvFA9SkrHg*Ke+ZzFn~9x<4C zH(@w4Z-k8IA;ISjYGxEih4a|MdI-tJy(SQ?8Y26~fYNVbQk>+}q;VXe9R|Rl3Tzkz z(6WRjcaqKuKnnrU=D9k1ViBME+^6m41E&c76QBX@!zSQWFJ7+kKvqpC+Nhw_6S!?J z9C>INYQYm1HuE%`*%VqcYO%EXqBDd43(Yk@md%l>kDIbtLu}lqQkI6(elUfiL?G}2 zFyK_DRtOkRnE+1=1XZX;t0$R?DmyeG)jdjGsz04#OQ&`Xc=DoZRg3pV^r5I+}_&vCjl7Hfhttt1saF|49pOn|G@xD4>>>x4$Iia_Sw%w z1+;n3+dx7a`q1p%v7+Jsi^ky1H?%@#qaA`dp+w=u0(geoqdLurYeab`q9(O8{Ki{# zpt`r3QMH3h^j42z_!79d-Z79nW-@=6xwcm6u6^Wdm~xH*La35MBESTUS4TN!fI$N+ zAOxU&x7yA6Gq$t+%54W_CtvjTx7!V_x$UX8Pwr|8%!jjOhVS>nv6UYuhTE>*;Iw>zVs{iRZ?zPn=l@bdnWR z2@@Qf57-RIAsf(OfXSWQ@ueJkXj{~7!=*nN!`8i+va&*`c2(~ao(w+75!0i2ROh1T;UC%P6Awj31lJhjp27ZAOyya1g6*E zT_6T#payPW8O1>d_LB7(%~}Lg2|_`;HPo{lQwWSfELdJQXoEWtVmch+A-bOp-r)M> zo6_wd4<=lUs0ua-L#bt5h_GG}vd2_jNa;2N@F^u3`j;?h-QkOtAA^$l613Cg;epfMVw52T_BCJXe;Sr`N&H4Gv- z+~73QAo|@PzvbX=ZHoIvq9p3bh_Igv385x#B6HE2CnjMi0?8=$*DJo`JH}#p+!Kw_ zA_Lj~;w@gF%(>w%@?tM)5cPfFFa6RTsLe6X1qwpMGCGuOJ(gQuH zpEf?CH+Wu_mD(b)Mkt`3N0Q_Hkw)xsVkhDi60RfJ4Tn2&$M9_$JQklko&-JCqdiVw z1?D5+?PEW}p+6!XFFhLL!O_3qg)%OrUl<1xC{sk4i9A>&MY@AUN@X^h8kJ!gM|xvw zw8kk|;w7Srtks%H>K{s`q=&5|4>Y0A$>c@kSxn9(Jl5n*;^gur6;JjgKLTYg#i0k@ zoZ`8~FfN`S7-b&fg^Mu?ObWyfI3+ZsM^sv+4OZnu;vfx8S-+uQNA{qrnT9xy&%<2* z0uegS5}su`p5_qkz{_xwTNc0syub~ZzyZjmT*hKu+9lvM-%jS3-G~cQ<>F8JV_z!5 z92Qw%3Zn>);9&C06gYu%<{=&RSJC{14mjpZxWhS6=49G~JxFH7U>TNSWLS<&C0?Q; ziREaLChVo8t~HnYNLO2O#~1n(8x-3r(&iYN;cen(E$$|7_9oTrB8?XT&0F7+o=PT;xe)8u%`saUUmh=rLk^Wrohk4Rh! zu;y32W^BTy34E81=H~oAK8vZDd;-Y{KXuA~Ya2n_@hL(~FBZ8>g96eh_91Q|g z=~Kc4RaT`$cBqHqV7@7$`(b3od`6j;=WW^6d5VnvnGBn{sY<3L%G5>-#OX^Klb#Jg zt>$Td(xXlCsh`dwW%XxX>Sdx0si7LGd^wsx9_K+B^e*DzE-2umI!_9?#RYmmkq1?7j~`D>99=Z~SA^)aZg5qg-&f^AFAD%s-ys@a|`+Nz=2@@v1k zt-Bnl+$t-Rh9HBw1*7P#36jwBtWLD%0Sh_9HDsPUaOXN?>fyRWW@=`|K5c@b#^p+G zsg0+lh-TJySgJbCn~LHFu-502Ew9qp=uVBk-h%g`I^ z0|ZC#_LA-}RImjL>*>17_-b&1rYLF@t z{bm`{Ri@J}?*5{xha8+SAYA~X52iGN*ERwlbRyTT5C1*?K#V%nY5_o=1<(ONF#~Ue zz22(?Pw=31@AtX_7q`Noa+bexuoxq#K&6p!9_MnVv0!$Aa}L3i?yV1yfTsQJ3a^kW zxG*`agH;-CmsaNe+OX5|Rt}#ECKz03AQ--JjED#^*b%W2AMy0Q=%yWj&bZV6Ou%$R zaR|Vs=CCgVXYUn2|Rfe{ocB;25tm`La<5&uv?{uFmFHA25g;?*I?Hv7&gg z(5eC0Aj55?Lu97kIs|XG9@sTnqYWma(vj(h81lhQSt7UEA~W(iI`Zb$8m|pO6DqNP zg+TAgonDlH=`?`ODBJI8+7ttT6^pVv?^AnZu@;;EGAi2%e6cb<^8p#$!Q2u;ENkB^ z?;I_cK^y1tlg_Sc{q2A0fG@*~^$4>(G^{)rb7nGPAP+L)6f)vSgAb47r4(|lVRJUO zo@{V42b^q%U;q;k*0K$N&IF)Jg8?Ais1@MpI=AyXk1{D=Fi&qWJ)iPk?ngg{aXzQ6 zKKocdCw1#4=RY?obNZ|gFqA?gz=nJi|@fEO@~xM;PM@v+2$X;_D8BHu{=B2G3? zgOoAvX|#1o5wS>jq7lpW3czSe3xTrfN*=`V3}nt8>7LEV-F;r~Vf$)j-Plg|v`^PF zkJYSX8}$b_nxnC9>%Ik}m~aUWlkLil9WX+oX?0p}DMe!@{(h^d2{M_6lv!KiSUX~? zAuq_j_4C?x>$S10Mo$U!ULN2suk=6=P(ctVgcvT^xR3Yp6$}--PAQTj|E_*k$g12~&5qYC`F?+Qj6R%b(VlzK8$h@~W#5Y-^hKJNQ zZNu$-$MqI8K@;@Aem{x>)Id1n?m=k(RkH$&?;Us^h%;w{Ze5D5gD-b;2de}{->^pa z28*%HVtCv_l~NPzEQe4YHpsHzvO&9XfzJR}O?6Pp7iaLH$~$qAZ>xVf&W5?b)@`~elw3e)z%Z1*2fzZHz%V{Su=z%x9CuR22xgBe`_A%}t*?%BMR% z@+7~U3%+EYR{mB_CNFiXiF!t=ugShBWhd@Xw*q>G*Xu>eO$K6bQiXVK7Zxjt7 zdk;c=#!5YnW1ZD|>}zEIz1G_wI))gd%fPW|yaRx9lKa7bmpxi=I$lVKbR_f?L#2AO z{jaM0+rxd_xBER$cg)NDk@|sk=e^B~`Mvx2Eu%RN&_HlgM-;YZ(2EYeSHe-ekmVP% zRWdD@{?>{wyr0kZ)Xw;8Q|{H9k5$CH=P!D-yFh$OMCp@`R)sh21`mRVJb_DkLasgA z(|%>a68{54Gh_pe6(slzVZvJr8QO9P3u44p6DhK?m}*l-jT#?m^7ye*$VDSb5>j*$ zrOA{k`M8mThY=(^eeB4wSqA4Bojbeq^a%y%6`)=2a7nU*M^dCpYXpH20t15r_^4L3 ziZ4Kb1t*Lcxzb1f6T)4*atX`kZk;`P^4zKG=1m%0b91LDv+HecHoeEB38RGySKvc> z-t1|F%b2)yi}mj1D-5zDZ!EuXY`K_GsI=cZVkM zpuzA88%}&Ev0{3R8`*aRDH49kl`LD*cSBXpO`cr%3+?}ZC;)pZ>ZqiKI1s@gfb$^) z2d28}s;m~^pobos0PB~rRv`-+wANyauDBYjtC$j}8L_Xv{+f)k!VJqLv2>^r2gS!C z6AZLQFw?C6vd%sWM6}VyC=CMCQgfgK7+@%EgdNQAV>aCKFhjQ)GSFZK;Dl3-%Py4* z2h8fk6jM8G%sjKq8NqXAO<;z36HYhDD=(Hh)mzV#JU`h}&-eU%Pri}rn~y$|;&5XP zGW5%dQJx%q^rf0=>aU4P{R3)r-Q#ziUE8Sfm@Bs0xUp^9wrxA`XNH=WVG@eTU{>e%klRj@tytHK2|Git z#`H7`4zspI10I2EOtpbGHwES#`T}#4j1OiS>%5+xDI#q&VJ$eo!mBb6&O%9alB&Xt z6bcF#PFNZj|0ZeMWrz?%|9nwQb;e`MOm&v)s5E(p_xv>SrRaQIDz-o2w%tv+e;?5rRF4K+7Xla8p$?t7BW+Wr1^XyoKpI+c-0d z0s7T^pu2T>0WRQXBzw5Z?-=3=aib!WShV-?U>{-ZucVFY0Nig0+La-ne1W4F`x@_e z*rE1x#NZ^oQTG=;YTBLwEq4m*h`1?c9_xmcb0~9GrHp4aaMvAixqf3 z2K>!;RK9{}OgL5;mZ89;iA<<(UY(``;L7qs5HNurKzO$TND?a`%=d31ory}26(DP{ zb|a?1myUTarkFxNu4F8J-0v{1Ws*&=h#ulrd*3J-^PwcIUh=yVAvHOr;WQy=nhyy$ z5#S_gA@nHjFeQ2HZgAZ6I(8czYFv}m0fDSUf0lBXr4O9=Z$8Ol4R)sZJ{BYM7cSxU zTn4rXksxF?CwvL~q+opj5HigOW}6BrX~?;sZzXc#z}h95bs4!^fSaQ+@{V+Q%a~f; zd$JW?POutt9vByqEd2Pk4 zyom^kr5r64ilLPPudhT)S*?{|BWFUO;kue$q*jNe$e$Jv7^N#5ejfFcMdT~c5zG`d z1NQlt`b-e$gy~R&=Cm$~yFtX|i%RKKQ&L+hi+zm?bu$3D8Pr1V8TeDC_9*M>@t~?q zho)?dL$vsv-6R&a0T@Cfa@FW!VDSzIWm|*Dijb}1g2tF_3H_zDFer2Lew(_Wn&QN^ zLnl97Xy3QB$NmK$3sY0X8197D0W*AS56O|siNpb6G%vc|_=`yAe$5s0xrjl^4s;jl zMXjek4@^c}dUt{|AlgQ!vVYyJCnMqlZTOV6~o1@CFJ;nI>*n` z48J!RaV&R4Y5g;{T>M`Z8tgt=Gw_;yIs%O~!I9?nSCnZhs|xKmB4fX8qyFMM4eHan zup&U1!U7UVFD07(;Mf~JaBtF<4#&XS+Y=R6k8B-t#D8ldk%E0C-`TD}TI{)+neG4i z{iPYzhSSk!jko_@tfd!e`x*+=)l!SZwFR@|rk#z81p6GBQ86nM_NAfC;*mXjZcQM{ zw_slr{e48;(q7App^oU8Yh0h=GEp^qK7{hP$TZc3odG18P3Ozj&boB)LXK#JciayN zVRT>F{GOX+1l3Kld!HZAQ7JOVxe)E(_T3ld{t}!EHFw85Xbyk61<5}E6MI!hbUW%o z_p7t!yw5@Jmy3pLc^A)JES8i%s8w9=CR)|@9056(ed){-RYVb8i$AZX`w@%V&M$k~ z2*-I5`OIV07=~q~(epXLAqn%P3t)+OliTi6)w7TI%?<7|z*82Xzv#|=l|gEGyhys8 zpKna^-lv%d{ayJmj*Rvi&Nz9>pmp5({cPtTRVy)o>v#R#eu)e@IM$6zd)46~!w4Z&_Duv%$~FB> z?R78GBI%_M45Y)d5xmH*Wo5ixt)jJrG3s;yB-=RD3^cU7JTyE63S!Zn9@C#y#Z$BT z(``l6Yy~R9P(K%XVKZu>&LY@Kh{sB}ni!?oZOaay-G`I}cut490w#pEo99;AtjZaL zGDJktvFFZ0M0O~qr?_h-CdkiOpxyx#+}PXIxisGlLZ>5yNW-W^ z1E#;?mP!MbE;4}r2FslW+mslo4(3+s8nIP;#{+HBNBJ&*8Minb<(&z=c@j4s4G+m- z54&Nt+Tm<8%F!6L|1iW5?uI4AxhK*~w)WkL4i_A59GF}MvbNZuZxf|{g4-2}U#H%N_f zw>ykLI&?u&HVgZB4XZy#%D6~s>G)KC0yoG4fY{sYc8(Qm#E@;&oJ6BIxDqF=*VIaS zHM*ndOBjn85w{vd^y&|W1A|JY`wGe|SiMX92690TRH+QB&Hs?bjZSKbL#IwpqRvlZ zfo_;ZmG~+!zSs9zfcBKD}qkl(4nLn#e+U~HH!%j_X2<`9Y@nL!@v-1 z9ukbzN>#BsRXpZt)~#yRL?@xMIlL*=eG%1*-AV{6wsku&$Ak z*^cvYqJR`7$#gY0gHb_9HLPE^uW%`luw#s|W4)CRGhC_fttld1YE%O$e4q3(_p;m^ zo7hsyw*)ZwG^)L6nj-v0nh`odu4L*kTUzEti1s@usBl=WX+>~$CD>G@Hh8IPRb}x+ z0{tuH4kndT7nRIrEfAeLa+Dm6j+JUt1eDEZY7tc}8IrkfK(;SMP5x1hlWmFbK@`#% zS*r!c_*5OQR->$OFAPGs@s5?51^R7;Hai-=dKKSei*RWDssP4ZE1giT-BU4P3R<{Z-CfZgDA z$e@%3*7=e5zU5J%-*7B>NQ%|y*R($rHZ9^RQUp8V?|aEWHm$T&ZPi8-OG@c7cNO+S zB1n=efH~ZmvTkY#3>~qVw33KyE7#~s@+7;t`l{MQ3K_y;xY4El0f&WcJ?dpaL=0Ty zXbc*=+zk4{BWTkS4hc%)Cu}eq*u{LkRVfe!f{ciS3>@oe%S=vc&RN+|%nd(c%P-Vq zAi*_M?y9+!QGdL*yc7x_6Xq$=&hW%cnZuwU*?vnypBBd9lQAx?b&yYy-+JKHjBkhX zL~!8HS_@YQbsD;2QzRi)4F7@8Z3mz!q#G^b_=@9_U1$AGQ%a@LnW0UPEZBxK-5F~@ zrwhnv?;>Li21#1rCfRB#KW{g;D!YWOzw~GizMya2=21MWp5CCMg30IqjMqav{lxM3 z@CiO+DyDjR+g>Xca{BmVx}Mx)T7)9hJR6gwUEM_l_N>|TA^Cm1QOfCu0saWpFikJ9 zkX32318w2h=d*?{dzk-TGe2JoFntQrQy0%(z#};(xm|!&cLX78`NFJ($L2tsJ^*o)8|?Iw>W;mAFDR)8+FDn|*|1 z*KnuwUQXaxSS&rmv{MDAV=T^7l~Lm~9490m=M00jB7#>f%blUo!!dC)qTUsZ&snso zyfD$U$EqWJUl|gqA8qdM7GnU(=>18^#7#`Vyz%y!8Qj>{$XLY>Hmwu@ssR-0C(c+{Ukl6jQm9n^d7L-dqMAe*JUfS4Y8&7>8~31#}+ zPr+n|y{4I>SfAs28v{F?veXf~mX@lEM`FyKR;WxGUO@Ab_BgsEq=3Q|)~4`h-3w(s zea$jPg(NG{JD%!*Lf4`YuahYvlEV?hB(f!{ZbMpi5s8V;ttV5pdeA9IBInx!VQ;)% zF#3wrCj#Vy%j?FIiJbRaKn~J+jEt9O6PdwL-*A^QTdcn6sqD{yGTL67lpb*T6xv|lWB4(5=G#qB<@t* zw_xK~o%+kl`c$3@NHS*ZY#nEC#-poX3^)H^nWmcoa1o;>j88Nyp^2YYPgu9PvAF6o zp;`95S^2$W;w{$@ug2Lc{DSIW?~8Uko{mV~ ztju>QYcrf}=1%_f&N?vFIszLe+NNXaA^CnN4&EjPc(sZ5V(^P@*^eC147D7aJk6P&}%}(S>uG(u;lj6yl=^h??~0yio_t<uRvzxAfeX^zxEJ+YZI@I`&7>G48hEj?#!C6`7gp*LycL}Rt-nOxj%|t zU4w`=J{jKc`QSS9-~H$9!TMog#(7}eF>}R}x)+G_JMz0J8sJ?)Yf|M~w-BPmQWHXz z6kU2k+aW^TOR8(jibONkQg+LkJ-Rcw`ni8JbW3kFi(b}NH#%#2Rsf2Q8NNS(2MB%M z+HA3D1>fHx*deu*rm;X-6RFz>1hR`w^^4B;ixotc8AqF(t2ta*%co4+Bm67sKey-j zTlQX7j5$_KSHq06zyJ0xvf9*rZfyti|AmBe%y?|beX$NEurPu24EGlTg%2UEr;vn5 z=Z|aBh%H`1%jM~I`1k3(F z?1|n4`ty1_%5w94-nOCCR7(n@ zBk-|8*sN6qwL;%|Y4PgAPcZh_sCxlqSqf9D8DwK#e{H#+ihV$V^oSP(e`-5OHbUu*y+MUAjqJs~^_{_$VNc2T~ zckD~=Pnm6X`Xcqe&0QvRdU65;K1jtCreu4f@@Q7K%n~l7T+F4k2&~VyG`l!JTf`EZ z4Df>@+HkMp#8A-a<$-#S8^q!mw!^|-Oqz)nB|xFM;vUjrQJ2gT;U;#Y8%BA7qdL|< zh>|z0%MVQeY+d9MnIZLwlExakZss9~o+POKP6B`74#h`_B*|SD2q)0p7M0gj+}F%u zk36=$pL4x5vOEoZbZRA6{0#QXegz2cic$)E5L^>bJrL7rz(#70$wy~#jdt3nXN$}yNH6vVzTguwfRYgS&Q zz($@Zj-PqxD$8a06+o7X0-8j|S;(PBKY;~4x&;(_U`>MNLuG40{ zXdWuMNU?e7U-cT3s$rCew&sA^oVHfCa|;SbRqjH3L`@GsmkBm1zN+U0 zEmaWoEr!n}CtzX=2bOl8X*gC%n1J3i%)_fTjKwm|z6iyHD%+}to2S;UiaxBcS^S{Y zp^Fb{9H-}50LiSEFt;*CisJR1vA+*a&S`CPz=vs2l78B01BtiVVAI}8U1AGc@!~vy zaL#>R>+4#*MKTWhw8DQO4Qw@&QJ75;DVUo5p?J&EoF^OMXl}J0?kMV@3eT-Rq zx#P={(=WWFAS%z}q@pO_vhv4d#s<{S;*G?+Zal@)Itcg`)w-!<4*gYAqI;x4=PA>? zZFKN1wmaJ!FCx9cg_(DFmvM=UexH3wqvv27y*8q4SLVw@8>7h=?R{(=EhR0-KqGKS zs2BsE56s-WH}=Z9td{e-vA-?Uf9Du5i&01HpsFFSTr^W(;1mQ*@OJzML)zeqthFfb zw+!DT%1oK3;1`1vU`dksv#hUlIu>>g5DxfnglX9Ki!n`wxae_<82#BYz?Zzp`v`SH z0v@}*p6itL{kgsVF7^%H95|2}+wKJwzkHE8ejr6>q$nM@9OQ1z?NeH1U zAwh|h5-q9?UrRuiQ7U53C=rVgr7NOHEFa!vzO_@hNUH56&2RrBW9oU1`!nZxB#MLwd)$looRc7dBStM+dx=450g5et`Ycc#ngp6AjeudQv{wqLI2P2{; zD%VP&Q@+97HFDQXk!u3v1k+Zrj0l1^2gtq7Hd{I8PMYS)J8p7fl}K}*@BI`E*Cv_4 z!btCUhArawyDdz2P9xk+f)K+QuV+xS?F4`%OK-*)2(_Q$gE2e6_jqv8LMIp6-4EdWYFb zz!f?f%5kc}%L6UXNe55sV>4veW0pU{e)`x$Q!5O6uYO35EYt^^8XJ2#9p46^9C=n) zz7r|HP=5gi1`h7dKaEYJbr*qBL$xzQ=?_4UqYC$d4BPUL4+#-sGtd82ajl!)u zVy|17&)!+^XzsBPx3@X!N=e#$?tKZxr4m1_VtM6+F59MWg!FO-Cu8%Ya-`ZHl zd|4mmFwxtP8OhmQG%gJtV-BVM#Z@ofGkG7RM#qvTm}$06w^6TP!H`l&khT00G#TOp zSxoe?3pfW6!|K*nA`AA2`YSI5l#Kq8spnqJsbAyaGj>Ind^>JEWALQyxxY?(QW3mg zcVMk2fe)zGWk%qIfHx7Y#equ`S<=qmAgXP`A|xW3=U3=Ih}odZ7jI*5EJ7+ zQ^|f?W|D4^*U(SaXcCcO3<&A^MP%EiP`c_&TThKM{4-sm9?B1+q#(Sfn>p!1VIle4 z1KvRbQU7fN!uz4^i-EBuTc|5+T|08Ef0?Sw))t{9T>DV⪙58Or-?pz-p|EN1xBp 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%0A(2t7wBM+-dI&20}o7?QB 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 z>+Q^O_4W1k)_VW{{{R30000000000000000000000000000{p8

0{r;$N|0>zNw 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 z%0D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

~wi?C=co*i@EsE2<1>t7dryOX)DBKP>Hs13=;v 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

6(<-2s($8_sEG41=rkqEif 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¬96` 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

(VW@oCQeB@8!75J$S0qmK`BwaAL_PJJ-d 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

bVAnFuY#gwAVN8bt-V4*pyquN4W7JE`2hanRluH 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