diff --git a/.gitattributes b/.gitattributes index a6344aac8c09253b3b630fb776ae94478aa0275b..7c686966cc50eea41c8b745f35baaccba59ad3d7 100644 --- a/.gitattributes +++ b/.gitattributes @@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text *.zip filter=lfs diff=lfs merge=lfs -text *.zst filter=lfs diff=lfs merge=lfs -text *tfevents* filter=lfs diff=lfs merge=lfs -text +*.csv filter=lfs diff=lfs merge=lfs -text +*.png filter=lfs diff=lfs merge=lfs -text diff --git a/.streamlit/config.toml b/.streamlit/config.toml new file mode 100644 index 0000000000000000000000000000000000000000..508672a57fb1caf6378b84cf71d6d68e6a6d2df6 --- /dev/null +++ b/.streamlit/config.toml @@ -0,0 +1,19 @@ +[theme] +base="light" + +# Primary accent for interactive elements +primaryColor = '#0078aa' + +# Background color for the main content area +# backgroundColor = '#273346' + +# Background color for sidebar and most interactive widgets +# secondaryBackgroundColor = '#7d828c' + +# Color used for almost all text +# textColor = '#4bc9ff' + +# Font family for all text in the app, except code blocks +# Accepted values (serif | sans serif | monospace) +# Default: "sans serif" +# font = "sans serif" \ No newline at end of file diff --git a/README.md b/README.md index 8385832fab599d9c95c4f72509c4e9ab212e63e5..29fb8da7b13aa98165cfc881994252300dd0f575 100644 --- a/README.md +++ b/README.md @@ -1,13 +1,113 @@ --- -title: Mhnfs -emoji: πŸš€ -colorFrom: yellow -colorTo: purple +title: MHNfs +emoji: πŸ”¬ +short_description: Activity prediction for low-data scenarios +colorFrom: gray +colorTo: gray sdk: streamlit -sdk_version: 1.32.2 +sdk_version: 1.29.0 app_file: app.py -pinned: false -license: gpl-3.0 +pinned: true --- -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference +# Activity Predictions with MHNfs for low-data scenarios + +## βš™οΈ Under the hood +
+ The predictive model (MHNfs) used in this application was specifically designed and + trained for low-data scenarios. The model predicts whether a molecule is active or + inactive. The predicted activity value is a continuous value between 0 and 1, and, + similar to a probability, the higher/lower the value, the more confident the model + is that the molecule is active/inactive.
+
+ The model was trained on the FS-Mol dataset which + includes 5120 tasks (roughly 5000 tasks were used for training, rest for evaluation). + The training tasks are listed here: + https://github.com/microsoft/FS-Mol/tree/main/datasets/targets. +
+ +## 🎯 About few-shot learning and the model MHNfs +
+ Few-shot learning is a machine learning sub-field which aims to provide + predictive models for scenarios in which only little data is known/available.
+
+ MHNfs is a few-shot learning model which is specifically designed for drug + discovery applications. It is built to use the input prompts in a way such that + the provided available knowledge, i.e. the known active and inactive molecules, + functions as context to predict the activity of the new requested molecules. + Precisely, the provided active and inactive molecules are associated with a + large set of general molecules - called context molecules - to enrich the + provided information and to remove spurious correlations arising from the + decoration of molecules. This is analogous to a Large Language Model which would + not only use the provided information in the current prompt as context but would + also have access to way more information, e.g., a prompting history. +
+ +## πŸ’» Run the prediction pipeline locally for larger screening chunks + +### Get started: +```bash +# Copied from hugging face +# Make sure you have git-lfs installed (https://git-lfs.com) +git lfs install + +# Clone repo +git clone https://huggingface.co/spaces/tschouis/mhnfs + +# Alternatively, if you want to clone without large files +GIT_LFS_SKIP_SMUDGE=1 git clone https://huggingface.co/spaces/tschouis/mhnfs +``` + +### Install requirements +```bash +pip install -r requirements.txt +``` +Notably, this command was tested inside a conda environment with python 3.7. + +### Run the prediction pipeline: +For your screening, load the model, i.e. the **Activity Predictor** into your python file or notebook and simply run it: +```python +from src.prediction_pipeline load ActivityPredictor + +# Define inputs +query_smiles = ["C1CCCCC1", "C1CCCCC1", "C1CCCCC1", "C1CCCCC1"] # Replace with your data +support_actives_smiles = ["C1CCCCC1", "C1CCCCC1"] # Replace with your data +support_inactives_smiles = ["C1CCCCC1", "C1CCCCC1"] # Replace with your data + +# Make predictions +predictions = predictor.predict(query_smiles, support_actives_smiles support_inactives_smiles) +``` + +* Provide molecules in SMILES notation. +* Make sure that the inputs to the Activity Predictor are either comma separated lists, or flattened numpy arrays, or pandas DataFrames. In the latter case, there should be a "smiles" column (both upper and lower case "SMILES" are accepted). All other columns are ignored. + + + +### Run the app locally with streamlib: +```bash +# Navigate into root directory of this project +cd .../whatever_your_dir_name_is/ # Replace with your path + +# Run streamlit app +python -m streamlit run +``` + + +## πŸ€— Hugging face app +Explore our hugging-face app here: + +## πŸ“š Cite us + +``` +@inproceedings{ + schimunek2023contextenriched, + title={Context-enriched molecule representations improve few-shot drug discovery}, + author={Johannes Schimunek and Philipp Seidl and Lukas Friedrich and Daniel Kuhn and Friedrich Rippmann and Sepp Hochreiter and GΓΌnter Klambauer}, + booktitle={The Eleventh International Conference on Learning Representations}, + year={2023}, + url={https://openreview.net/forum?id=XrMWUuEevr} +} +``` + + diff --git a/app.py b/app.py new file mode 100644 index 0000000000000000000000000000000000000000..b9a33518d3d236f90b5e8aa6d906ff4cdc8cc557 --- /dev/null +++ b/app.py @@ -0,0 +1,65 @@ +""" +This script runs the streamlit app for MHNfs + +MHNfs: Few-shot method for drug discovery activity predictions + (https://openreview.net/pdf?id=XrMWUuEevr) +""" + +# -------------------------------------------------------------------------------------- +# Imports +import streamlit as st + +from src.app.layout import LayoutMaker +from src.app.prediction_utils import (create_prediction_df, + create_molecule_grid_plot) +from src.prediction_pipeline import ActivityPredictor + +# -------------------------------------------------------------------------------------- +# Functions +class App(): + def __init__(self): + # Set page configration to wide + st.set_page_config(layout="wide", page_title="MHNfs", page_icon="πŸ”¬") + + # Layout maker + self.layoutMaker = LayoutMaker() + + # Load mhnfs model + self.predictor = ActivityPredictor() + + def define_layout(self): + + # Define Sidebar width + css = ''' + + ''' + st.markdown(css, unsafe_allow_html=True) + + # Sidebar + self.inputs, self.buttons = self.layoutMaker.make_sidebar() + + # Main page + # - header + self.layoutMaker.make_header() + + # - main body + self.layoutMaker.make_main_content_area(self.predictor, + self.inputs, + self.buttons, + create_prediction_df, + create_molecule_grid_plot) + +def run_app(): + app = App() + app.define_layout() + + +# -------------------------------------------------------------------------------------- +# Run script +if __name__ == "__main__": + run_app() diff --git a/assets/data_preprocessing_objects/ecdfs.pkl b/assets/data_preprocessing_objects/ecdfs.pkl new file mode 100644 index 0000000000000000000000000000000000000000..7fbab090f3b42d53c49654def367089b26477d68 --- /dev/null +++ b/assets/data_preprocessing_objects/ecdfs.pkl @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eeec12688fd9e0bb0bbd68d5203e2fb46c45d30a07417f0883adbfc133d48e9f +size 520417347 diff --git a/assets/data_preprocessing_objects/scaler_fitted.pkl b/assets/data_preprocessing_objects/scaler_fitted.pkl new file mode 100755 index 0000000000000000000000000000000000000000..0661f6a057e0debdcbc0f9edcd9d1f802ac46edd --- /dev/null +++ b/assets/data_preprocessing_objects/scaler_fitted.pkl @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4538c1c1d9b5b50d29a14c14134f66a563c3a0f4022ce77b8eb2959c3eff51ea +size 54501 diff --git a/assets/example_csv/.~lock.known_inactive_molecules.csv# b/assets/example_csv/.~lock.known_inactive_molecules.csv# new file mode 100644 index 0000000000000000000000000000000000000000..6aac86237cd3e80015c7e16f5769a5def850e413 --- /dev/null +++ b/assets/example_csv/.~lock.known_inactive_molecules.csv# @@ -0,0 +1 @@ +,johannes,Latitude-5501,02.01.2024 15:57,file:///home/johannes/.config/libreoffice/4; \ No newline at end of file diff --git a/assets/example_csv/known_active_molecules.csv b/assets/example_csv/known_active_molecules.csv new file mode 100644 index 0000000000000000000000000000000000000000..907303100b4fa831a5adb782eb0ebbd9fe64826c --- /dev/null +++ b/assets/example_csv/known_active_molecules.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bc98c05246b42d84c6833d191efa32c7c6473d76c5f2719c8ff3310cfe22df04 +size 353 diff --git a/assets/example_csv/known_inactive_molecules.csv b/assets/example_csv/known_inactive_molecules.csv new file mode 100644 index 0000000000000000000000000000000000000000..2861e2b837c19d703a459c11898a8bcf6a069fe1 --- /dev/null +++ b/assets/example_csv/known_inactive_molecules.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a6e183c33b7445ae0c00bea4a7cdae52bfce14da2829f6827e20dda162df23af +size 363 diff --git a/assets/example_csv/molecules_for_prediction.csv b/assets/example_csv/molecules_for_prediction.csv new file mode 100644 index 0000000000000000000000000000000000000000..46f476e8b149a54d7ba5048930d3ded4faf38b88 --- /dev/null +++ b/assets/example_csv/molecules_for_prediction.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:497adfdbd026c7ab7d1564b685a246fcb7eb6eabb2442918862b31ccd0b32369 +size 460 diff --git a/assets/example_csv/predictions/nottrustworthy_example.csv b/assets/example_csv/predictions/nottrustworthy_example.csv new file mode 100644 index 0000000000000000000000000000000000000000..18bbee0dbc0ff12ccb73b4e749bf62c22f2c21a9 --- /dev/null +++ b/assets/example_csv/predictions/nottrustworthy_example.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f3f8b5e017175b8d62982b1fc4138a4348f51b6a0469c32df991f5d2576a679d +size 588 diff --git a/assets/example_csv/predictions/nottrustworthy_example.png b/assets/example_csv/predictions/nottrustworthy_example.png new file mode 100644 index 0000000000000000000000000000000000000000..0f9ab8ff9fa7e16f3cdbfcca74fa0049e52a1194 --- /dev/null +++ b/assets/example_csv/predictions/nottrustworthy_example.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ae7aff2e2cd2e68bdcb4a5563be38c13d7780453443657b36f01333ab57a949c +size 25505 diff --git a/assets/example_csv/predictions/trustworthy_example.csv b/assets/example_csv/predictions/trustworthy_example.csv new file mode 100644 index 0000000000000000000000000000000000000000..1ebd92bc23042b661efe278566a608ab914913a3 --- /dev/null +++ b/assets/example_csv/predictions/trustworthy_example.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3517bcef4a9998975b031d1b4f2b4aa29679669079100230f84e27bc06f80c02 +size 889 diff --git a/assets/example_csv/predictions/trustworthy_example.png b/assets/example_csv/predictions/trustworthy_example.png new file mode 100644 index 0000000000000000000000000000000000000000..d2709d25f963f96ef45b994ff2b7ab35a5b5c887 --- /dev/null +++ b/assets/example_csv/predictions/trustworthy_example.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:df2a73cdf527546e8b078cb45618b4554a77f11fdd48367ef25939e0a6a2b518 +size 28331 diff --git a/assets/header.png b/assets/header.png new file mode 100644 index 0000000000000000000000000000000000000000..c5c71fbddd84d37cae9f0f6d62becfd7a47bea9e --- /dev/null +++ b/assets/header.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1d355c5fc158281371a09759584110e611c810d2442e8aad30551998aa728f0a +size 122706 diff --git a/assets/logo.png b/assets/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..a306190a2f0ac4f404745bf23609cade08260287 --- /dev/null +++ b/assets/logo.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:505cc795dcaac622e2af6bf2ed118d7ab28d3eab27fd421755844c042ed7646a +size 40875 diff --git a/assets/mhnfs_data/cfg.yaml b/assets/mhnfs_data/cfg.yaml new file mode 100644 index 0000000000000000000000000000000000000000..20686869fab8fcae751e6349a348a7df5066e284 --- /dev/null +++ b/assets/mhnfs_data/cfg.yaml @@ -0,0 +1,42 @@ +model: + encoder: + activation: selu + input_dim: 2248 + number_hidden_layers: 0 + number_hidden_neurons: 1024 + regularization: + input_dropout: 0.1 + dropout: 0.5 + layerNormBlock: + affine: False + usage: True + transformer: + activity_embedding_dim: 64 + number_heads: 8 + dim_forward: 567 + dropout: 0.5 + num_layers: 1 + ss_dropout: 0.1 + hopfield: + dim_QK: 512 + heads: 8 + beta: 0.044194173824159216 + dropout: 0.5 + prediction_scaling: 0.044194173824159216 + associationSpace_dim: 1024 + similarityModule: + type: cosineSim + l2Norm: False + scaling: 1/N + training: + optimizer: AdamW + batch_size: 512 + lr: 0.0001 + weightDecay: 0.0 + lrScheduler: + usage: True + context: + ratio_training_molecules: 0.05 +system: + ressources: + device: cpu diff --git a/assets/mhnfs_data/full_context_set.npy b/assets/mhnfs_data/full_context_set.npy new file mode 100755 index 0000000000000000000000000000000000000000..d15fb13e1c80dd060fcbf7d7e580c609adef9140 --- /dev/null +++ b/assets/mhnfs_data/full_context_set.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1ed40b8d9cc39859772af0d32ed69c7f2467b9235f83f37ff42611bc22828e52 +size 3899416896 diff --git a/assets/mhnfs_data/mhnfs_checkpoint.ckpt b/assets/mhnfs_data/mhnfs_checkpoint.ckpt new file mode 100644 index 0000000000000000000000000000000000000000..89fb2781a24f2398d093d3fdc743995ef399235b --- /dev/null +++ b/assets/mhnfs_data/mhnfs_checkpoint.ckpt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:25fcfdb7c6355b7781edaefc9ec56351f012356b17e4087f72b0a78c6d8e2300 +size 313588174 diff --git a/assets/mhnfs_overview.png b/assets/mhnfs_overview.png new file mode 100644 index 0000000000000000000000000000000000000000..d56d2c0c46fbe515685c4ca805cce81e6d215541 --- /dev/null +++ b/assets/mhnfs_overview.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f89731eaf842e6018b4153d60193ea57442fb5933774135a653d4b70ac48afe2 +size 466946 diff --git a/assets/test_reference_data/ecfps.npy b/assets/test_reference_data/ecfps.npy new file mode 100644 index 0000000000000000000000000000000000000000..e329a21664a03188ea6cf18774762266c493d8a5 --- /dev/null +++ b/assets/test_reference_data/ecfps.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:056a628c308cf69e647f2c86090f8f93c2aedcd719845f57f11e653ce6d9d70b +size 24704 diff --git a/assets/test_reference_data/model_input_query.pt b/assets/test_reference_data/model_input_query.pt new file mode 100644 index 0000000000000000000000000000000000000000..513ad54892b7e5e6bf4cdec17ddd0dfbdd449352 --- /dev/null +++ b/assets/test_reference_data/model_input_query.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e889558eb3300355b5c6ea0ce1518bb949141238b8d26b257ec1bd496baeda18 +size 36715 diff --git a/assets/test_reference_data/model_input_support_actives.pt b/assets/test_reference_data/model_input_support_actives.pt new file mode 100644 index 0000000000000000000000000000000000000000..17bed4d70ffe83df73704148a9331b53388d0a11 --- /dev/null +++ b/assets/test_reference_data/model_input_support_actives.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e5e55816e09597d267fb91297a56f58a4f4420ed32340650be4c1dd37efe1656 +size 72683 diff --git a/assets/test_reference_data/model_input_support_inactives.pt b/assets/test_reference_data/model_input_support_inactives.pt new file mode 100644 index 0000000000000000000000000000000000000000..b59ba16f1a2537f88a66cdf633db24cbf369da45 --- /dev/null +++ b/assets/test_reference_data/model_input_support_inactives.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e62e8b18da47d1c9475c18bc2ad50a563f10f0d0bced247d848e453321a13ced +size 72683 diff --git a/assets/test_reference_data/model_predictions.pt b/assets/test_reference_data/model_predictions.pt new file mode 100644 index 0000000000000000000000000000000000000000..fd8e6d8a51d47afcf6f0de8858dafc30d6ce899d --- /dev/null +++ b/assets/test_reference_data/model_predictions.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a7e63ad2ad9b664e3301479427f8d5cf005c979d7cc9e4bce033f18640eb4df0 +size 747 diff --git a/assets/test_reference_data/preprocessed_features.npy b/assets/test_reference_data/preprocessed_features.npy new file mode 100644 index 0000000000000000000000000000000000000000..f1dc33ac3aa07b8821a65da45e4003495ea31144 --- /dev/null +++ b/assets/test_reference_data/preprocessed_features.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1e97dc7eb85509c6b07156292b57a1bee4eaa8d60fbdb40c7e2e5738c8c6a460 +size 54080 diff --git a/assets/test_reference_data/rdkit_descr_quantils.npy b/assets/test_reference_data/rdkit_descr_quantils.npy new file mode 100644 index 0000000000000000000000000000000000000000..b50a6ef8039d1f6438cc59d82b17cd2590605de9 --- /dev/null +++ b/assets/test_reference_data/rdkit_descr_quantils.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cde4d2fd8658cdbcd55e75f14cb360cfa1b239f99d281c1f7296449636e94c6a +size 4928 diff --git a/assets/test_reference_data/rdkit_descrs.npy b/assets/test_reference_data/rdkit_descrs.npy new file mode 100644 index 0000000000000000000000000000000000000000..ece95389f506b58a7036eb0a269e1657e980cad4 --- /dev/null +++ b/assets/test_reference_data/rdkit_descrs.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d1b06153004b3f2ac02f0cefd16b0f17225527bbf53f8efe6e43c035b3d21690 +size 2528 diff --git a/assets/test_reference_data/smiles.pkl b/assets/test_reference_data/smiles.pkl new file mode 100644 index 0000000000000000000000000000000000000000..77e90c8a544d78a2023574e841bf0d81b832bf05 --- /dev/null +++ b/assets/test_reference_data/smiles.pkl @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e0168a7aaa6f7f3eca611a42d70782bae9eb970194449320d37b64f5a8c264f9 +size 179 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..496ae46a66a97f77254f8e181c48ba09ec723c2e --- /dev/null +++ b/requirements.txt @@ -0,0 +1,10 @@ +rdkit==2022.3.3 +pytorch-lightning==1.6.1 +torch==1.13.1 +numpy==1.21.5 +pandas==1.3.5 +omegaconf==2.1.2 +mols2grid==1.1.1 +scikit-learn +statsmodels==0.13.5 +streamlit \ No newline at end of file diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/src/__pycache__/__init__.cpython-37.pyc b/src/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..16665065e80e1a7344af4b094b1df63ace5189d8 Binary files /dev/null and b/src/__pycache__/__init__.cpython-37.pyc differ diff --git a/src/__pycache__/prediction_pipeline.cpython-37.pyc b/src/__pycache__/prediction_pipeline.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cc9e266ea5f1b7b0ebca3f8e977514f3c4c89f4f Binary files /dev/null and b/src/__pycache__/prediction_pipeline.cpython-37.pyc differ diff --git a/src/app/__pycache__/constants.cpython-37.pyc b/src/app/__pycache__/constants.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..66b6c4afa19390d172e3ff5ed5baafd3159db677 Binary files /dev/null and b/src/app/__pycache__/constants.cpython-37.pyc differ diff --git a/src/app/__pycache__/layout.cpython-37.pyc b/src/app/__pycache__/layout.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cddf59c07ff5cce1e03d8b4fd9c8ca1e5ea6391f Binary files /dev/null and b/src/app/__pycache__/layout.cpython-37.pyc differ diff --git a/src/app/__pycache__/prediction_utils.cpython-37.pyc b/src/app/__pycache__/prediction_utils.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2a5351001c478b42f20803d341b223ea166c78e7 Binary files /dev/null and b/src/app/__pycache__/prediction_utils.cpython-37.pyc differ diff --git a/src/app/constants.py b/src/app/constants.py new file mode 100644 index 0000000000000000000000000000000000000000..bd6844863797c2e005833589612792853fec2ccc --- /dev/null +++ b/src/app/constants.py @@ -0,0 +1,269 @@ +""" +This file includes all the constant content shown in the app +""" + +# -------------------------------------------------------------------------------------- + +summary_text = (''' + This application allows you to make **activity predictions** for + **biological targets** for which you have only a **little knowledge** in + terms of known active and inactive molecules. + + **Provide** via the sidebar:\n + - some active molecules, + - some inactive molecules, and + - molecules you want to predict. + + Hit **Predict** and explore the predictions! + + For more **information** about the **model** and **how to provide the + molecules**, please visit the **Additional Information** tab. + ''') + +mhnfs_text =(''' +
+ MHNfs is a few-shot drug discovery model which consists of a context + module , a cross-attention module , and a similarity module + as described here: https://openreview.net/pdf?id=XrMWUuEevr. +
+
+ +
+ Abstract. A central task in computational drug discovery is to construct + models from known active molecules to find further promising molecules for + subsequent screening. However, typically only very few active molecules are + known. Therefore, few-shot learning methods have the potential to improve the + effectiveness of this critical phase of the drug discovery process. We introduce + a new method for few-shot drug discovery. Its main idea is to enrich a molecule + representation by knowledge about known context or reference molecules. Our + novel concept for molecule representation enrichment is to associate molecules + from both the support set and the query set with a large set of reference + (context) molecules through a modern Hopfield network. Intuitively, this + enrichment step is analogous to a human expert who would associate a given + molecule with familiar molecules whose properties are known. The enrichment step + reinforces and amplifies the covariance structure of the data, while + simultaneously removing spurious correlations arising from the decoration of + molecules. Our approach is compared with other few-shot methods for drug + discovery on the FS-Mol benchmark dataset. On FS-Mol, our approach outperforms + all compared methods and therefore sets a new state-of-the art for few-shot + learning in drug discovery. An ablation study shows that the enrichment step of + our method is the key to improve the predictive quality. In a domain shift + experiment, we further demonstrate the robustness of our method. Code is + available at https://github.com/ml-jku/MHNfs. +
+
+
+ ''') + +citation_text = ''' + ### + @inproceedings{ + schimunek2023contextenriched, + title={Context-enriched molecule representations improve few-shot drug discovery}, + author={Johannes Schimunek and Philipp Seidl and Lukas Friedrich and Daniel Kuhn and Friedrich Rippmann and Sepp Hochreiter and GΓΌnter + Klambauer}, + booktitle={The Eleventh International Conference on Learning Representations}, + year={2023}, + url={https://openreview.net/forum?id=XrMWUuEevr} + } + ''' + +few_shot_learning_text = ( + ''' +
+ Few-shot learning is a machine learning sub-field which aims to provide + predictive models for scenarios in which only little data is known/available.
+
+ + MHNfs is a few-shot learning model which is specifically designed for drug + discovery applications. It is built to use the input prompts in a way such that + the provided available knowledge, i.e. the known active and inactive molecules, + functions as context to predict the activity of the new requested molecules. + Precisely, the provided active and inactive molecules are associated with a + large set of general molecules - called context molecules - to enrich the + provided information and to remove spurious correlations arising from the + decoration of molecules. This is analogous to a Large Language Model which would + not only use the provided information in the current prompt as context but would + also have access to way more information, e.g., a prompting history. +
+ ''') + +under_the_hood_text = (''' +
+ The predictive model (MHNfs) used in this application was specifically designed and + trained for low-data scenarios. The model predicts whether a molecule is active or + inactive. The predicted activity value is a continuous value between 0 and 1, and, + similar to a probability, the higher/lower the value, the more confident the model + is that the molecule is active/inactive. + + The model was trained on the FS-Mol dataset which + includes 5120 tasks (roughly 5000 tasks were used for training, rest for evaluation). + The training tasks are listed here: + https://github.com/microsoft/FS-Mol/tree/main/datasets/targets. +
+ ''') + +usage_text = (''' +
+ To use this application, you need to provide 3 different sets of molecules: +
    +
  1. active molecules: set of known active molecules,
    2. +
  2. inactive molecules: set of known inactive molecules, and
    3. +
  3. molecules to predict: set of molecules you want to predict.
    4. +
+ These three sets can be provided via the sidebar. The sidebar also includes two + buttons predict and reset to run the prediction pipeline and to + reset it. +
+ ''') + +data_text = (''' +
+
+ + + + + + + ''') + +trust_text = (''' +
+ Just like all other machine learning models, the performance of MHNfs varies + and, generally, the model works well if the task is somehow close to tasks which + were used to train the model. The model performance for very different tasks is + unclear and might be poor.
+
+ + MHNfs was trained on the FS-Mol dataset which includes 5120 tasks (roughly + 5000 tasks were used for training, rest for evaluation). The training tasks are + listed here: https://github.com/microsoft/FS-Mol/tree/main/datasets/targets. +
+ ''') + +example_trustworthy_text = (''' +
+ Since the predicitve model has seen a lot of kinase related tasks during training, + the model is expected to generally perform well on kinase targets. For this example, + we use data for the target + CHEMBL5914. Notably, this specific kinase has not been seen + during training. Precisely, we use the available inhibition data while molecules + with an inhibition value greater (smaller) than 50 % are considered as active + (inactive).
+ + From the known available data, we have selected 4 "known" active molecules, + 8 "known" inactive molecules, and 11 molecules to predict.
+ + Molecules to predict: +
+ FC(F)(F)c1ccc(Cl)cc1CN1CCNc2ncc(-c3ccnc(N4CCNCC4)c3)cc21,
+ CS(=O)(=O)c1ccc(-n2nc(-c3cnc4[nH]ccc4c3)c3c(N)ncnc32)cc1,
+ O=C(Nc1ccccc1Cl)c1cnc2ccc(C3CCNCC3)cn12.O=C(O)C(=O)O,
+ CC(C)n1cnc2c(Nc3cccc(Cl)c3)nc(N[C@@H]3CCCC[C@@H]3N)nc21,
+ Nc1ncc(-c2ccc(NS(=O)(=O)C3CC3)cc2F)cc1-c1ccc2c(c1)CCNC2=O,
+ CCN1CCN(Cc2ccc(NC(=O)c3ccc(C)c(C#Cc4cccnc4)c3)cc2C(F)(F)F)CC1,
+ CN1CCN(c2ccc(-c3cnc4c(c3)N(Cc3cc(Cl)ccc3C(F)(F)F)CCN4)cn2)CC1,
+ CC(C)n1nc(-c2cnc(N)c(OC(F)(F)F)c2)cc1[C@H]1[C@@H]2CN(C3COC3)C[C@@H]21,
+ Nc1ncc(-c2cc([C@H]3[C@@H]4CN(C5COC5)C[C@@H]43)n(CC3CC3)n2)cc1C(F)(F)F,
+ Cc1ccc(NC(=O)C2(C(=O)Nc3ccc(Nc4ncc(F)c(-c5cc(F)c6nc(C)n(C(C)C)c6c5)n4)cc3)CC2)cc1,
+ C[C@@H](Oc1cc(-c2cnn(C3CCNCC3)c2)cnc1N)c1c(Cl)ccc(F)c1Cl +

+ + Known active molecules: +
+ CC(=O)N1CCN(c2cc(-c3cnc4c(c3)N(Cc3cc(Cl)ccc3C(F)(F)F)CCN4)ccn2)CC1,
+ CS(=O)(=O)c1cccc(Nc2nccc(-c3sc(N4CCOCC4)nc3-c3cccc(NS(=O)(=O)c4c(F)cccc4F)c3)n2)c1,
+ COc1cnccc1Nc1nc(-c2nn(Cc3c(F)cc(OCCO)cc3F)c3ccccc23)ncc1OC,
+ CN(C)[C@@H]1CC[C@@]2(C)[C@@H](CC[C@@H]3[C@@H]2CC[C@]2(C)C(c4cccc5cnccc45)=CC[C@@H]32)C1
+

+ + Known inactive molecules: +
+ c1cc(-c2c[nH]c3cnccc23)ccn1,
+ COc1ccc2c3ccnc(C(F)(F)F)c3n(CCCCN)c2c1,
+ CNS(=O)(=O)c1ccc(N(C)C)c(Nc2ncnc3cc(OC)c(OC)cc23)c1,
+ CN(C1CC1)S(=O)(=O)c1ccc(-c2cnc(N)c(-c3ccc4c(c3)CCNC4=O)c2)c(F)c1,
+ CCN1CCN(Cc2ccc(NC(=O)c3ccc(C)c(C#Cc4cnc5[nH]ccc5c4)c3)cc2C(F)(F)F)CC1,
+ CC(C)n1cc(-c2cc(-c3ccc(CN4CCOCC4)cc3)cnc2N)nn1,
+ CC(C)(O)[C@H](F)CN1Cc2cc(NC(=O)c3cnn4cccnc34)c(N3CCOCC3)cc2C1=O,
+ [2H]C([2H])([2H])C1(C([2H])([2H])[2H])Cn2nc(-c3ccc(F)cn3)c(-c3ccnc4[nH]ncc34)c2CO1
+

+ + Predictions:
+ +
+ ''') + +example_nottrustworthy_text = (''' +
+ For this example, we use data for the auxiliary transport protein target + CHEMBL5738. Precisely, we use the available Ki data + while molecules with a pCHEMBL value greater (smaller) than 5 are considered + as active (inactive).
+ + From the known available data, we have selected 4 "known" active molecules, + 3 "known" inactive molecules, and 10 molecules to predict.
+ + Molecules to predict: +
+ CC(C(=O)O)c1ccc(-c2ccccc2)c(F)c1,
+ O=S(=O)(O)Oc1cccc2cccc(Nc3ccccc3)c12,
+ CCCCCCCC/C=C\CCCCCCCC(=O)O,
+ C[C@]12C=CC(=O)C=C1CC[C@@H]1[C@@H]2[C@@H](O)C[C@@]2(C)[C@H]1CC[C@]2(O)C(=O)CO,
+ CCOC(=O)C(C)(C)Oc1ccc(Cl)cc1,
+ Cc1ccc(Cl)c(Nc2ccccc2C(=O)O)c1Cl,
+ O=C(O)Cc1ccccc1Nc1c(Cl)cccc1Cl,
+ CC(C)(Oc1ccc(CCNC(=O)c2ccc(Cl)cc2)cc1)C(=O)O,
+ O=C(c1ccccc1)c1ccc2n1CCC2C(=O)O,
+ CC(C)OC(=O)C(C)(C)Oc1ccc(C(=O)c2ccc(Cl)cc2)cc1
+

+ + Known active molecules: +
+ CC(C(=O)O)c1ccc(N2Cc3ccccc3C2=O)cc1,
+ CN1C(=O)CN=C(c2ccccc2)c2cc(Cl)ccc21,
+ CC(C)(Oc1ccc(C(=O)c2ccc(Cl)cc2)cc1)C(=O)O,
+ CC(=O)[C@H]1CC[C@H]2[C@@H]3CCC4=CC(=O)CC[C@]4(C)[C@H]3CC[C@]12C + +

+ + Known inactive molecules: +
+ CC(C)Cc1ccc(C(C)C(=O)O)cc1,
+ O=C1Nc2ccc(Cl)cc2C(c2ccccc2Cl)=NC1O,
+ C[C@@H]1C[C@H]2[C@@H]3CCC4=CC(=O)C=C[C@]4(C)[C@@]3(F)[C@@H](O)C[C@]2(C)[C@@]1(O)C(=O)CO +

+ + Predictions:
+ +
+ ''') \ No newline at end of file diff --git a/src/app/layout.py b/src/app/layout.py new file mode 100644 index 0000000000000000000000000000000000000000..61fe081e303a9d9b9033d02ecf172cc2e190295a --- /dev/null +++ b/src/app/layout.py @@ -0,0 +1,439 @@ +""" +This file defines the layout of the app including the header, sidebar, and tabs in the +main content area. +""" + +#--------------------------------------------------------------------------------------- +# Imports +import streamlit as st +import streamlit.components.v1 as components +from PIL import Image +import pandas as pd +import yaml + +from src.data_preprocessing.create_descriptors import handle_inputs +from src.app.constants import (summary_text, + mhnfs_text, + citation_text, + few_shot_learning_text, + under_the_hood_text, + usage_text, + data_text, + trust_text, + example_trustworthy_text, + example_nottrustworthy_text) +#--------------------------------------------------------------------------------------- +# Global variables +MAX_INPUT_LENGTH = 20 + +#--------------------------------------------------------------------------------------- +# Functions + +class LayoutMaker(): + """ + This class includes all the design choices regarding the layout of the app. This + class can be used in the main file to define header, sidebar, and main content area. + """ + + def __init__(self): + + # Initialize the inputs dictionary + self.inputs = dict() # this will be the storage for query and support set inputs + self.inputs_lists = dict() + + # Initialize prediction storage + self.predictions = None + + # Buttons + self.buttons = dict() # this will be the storage for buttons + + # content + self.summary_text = summary_text + self.mhnfs_text = mhnfs_text + self.citation_text = citation_text + self.few_shot_learning_text = few_shot_learning_text + self.under_the_hood_text = under_the_hood_text + self.usage_text = usage_text + self.data_text = data_text + self.trust_text = trust_text + self.example_trustworthy_text = example_trustworthy_text + self.example_nottrustworthy_text = example_nottrustworthy_text + + self.df_trustworthy = pd.read_csv("./assets/example_csv/predictions/" + "trustworthy_example.csv") + self.df_nottrustworthy = pd.read_csv("./assets/example_csv/predictions/" + "nottrustworthy_example.csv") + + self.max_input_length = MAX_INPUT_LENGTH + + def make_sidebar(self): + """ + This function defines the sidebar of the app. It includes the logo, query box, + support set boxes, and predict buttons. + It returns the stored inputs (for query and support set) and the buttons which + allow for user interactions. + """ + with st.sidebar: + # Logo + logo = Image.open("./assets/logo.png") + st.image(logo) + st.divider() + + # Query box + self._make_query_box() + st.divider() + + # Support set actives box + self._make_active_support_set_box() + st.divider() + + # Support set inactives box + self._make_inactive_support_set_box() + st.divider() + + # Predict buttons + self.buttons["predict"] = st.button("Predict...") + self.buttons["reset"] = st.button("Reset") + + return self.inputs, self.buttons + + def make_header(self): + """ + This function defines the header of the app. It consists only of a png image + in which the title and an overview is given. + """ + + header_container = st.container() + with header_container: + header = Image.open("./assets/header.png") + st.image(header) + + def make_main_content_area(self, + predictor, + inputs, + buttons, + create_prediction_df: callable, + create_molecule_grid_plot: callable): + + + tab1, tab2, tab3, tab4 = st.tabs(["Predictions", + "Paper / Cite", + "Additional Information", + "Examples"]) + + # Results tab + with tab1: + self._fill_tab_with_results_content(predictor, + inputs, + buttons, + create_prediction_df, + create_molecule_grid_plot) + + # Paper tab + with tab2: + self._fill_paper_and_citation_tab() + + # More explanations tab + with tab3: + self._fill_more_explanations_tab() + + with tab4: + self._fill_examples_tab() + + def _make_query_box(self): + """ + This function + a) defines the query box and + b) stores the query input in the inputs dictionary + """ + + st.info(":blue[Molecules to predict:]", icon="❓") + + query_container = st.container() + with query_container: + input_choice = st.radio( + "Input your data in SMILES notation via:", ["Text box", "CSV upload"] + ) + if input_choice == "Text box": + query_input = st.text_area( + label="SMILES input for query molecules", + label_visibility="hidden", + key="query_textbox", + value="CC(C)Sc1nc(C(C)(C)C)nc(OCC(=O)O)c1C#N, " + "Cc1nc(NCc2cccnc2)cc(=O)n1CC(=O)O", + ) + elif input_choice == "CSV upload": + query_file = st.file_uploader(key="query_csv", + label = "CSV upload for query mols", + label_visibility="hidden") + if query_file is not None: + query_input = pd.read_csv(query_file) + else: query_input = None + + # Update storage + self.inputs["query"] = query_input + + def _make_active_support_set_box(self): + """ + This function + a) defines the active support set box and + b) stores the active support set input in the inputs dictionary + """ + + st.info(":blue[Known active molecules:]", icon="✨") + active_container = st.container() + with active_container: + active_input_choice = st.radio( + "Input your data in SMILES notation via:", + ["Text box", "CSV upload"], + key="active_input_choice", + ) + + if active_input_choice == "Text box": + support_active_input = st.text_area( + label="SMILES input for active support set molecules", + label_visibility="hidden", + key="active_textbox", + value="Cc1nc(NCC2CCCCC2)c(C#N)c(=O)n1CC(=O)O, " + "CSc1nc(C(C)C)nc(OCC(=O)O)c1C#N" + ) + elif active_input_choice == "CSV upload": + support_active_file = st.file_uploader( + key="support_active_csv", + label = "CSV upload for active support set molecules", + label_visibility="hidden" + ) + if support_active_file is not None: + support_active_input = pd.read_csv(support_active_file) + else: support_active_input = None + + # Update storage + self.inputs["support_active"] = support_active_input + + def _make_inactive_support_set_box(self): + st.info(":blue[Known inactive molecules:]", icon="✨") + inactive_container = st.container() + with inactive_container: + inactive_input_choice = st.radio( + "Input your data in SMILES notation via:", + ["Text box", "CSV upload"], + key="inactive_input_choice", + ) + if inactive_input_choice == "Text box": + support_inactive_input = st.text_area( + label="SMILES input for inactive support set molecules", + label_visibility="hidden", + key="inactive_textbox", + value="CSc1nc(C)nc(OCC(=O)O)c1C#N, " + "CSc1nc(C)n(CC(=O)O)c(=O)c1C#N" + ) + elif inactive_input_choice == "CSV upload": + support_inactive_file = st.file_uploader( + key="support_inactive_csv", + label = "CSV upload for inactive support set molecules", + label_visibility="hidden" + ) + if support_inactive_file is not None: + support_inactive_input = pd.read_csv( + support_inactive_file + ) + else: support_inactive_input = None + + # Update storage + self.inputs["support_inactive"] = support_inactive_input + + def _fill_tab_with_results_content(self, predictor, inputs, buttons, + create_prediction_df, create_molecule_grid_plot): + tab_container = st.container() + with tab_container: + # Info + st.info(":blue[Summary:]", icon="πŸš€") + st.markdown(self.summary_text) + + # Results + st.info(":blue[Results:]",icon="πŸ‘¨β€πŸ’»") + + if buttons['predict']: + + # Check 1: Are all inputs provided? + if (inputs['query'] is None or + inputs['support_active'] is None or + inputs['support_inactive'] is None): + st.error("You didn't provide all necessary inputs.\n\n" + "Please provide all three necessary inputs via the " + "sidebar and hit the predict button again.") + else: + # Check 2: Less than max allowed molecules provided? + max_input_length = 0 + for key, input in inputs.items(): + input_list = handle_inputs(input) + self.inputs_lists[key] = input_list + max_input_length = max(max_input_length, len(input_list)) + + if max_input_length > self.max_input_length: + st.error("You provided too many molecules. The number of " + "molecules for each input is restricted to " + f"{self.max_input_length}.\n\n" + "For larger screenings, we suggest to clone the repo " + "and to run the model locally.") + else: + # Progress bar + progress_bar_text = ("I'm predicting activities. This might " + "need some minutes. Please wait...") + progress_bar = st.progress(50, text=progress_bar_text) + + # Results table + df = self._predict_and_create_results_table(predictor, + inputs, + create_prediction_df) + + progress_bar_text = ("Done. Here are the results:") + progress_bar = progress_bar.progress(100, text=progress_bar_text) + st.dataframe(df, use_container_width=True) + + col1, col2, col3, col4 = st.columns([1,1,1,1]) + # Provide download button for predictions + with col2: + self.buttons["download_results"] = st.download_button( + "Download predictions as CSV", + self._convert_df_to_binary(df), + file_name="predictions.csv", + ) + + # Provide download button for inputs + with col3: + with open("inputs.yml", 'w') as fl: + self.buttons["download_inputs"] = st.download_button( + "Download inputs as YML", + self._convert_to_yml(self.inputs_lists), + file_name="inputs.yml", + ) + st.divider() + + # Results grid + st.info(":blue[Grid plot of the predicted molecules:]", + icon="πŸ“Š") + mol_html_grid = create_molecule_grid_plot(df) + components.html(mol_html_grid, height=1000, scrolling=True) + + elif buttons['reset']: + self._reset() + + def _fill_paper_and_citation_tab(self): + st.info(":blue[**Paper: Context-enriched molecule representations improve " + "few-shot drug discovery**]", icon="πŸ“„") + st.markdown(self.mhnfs_text, unsafe_allow_html=True) + st.image("./assets/mhnfs_overview.png") + st.write("") + st.write("") + st.write("") + st.info(":blue[**Cite us / BibTex**]", icon="πŸ“š") + st.markdown(self.citation_text) + + def _fill_more_explanations_tab(self): + st.info(":blue[**Under the hood**]", icon="βš™οΈ") + st.markdown(self.under_the_hood_text, unsafe_allow_html=True) + st.write("") + st.write("") + + st.info(":blue[**About few-shot learning and the model MHNfs**]", icon="🎯") + st.markdown(self.few_shot_learning_text, unsafe_allow_html=True) + st.write("") + st.write("") + + st.info(":blue[**Usage**]", icon="πŸŽ›οΈ") + st.markdown(self.usage_text, unsafe_allow_html=True) + st.write("") + st.write("") + + st.info(":blue[**How to provide the data**]", icon="πŸ“€") + st.markdown(self.data_text, unsafe_allow_html=True) + st.write("") + st.write("") + + st.info(":blue[**When to trust the predictions**]", icon="πŸ”") + st.markdown(self.trust_text, unsafe_allow_html=True) + + def _fill_examples_tab(self): + st.info(":blue[**Example for trustworthy predictions**]", icon="βœ…") + st.markdown(self.example_trustworthy_text, unsafe_allow_html=True) + st.dataframe(self.df_trustworthy, use_container_width=True) + st.markdown("**Plot: Predictions for active and inactive molecules (model AUC=" + "0.96**)") + prediction_plot_tw = Image.open("./assets/example_csv/predictions/" + "trustworthy_example.png") + st.image(prediction_plot_tw) + st.write("") + st.write("") + + st.info(":blue[**Example for not trustworthy predictions**]", icon="⛔️") + st.markdown(self.example_nottrustworthy_text, unsafe_allow_html=True) + st.dataframe(self.df_nottrustworthy, use_container_width=True) + st.markdown("**Plot: Predictions for active and inactive molecules (model AUC=" + "0.42**)") + prediction_plot_ntw = Image.open("./assets/example_csv/predictions/" + "nottrustworthy_example.png") + st.image(prediction_plot_ntw) + + def _predict_and_create_results_table(self, + predictor, + inputs, + create_prediction_df: callable): + + df = create_prediction_df(predictor, + inputs['query'], + inputs['support_active'], + inputs['support_inactive']) + return df + + def _reset(self): + keys = list(st.session_state.keys()) + for key in keys: + st.session_state.pop(key) + + def _convert_df_to_binary(_self, df): + return df.to_csv(index=False).encode('utf-8') + + def _convert_to_yml(_self, inputs): + return yaml.dump(inputs) + content = """ + # Usage + As soon as you have a few active and inactive molecules for your task, you can + provide them here and make predictions for new molecules. + + ## About few-shot learning and the model MHNfs + **Few-shot learning** is a machine learning sub-field which aims to provide + predictive models for scenarios in which only little data is known/available. + + **MHNfs** is a few-shot learning model which is specifically designed for drug + discovery applications. It is built to use the input prompts in a way such that + the provided available knowledge - i.e. the known active and inactive molecules - + functions as context to predict the activity of the new requested molecules. + Precisely, the provided active and inactive molecules are associated with a + large set of general molecules - called context molecules - to enrich the + provided information and to remove spurious correlations arising from the + decoration of molecules. This is analogous to a Large Language Model which would + not only use the provided information in the current prompt as context but would + also have access to way more information, e.g. a prompting history. + + ## How to provide the data + * Molecules have to be provided in SMILES format. + * You can provide the molecules via the text boxes or via CSV upload. + - Text box: Replace the pseudo input by directly typing your molecules into + the text box. Please separate the molecules by comma. + - CSV upload: Upload a CSV file with the molecules. + * The CSV file should include a smiles column (both upper and lower + case "SMILES" are accepted). + * All other columns will be ignored. + + ## When to trust the predictions + Just like all other machine learning models, the performance of MHNfs varies + and, generally, the model works well if the task is somehow close to tasks which + were used to train the model. The model performance for very different tasks is + unclear and might be poor. + + MHNfs was trained on a the FS-Mol dataset which includes 5120 tasks (Roughly + 5000 tasks were used for training, rest for evaluation). The training tasks are + listed here: https://github.com/microsoft/FS-Mol/tree/main/datasets/targets. + """ + return content \ No newline at end of file diff --git a/src/app/prediction_utils.py b/src/app/prediction_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..37613b9483327ab3ac2b101a2dbab324050e1dd4 --- /dev/null +++ b/src/app/prediction_utils.py @@ -0,0 +1,33 @@ +""" +This module includes all functions which are called from the main app and are needed to +make activity predictions and to output the results. +""" + +#--------------------------------------------------------------------------------------- +# Deendencies +import pandas as pd +import mols2grid +#--------------------------------------------------------------------------------------- +# Define functions + +def create_prediction_df(predictor, query_smiles, support_activces_smiles, + support_inactives_smiles): + """ + This function creates a dataframe with the query molecules and the corresponding + predictions. + """ + # Make predictions + predictions = predictor.predict(query_smiles, support_activces_smiles, + support_inactives_smiles) + + smiles = predictor._return_query_mols_as_list() + + # Create dataframe + prediction_df = pd.DataFrame({"Molecule": smiles, + "Predicted activity": predictions.astype('str')}) + + return prediction_df + +def create_molecule_grid_plot(df, smiles_col="Molecule"): + mol_html_grid = mols2grid.display(df,smiles_col=smiles_col)._repr_html_() + return mol_html_grid \ No newline at end of file diff --git a/src/data_preprocessing/__init__.py b/src/data_preprocessing/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/src/data_preprocessing/__pycache__/__init__.cpython-36.pyc b/src/data_preprocessing/__pycache__/__init__.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0ea3026f90c7b5c8ae0b1a772cbfb3ef5678fbce Binary files /dev/null and b/src/data_preprocessing/__pycache__/__init__.cpython-36.pyc differ diff --git a/src/data_preprocessing/__pycache__/__init__.cpython-37.pyc b/src/data_preprocessing/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fcac0f6f0dd8f2817ee437e9ef28311708500bb6 Binary files /dev/null and b/src/data_preprocessing/__pycache__/__init__.cpython-37.pyc differ diff --git a/src/data_preprocessing/__pycache__/constants.cpython-37.pyc b/src/data_preprocessing/__pycache__/constants.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1f8dba5d790ecb68272c5420afaded6ed2e6a958 Binary files /dev/null and b/src/data_preprocessing/__pycache__/constants.cpython-37.pyc differ diff --git a/src/data_preprocessing/__pycache__/create_descriptors.cpython-36.pyc b/src/data_preprocessing/__pycache__/create_descriptors.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e169defd0f2b9ec7587cae9bcec9aff4afce3a77 Binary files /dev/null and b/src/data_preprocessing/__pycache__/create_descriptors.cpython-36.pyc differ diff --git a/src/data_preprocessing/__pycache__/create_descriptors.cpython-37.pyc b/src/data_preprocessing/__pycache__/create_descriptors.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..295a5c4e106008fc4c0684d43cf3ecc927f0ef56 Binary files /dev/null and b/src/data_preprocessing/__pycache__/create_descriptors.cpython-37.pyc differ diff --git a/src/data_preprocessing/__pycache__/create_model_inputs.cpython-37.pyc b/src/data_preprocessing/__pycache__/create_model_inputs.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3f68b11a09f0b68718b3b033b27010ba1725101d Binary files /dev/null and b/src/data_preprocessing/__pycache__/create_model_inputs.cpython-37.pyc differ diff --git a/src/data_preprocessing/__pycache__/utils.cpython-37.pyc b/src/data_preprocessing/__pycache__/utils.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ce74fef01c85d90bfebc5abc8bfad540e3d57131 Binary files /dev/null and b/src/data_preprocessing/__pycache__/utils.cpython-37.pyc differ diff --git a/src/data_preprocessing/constants.py b/src/data_preprocessing/constants.py new file mode 100644 index 0000000000000000000000000000000000000000..bc0f7cbaf5fd1fb47811bbe489b6487c20bf5d60 --- /dev/null +++ b/src/data_preprocessing/constants.py @@ -0,0 +1,11 @@ +USED_200_DESCR = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,25,26,27,28,29,30, 31,32,33, + 34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56, + 57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79, + 80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101, + 102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118, + 119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135, + 136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152, + 153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169, + 170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186, + 187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203, + 204,205,206,207] diff --git a/src/data_preprocessing/create_descriptors.py b/src/data_preprocessing/create_descriptors.py new file mode 100644 index 0000000000000000000000000000000000000000..fc36d5cb84104e64046d21b3a7c06b9ee069a7b5 --- /dev/null +++ b/src/data_preprocessing/create_descriptors.py @@ -0,0 +1,148 @@ +""" +This file includes all necessary code to preprocess molecules (assumed to be in SMILES +format) and create descriptors which can be fed into MHNfs. +""" + +#--------------------------------------------------------------------------------------- +# Dependencies +import numpy as np +import pandas as pd +import pickle +from typing import List +from rdkit import Chem, DataStructs +from rdkit.Chem.rdchem import Mol +from rdkit.Chem import Descriptors, rdFingerprintGenerator + +from src.data_preprocessing.constants import USED_200_DESCR +from src.data_preprocessing.utils import Standardizer + +#--------------------------------------------------------------------------------------- +# Define main function + +def preprocess_molecules(input_molecules: [str, List[str], pd.DataFrame]): + """ + This function preprocesses molecules (assumed to be in SMILES format) and creates + descriptors which can be fed into MHNfs. + """ + + # Load needed objects + current_loc = __file__.rsplit("/",3)[0] + with open(current_loc + "/assets/data_preprocessing_objects/scaler_fitted.pkl", + "rb") as fl: + scaler = pickle.load(fl) + + with open(current_loc + "/assets/data_preprocessing_objects/ecdfs.pkl", "rb") as fl: + ecdfs = pickle.load(fl) + + # Ensure that input_molecules is an Iterable with strs + input_smiles = handle_inputs(input_molecules) + + # Create cleanded rdkit mol objects + input_molecules = create_cleaned_mol_objects(input_smiles) + + # Create fingerprints and descriptors + ecfps = create_ecfp_fps(input_molecules) + rdkit_descrs = create_rdkit_descriptors(input_molecules) + + # Create quantils + rdkit_descr_quantils = create_quantils(rdkit_descrs, ecdfs) + + # Concatenate features + raw_features = np.concatenate((ecfps, rdkit_descr_quantils), axis=1) + + # Normalize feature vectors + normalized_features = scaler.transform(raw_features) + + # Return feature vectors + return normalized_features + +#--------------------------------------------------------------------------------------- +# Define helper functions +def handle_inputs(input_molecules: [str, List[str], pd.DataFrame]): + """ + This function handles the input molecules. + """ + + if isinstance(input_molecules, list): + return input_molecules + + elif isinstance(input_molecules, pd.DataFrame): + input_molecules.columns = [c.lower() for c in input_molecules.columns] + if "smiles" not in input_molecules.columns: + raise ValueError(("Input DataFrame must have a column named 'Smiles'.")) + iterable = list(input_molecules["smiles"].values) + return iterable + + elif isinstance(input_molecules, str): + smiles_list = input_molecules.split(",") + smiles_list_cleaned = [smiles.strip() for smiles in smiles_list] + + smiles_list_cleaned = [smiles for smiles in smiles_list_cleaned if smiles != ""] + return smiles_list_cleaned + else: + raise TypeError(("Input molecules must be a string,a list of strings or a " + "pandas DataFrame.")) + +def create_ecfp_fps(mols: List[Mol]) -> np.ndarray: + """ + This function ECFP fingerprints for a list of molecules. + """ + ecfps = list() + + for mol in mols: + fp_sparse_vec = rdFingerprintGenerator.GetCountFPs( + [mol], fpType=rdFingerprintGenerator.MorganFP + )[0] + fp = np.zeros((0,), np.int8) + DataStructs.ConvertToNumpyArray(fp_sparse_vec, fp) + + ecfps.append(fp) + + return np.array(ecfps) + +def create_rdkit_descriptors(mols: List[Mol]) -> np.ndarray: + """ + This function creates RDKit descriptors for a list of molecules. + """ + rdkit_descriptors = list() + + for mol in mols: + descrs = [] + for _, descr_calc_fn in Descriptors._descList: + descrs.append(descr_calc_fn(mol)) + + descrs = np.array(descrs) + descrs = descrs[USED_200_DESCR] + rdkit_descriptors.append(descrs) + + return np.array(rdkit_descriptors) + +def create_quantils(raw_features: np.ndarray, ecdfs: list) -> np.ndarray: + + quantils = np.zeros_like(raw_features) + + for column in range(raw_features.shape[1]): + raw_values = raw_features[:, column].reshape(-1) + ecdf = ecdfs[column] + q = ecdf(raw_values) + quantils[:, column] = q + + return quantils + +def create_cleaned_mol_objects(smiles: List[str]) -> List[Mol]: + """ + This function creates cleaned RDKit mol objects from a list of SMILES. + """ + sm = Standardizer(canon_taut=True) + + mols = list() + for smile in smiles: + #try: + mol = Chem.MolFromSmiles(smile) + standardized_mol, _ = sm.standardize_mol(mol) + can_mol = Chem.MolFromSmiles(Chem.MolToSmiles(standardized_mol)) + mols.append(can_mol) + return mols + +#--------------------------------------------------------------------------------------- + diff --git a/src/data_preprocessing/create_model_inputs.py b/src/data_preprocessing/create_model_inputs.py new file mode 100644 index 0000000000000000000000000000000000000000..d254817c1b788c9ad866f878a88edb76a53d46b6 --- /dev/null +++ b/src/data_preprocessing/create_model_inputs.py @@ -0,0 +1,46 @@ +""" +In this file, the input functions for query and support set molecules are defined. +Input is assumed to be either a SMILES string, a list of SMILES strings, or a pandas +dataframe. +""" + +#--------------------------------------------------------------------------------------- +# Dependencies +import pandas as pd +from typing import List +import torch + +from src.data_preprocessing.create_descriptors import preprocess_molecules + +#--------------------------------------------------------------------------------------- +# Define main functions +def create_query_input(smiles_input: [str, List[str], pd.DataFrame]): + """ + This function creates the input for the query molecules. + """ + + # Create vector representation + numpy_vector_representation = preprocess_molecules(smiles_input) + assert len(numpy_vector_representation.shape) == 2 + + # Create pytorch tensor + tensor = torch.from_numpy(numpy_vector_representation).unsqueeze(1).float() + + return tensor + +def create_support_set_input(smiles_input: [str, List[str], pd.DataFrame]): + """ + This function creates the input for the support set molecules. + """ + + # Create vector representation + numpy_vector_representation = preprocess_molecules(smiles_input) + assert len(numpy_vector_representation.shape) == 2 + + size = numpy_vector_representation.shape[0] + + # Create pytorch tensors + tensor = torch.from_numpy(numpy_vector_representation).unsqueeze(0).float() + size = torch.tensor(size) + + return tensor, size \ No newline at end of file diff --git a/src/data_preprocessing/utils.py b/src/data_preprocessing/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..fc42b448b08f891fa6314f02cd35f65d6af7a42d --- /dev/null +++ b/src/data_preprocessing/utils.py @@ -0,0 +1,247 @@ +## These MolStandardizer classes are due to Paolo Tosco +## It was taken from the FS-Mol github +## (https://github.com/microsoft/FS-Mol/blob/main/fs_mol/preprocessing/utils/ +## standardizer.py) +## They ensure that a sequence of standardization operations are applied +## https://gist.github.com/ptosco/7e6b9ab9cc3e44ba0919060beaed198e + +import logging + +from rdkit import Chem, RDLogger +from rdkit.Chem.MolStandardize import rdMolStandardize + + +class BaseLogger: + """ + Simple logging base class. + + Inherit from this class and call self.get_logger() to + get a logger bearing the class name. + """ + + DEFAULT_LOG_LEVEL = logging.WARNING + + def __init__(self): + self._log_level = self.DEFAULT_LOG_LEVEL + + def set_log_level(self, log_level): + if not getattr(logging, log_level): + raise TypeError(f"log_level {log_level} does not exist in logging") + self._log_level = log_level + + def get_logger(self): + """Return a logger bearing the class name.""" + logger = logging.getLogger(self.__class__.__name__) + if not logger.hasHandlers(): + handler = logging.StreamHandler() + formatter = logging.Formatter("[%(asctime)s:%(name)s:%(levelname)s] %(message)s") + handler.setFormatter(formatter) + logger.addHandler(handler) + logger.setLevel(self._log_level) + return logger + + +class Standardizer(BaseLogger): + """ + Simple wrapper class around rdkit Standardizer. + """ + + DEFAULT_CANON_TAUT = False + DEFAULT_METAL_DISCONNECT = False + MAX_TAUTOMERS = 100 + MAX_TRANSFORMS = 100 + MAX_RESTARTS = 200 + PREFER_ORGANIC = True + + def __init__( + self, + metal_disconnect=None, + canon_taut=None, + ): + """ + Constructor. + + All parameters are optional. + :param metal_disconnect: if True, metallorganic complexes are + disconnected + :param canon_taut: if True, molecules are converted to their + canonical tautomer + """ + super().__init__() + if metal_disconnect is None: + metal_disconnect = self.DEFAULT_METAL_DISCONNECT + if canon_taut is None: + canon_taut = self.DEFAULT_CANON_TAUT + self._canon_taut = canon_taut + self._metal_disconnect = metal_disconnect + self._taut_enumerator = None + self._rdlogger = None + self._uncharger = None + self._lfrag_chooser = None + self._metal_disconnector = None + self._normalizer = None + self._reionizer = None + self._params = None + + @property + def params(self): + """Return the MolStandardize CleanupParameters.""" + if self._params is None: + self._params = rdMolStandardize.CleanupParameters() + self._params.maxTautomers = self.MAX_TAUTOMERS + self._params.maxTransforms = self.MAX_TRANSFORMS + self._params.maxRestarts = self.MAX_RESTARTS + self._params.preferOrganic = self.PREFER_ORGANIC + self._params.tautomerRemoveSp3Stereo = False + return self._params + + @property + def canon_taut(self): + """Return whether tautomer canonicalization will be done.""" + return self._canon_taut + + @property + def metal_disconnect(self): + """Return whether metallorganic complexes will be disconnected.""" + return self._metal_disconnect + + @property + def taut_enumerator(self): + """Return the TautomerEnumerator object.""" + if self._taut_enumerator is None: + self._taut_enumerator = rdMolStandardize.TautomerEnumerator(self.params) + return self._taut_enumerator + + @property + def uncharger(self): + """Return the Uncharger object.""" + if self._uncharger is None: + self._uncharger = rdMolStandardize.Uncharger() + return self._uncharger + + @property + def lfrag_chooser(self): + """Return the LargestFragmentChooser object.""" + if self._lfrag_chooser is None: + self._lfrag_chooser = rdMolStandardize.LargestFragmentChooser(self.params.preferOrganic) + return self._lfrag_chooser + + @property + def metal_disconnector(self): + """Return the MetalDisconnector object.""" + if self._metal_disconnector is None: + self._metal_disconnector = rdMolStandardize.MetalDisconnector() + return self._metal_disconnector + + @property + def normalizer(self): + """Return the Normalizer object.""" + if self._normalizer is None: + self._normalizer = rdMolStandardize.Normalizer( + self.params.normalizationsFile, self.params.maxRestarts + ) + return self._normalizer + + @property + def reionizer(self): + """Return the Reionizer object.""" + if self._reionizer is None: + self._reionizer = rdMolStandardize.Reionizer(self.params.acidbaseFile) + return self._reionizer + + def charge_parent(self, mol_in): + """Sequentially apply a series of MolStandardize operations: + + * MetalDisconnector + * Normalizer + * Reionizer + * LargestFragmentChooser + * Uncharger + + The net result is that a desalted, normalized, neutral + molecule with implicit Hs is returned. + """ + params = Chem.RemoveHsParameters() + params.removeAndTrackIsotopes = True + mol_in = Chem.RemoveHs(mol_in, params, sanitize=False) + if self._metal_disconnect: + mol_in = self.metal_disconnector.Disconnect(mol_in) + normalized = self.normalizer.normalize(mol_in) + Chem.SanitizeMol(normalized) + normalized = self.reionizer.reionize(normalized) + Chem.AssignStereochemistry(normalized) + normalized = self.lfrag_chooser.choose(normalized) + normalized = self.uncharger.uncharge(normalized) + # need this to reassess aromaticity on things like + # cyclopentadienyl, tropylium, azolium, etc. + Chem.SanitizeMol(normalized) + return Chem.RemoveHs(Chem.AddHs(normalized)) + + def standardize_mol(self, mol_in): + """ + Standardize a single molecule. + + :param mol_in: a Chem.Mol + :return: * (standardized Chem.Mol, n_taut) tuple + if success. n_taut will be negative if + tautomer enumeration was aborted due + to reaching a limit + * (None, error_msg) if failure + + This calls self.charge_parent() and, if self._canon_taut + is True, runs tautomer canonicalization. + """ + logger = self.get_logger() + if self._rdlogger is None: + self._rdlogger = RDLogger.logger() + self._rdlogger.setLevel(RDLogger.CRITICAL) + n_tautomers = 0 + if isinstance(mol_in, Chem.Mol): + name = None + try: + name = mol_in.GetProp("_Name") + except KeyError: + pass + if not name: + name = "NONAME" + else: + error = f"Expected SMILES or Chem.Mol as input, got {str(type(mol_in))}" + logger.critical(error) + return None, error + try: + mol_out = self.charge_parent(mol_in) + except Exception as e: + error = f"charge_parent FAILED: {str(e).strip()}" + logger.critical(error) + return None, error + if self._canon_taut: + try: + res = self.taut_enumerator.Enumerate(mol_out, False) + except TypeError: + # we are still on the pre-2021 RDKit API + res = self.taut_enumerator.Enumerate(mol_out) + except Exception as e: + # something else went wrong + error = f"canon_taut FAILED: {str(e).strip()}" + logger.critical(error) + return None, error + n_tautomers = len(res) + if hasattr(res, "status"): + completed = res.status == rdMolStandardize.TautomerEnumeratorStatus.Completed + else: + # we are still on the pre-2021 RDKit API + completed = len(res) < 1000 + if not completed: + n_tautomers = -n_tautomers + try: + mol_out = self.taut_enumerator.PickCanonical(res) + except AttributeError: + # we are still on the pre-2021 RDKit API + mol_out = max([(self.taut_enumerator.ScoreTautomer(m), m) for m in res])[1] + except Exception as e: + # something else went wrong + error = f"canon_taut FAILED: {str(e).strip()}" + logger.critical(error) + return None, error + mol_out.SetProp("_Name", name) + return mol_out, n_tautomers \ No newline at end of file diff --git a/src/mhnfs/__init__.py b/src/mhnfs/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/src/mhnfs/__pycache__/__init__.cpython-37.pyc b/src/mhnfs/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fba5ad560e223c1e1893671503c646d9c56befd9 Binary files /dev/null and b/src/mhnfs/__pycache__/__init__.cpython-37.pyc differ diff --git a/src/mhnfs/__pycache__/initialization.cpython-37.pyc b/src/mhnfs/__pycache__/initialization.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2d2ef68d4230e8bb8d83a729df808c1938a8b55b Binary files /dev/null and b/src/mhnfs/__pycache__/initialization.cpython-37.pyc differ diff --git a/src/mhnfs/__pycache__/model.cpython-37.pyc b/src/mhnfs/__pycache__/model.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f3ee2a7bbffadf8060504f08dd61abe0a918a882 Binary files /dev/null and b/src/mhnfs/__pycache__/model.cpython-37.pyc differ diff --git a/src/mhnfs/__pycache__/modules.cpython-37.pyc b/src/mhnfs/__pycache__/modules.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a84eb2cf9aaeb0bf00f019b67066dbf143d1414a Binary files /dev/null and b/src/mhnfs/__pycache__/modules.cpython-37.pyc differ diff --git a/src/mhnfs/hopfield/LICENSE b/src/mhnfs/hopfield/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..47a0284f6bbbea8399f555abb5ff5932c873e95f --- /dev/null +++ b/src/mhnfs/hopfield/LICENSE @@ -0,0 +1,79 @@ +From Hopfield layers: + +Copyright (c) 2020, Institute for Machine Learning, Johannes Kepler University Linz (Bernhard SchΓ€fl) +All rights reserved. + +All other contributions: +Copyright (c) 2020 the respective contributors +All rights reserved. + +From PyTorch: + +Copyright (c) 2016- Facebook, Inc (Adam Paszke) +Copyright (c) 2014- Facebook, Inc (Soumith Chintala) +Copyright (c) 2011-2014 Idiap Research Institute (Ronan Collobert) +Copyright (c) 2012-2014 Deepmind Technologies (Koray Kavukcuoglu) +Copyright (c) 2011-2012 NEC Laboratories America (Koray Kavukcuoglu) +Copyright (c) 2011-2013 NYU (Clement Farabet) +Copyright (c) 2006-2010 NEC Laboratories America (Ronan Collobert, Leon Bottou, Iain Melvin, Jason Weston) +Copyright (c) 2006 Idiap Research Institute (Samy Bengio) +Copyright (c) 2001-2004 Idiap Research Institute (Ronan Collobert, Samy Bengio, Johnny Mariethoz) + +From Caffe2: + +Copyright (c) 2016-present, Facebook Inc. All rights reserved. + +All contributions by Facebook: +Copyright (c) 2016 Facebook Inc. + +All contributions by Google: +Copyright (c) 2015 Google Inc. +All rights reserved. + +All contributions by Yangqing Jia: +Copyright (c) 2015 Yangqing Jia +All rights reserved. + +All contributions from Caffe: +Copyright(c) 2013, 2014, 2015, the respective contributors +All rights reserved. + +All other contributions: +Copyright(c) 2015, 2016 the respective contributors +All rights reserved. + +Caffe2 uses a copyright model similar to Caffe: each contributor holds +copyright over their contributions to Caffe2. The project versioning records +all such contribution and copyright details. If a contributor wants to further +mark their specific copyright on a particular contribution, they should +indicate their copyright solely in the commit message of the change when it is +committed. + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +3. Neither the names of Facebook, Deepmind Technologies, NYU, NEC Laboratories America + and IDIAP Research Institute nor the names of its contributors may be + used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. diff --git a/src/mhnfs/hopfield/README.md b/src/mhnfs/hopfield/README.md new file mode 100644 index 0000000000000000000000000000000000000000..bc3afb01437ec35fcf8864ae87e6055b4886d473 --- /dev/null +++ b/src/mhnfs/hopfield/README.md @@ -0,0 +1,119 @@ +# Hopfield Networks is All You Need + +_Hubert Ramsauer1, +Bernhard SchΓ€fl1, +Johannes Lehner1, +Philipp Seidl1, +Michael Widrich1, +Lukas Gruber1, +Markus Holzleitner1, +Milena PavloviΔ‡3, 4, +Geir Kjetil Sandve4, +Victor Greiff3, +David Kreil2, +Michael Kopp2, +GΓΌnter Klambauer1, +Johannes Brandstetter1, +Sepp Hochreiter1, 2_ + +1 ELLIS Unit Linz and LIT AI Lab, Institute for Machine Learning, Johannes Kepler University Linz, Austria +2 Institute of Advanced Research in Artificial Intelligence (IARAI) +3 Department of Immunology, University of Oslo, Norway +4 Department of Informatics, University of Oslo, Norway + +--- + +##### Detailed blog post on this paper as well as the necessary background on Hopfield networks at [this link](https://ml-jku.github.io/hopfield-layers/). + +--- + +The transformer and BERT models pushed the performance on NLP tasks to new levels via their attention mechanism. We show +that this attention mechanism is the update rule of a modern Hopfield network with continuous states. This new Hopfield +network can store exponentially (with the dimension) many patterns,converges with one update, and has exponentially +small retrieval errors. The number of stored patterns must be traded off against convergence speed and retrieval error. +The new Hopfield network has three types of energy minima (fixed points of the update): + +1. global fixed point averaging over all patterns, +2. metastable states averaging over a subset of patterns, and +3. fixed points which store a single pattern. + +Transformers learn an attention mechanism by constructing an embedding of patterns and queries into an associative +space. Transformer and BERT models operate in their first layers preferably in the global averaging regime, while they +operate in higher layers in metastable states. The gradient in transformers is maximal in the regime of metastable +states, is uniformly distributed when averaging globally, and vanishes when a fixed point is near a stored pattern. +Based on the Hopfield network interpretation, we analyzed learning of transformer and BERT architectures. Learning starts +with attention heads that average and then most of them switch to metastable states. However, the majority of heads in +the first layers still averages and can be replaced by averaging operations like the Gaussian weighting that we propose. +In contrast, heads in the last layers steadily learn and seem to use metastable states to collect information created in +lower layers. These heads seem a promising target for improving transformers. Neural networks that integrate Hopfield +networks that are equivalent to attention heads outperform other methods on immune repertoire classification, where the +Hopfield net stores several hundreds of thousands of patterns. + +With _this_ repository, we provide a PyTorch implementation of a new layer called +β€œHopfield” which allows to equip deep learning architectures with Hopfield networks as new memory concepts. + +The full paper is available at [https://arxiv.org/abs/2008.02217](https://arxiv.org/abs/2008.02217). + +## Requirements + +The software was developed and tested on the following 64-bit operating systems: + +- CentOS Linux release 8.1.1911 (Core) +- macOS 10.15.5 (Catalina) + +As the development environment, [Python](https://www.python.org) 3.8.3 in combination with [PyTorch](https://pytorch.org) 1.6.0 was used (a version of at least 1.5.0 should be sufficient). More details on how to install PyTorch are available on the [official project page](https://pytorch.org). + +## Usage + +To get up and running with Hopfield-based networks, only one argument needs to be set, the size (depth) of the input. + +```python +hopfield = Hopfield(input_size=...) +``` + +It is also possible to replace commonly used pooling functions with a Hopfield-based one. Internally, a state pattern is trained, which in turn is used to compute pooling weights with respect to the input. + +```python +hopfield_pooling = HopfieldPooling(input_size=...) +``` + +A second variant of our Hopfield-based modules is one which employs a trainable but fixed lookup mechanism. Internally, one or multiple stored patterns and pattern projections are trained (optionally in a non-shared manner), which in turn are used as a lookup mechanism independent of the input data. + +```python +hopfield_lookup = HopfieldLayer(input_size=...) +``` + +The usage is as simple as with the main module, but equally powerful. + +## Examples + +Generally, the Hopfield layer is designed to be used to implement or to substitute different layers like: + +- Pooling layers: We consider the Hopfield layer as a pooling layer if only one static state (query) pattern exists. Then, it is de facto a pooling over the sequence, which results from the softmax values applied on the stored patterns. Therefore, our Hopfield layer can act as a pooling layer. + +- Permutation equivariant layers: Our Hopfield layer can be used as a plug-in replacement for permutation equivariant layers. Since the Hopfield layer is an associative memory it assumes no dependency between the input patterns. + +- GRU & LSTM layers: Our Hopfield layer can be used as a plug-in replacement for GRU & LSTM layers. Optionally, for substituting GRU & LSTM layers, positional encoding might be considered. + +- Attention layers: Our Hopfield layer can act as an attention layer, where state (query) and stored (key) patterns are different, and need to be associated. + +The folder [examples](examples/) contains multiple demonstrations on how to use the Hopfield, HopfieldPooling as well as the HopfieldLayer modules. To successfully run the contained [Jupyter notebooks](https://jupyter.org), additional third-party modules like [pandas](https://pandas.pydata.org) and [seaborn](https://seaborn.pydata.org) are required. + +- [Bit Pattern Set](examples/bit_pattern/bit_pattern_demo.ipynb): The dataset of this demonstration falls into the category of binary classification tasks in the domain of Multiple Instance Learning (MIL) problems. Each bag comprises a collection of bit pattern instances, wheres each instance is a sequence of 0s and 1s. The positive class has specific bit patterns injected, which are absent in the negative one. This demonstration shows, that Hopfield, HopfieldPooling and HopfieldLayer are capable of learning and filtering each bag with respect to the class-defining bit patterns. + +- [Latch Sequence Set](examples/latch_sequence/latch_sequence_demo.ipynb): We study an easy example of learning long-term dependencies by using a simple latch task, see [Hochreiter and Mozer](https://link.springer.com/chapter/10.1007/3-540-44668-0_92). The essence of this task is that a sequence of inputs is presented, beginning with one of two symbols, A or B, and after a variable number of time steps, the model has to output a corresponding symbol. Thus, the task requires memorizing the original input over time. It has to be noted, that both class-defining symbols must only appear at the first position of a sequence. This task was specifically designed to demonstrate the capability of recurrent neural networks to capture long term dependencies. This demonstration shows, that Hopfield, HopfieldPooling and HopfieldLayer adapt extremely fast to this specific task, concentrating only on the first entry of the sequence. + +- [Attention-based Deep Multiple Instance Learning](examples/mnist_bags/mnist_bags_demo.ipynb): The dataset of this demonstration falls into the category of binary classification tasks in the domain of Multiple Instance Learning (MIL) problems, see [Ilse and Tomczak](https://arxiv.org/abs/1802.04712). Each bag comprises a collection of 28x28 grayscale images/instances, whereas each instance is a sequence of pixel values in the range of [0; 255]. The amount of instances per pag is drawn from a Gaussian with specified mean and variance. The positive class is defined by the presence of the target number/digit, whereas the negative one by its absence. + +## Disclaimer + +Some implementations of this repository are based on existing ones of the official [PyTorch repository v1.6.0](https://github.com/pytorch/pytorch/tree/v1.6.0) and accordingly extended and modified. In the following, the involved parts are listed: + +- The implementation of [HopfieldCore](modules/activation.py#L11) is based on the implementation of [MultiheadAttention](https://github.com/pytorch/pytorch/blob/b31f58de6fa8bbda5353b3c77d9be4914399724d/torch/nn/modules/activation.py#L771). +- The implementation of [hopfield_core_forward](modules/functional.py#L8) is based on the implementation of [multi_head_attention_forward](https://github.com/pytorch/pytorch/blob/b31f58de6fa8bbda5353b3c77d9be4914399724d/torch/nn/functional.py#L3854). +- The implementation of [HopfieldEncoderLayer](modules/transformer.py#L12) is based on the implementation of [TransformerEncoderLayer](https://github.com/pytorch/pytorch/blob/b31f58de6fa8bbda5353b3c77d9be4914399724d/torch/nn/modules/transformer.py#L241). +- The implementation of [HopfieldDecoderLayer](modules/transformer.py#L88) is based on the implementation of [TransformerDecoderLayer](https://github.com/pytorch/pytorch/blob/b31f58de6fa8bbda5353b3c77d9be4914399724d/torch/nn/modules/transformer.py#L303). + +## License + +This repository is BSD-style licensed (see [LICENSE](LICENSE)), except where noted otherwise. \ No newline at end of file diff --git a/src/mhnfs/hopfield/__init__.py b/src/mhnfs/hopfield/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/src/mhnfs/hopfield/__pycache__/__init__.cpython-37.pyc b/src/mhnfs/hopfield/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a185a4fc0f402dd6c0a9a82821c064767effe6c0 Binary files /dev/null and b/src/mhnfs/hopfield/__pycache__/__init__.cpython-37.pyc differ diff --git a/src/mhnfs/hopfield/__pycache__/__init__.cpython-38.pyc b/src/mhnfs/hopfield/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2e46ddbbf242fac3d42ab6d882c300182e12c288 Binary files /dev/null and b/src/mhnfs/hopfield/__pycache__/__init__.cpython-38.pyc differ diff --git a/src/mhnfs/hopfield/__pycache__/__init__.cpython-39.pyc b/src/mhnfs/hopfield/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5f41640cb4dbe924a93ab5b0a7fc03b89300f2ed Binary files /dev/null and b/src/mhnfs/hopfield/__pycache__/__init__.cpython-39.pyc differ diff --git a/src/mhnfs/hopfield/auxiliary/__init__.py b/src/mhnfs/hopfield/auxiliary/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/src/mhnfs/hopfield/auxiliary/data.py b/src/mhnfs/hopfield/auxiliary/data.py new file mode 100644 index 0000000000000000000000000000000000000000..2c3e393145921d6588d6b0adc41f036b6bd5f4a9 --- /dev/null +++ b/src/mhnfs/hopfield/auxiliary/data.py @@ -0,0 +1,252 @@ +import torch + +from math import ceil +from torch.utils.data import Dataset +from typing import Dict, Optional, Sequence, Tuple, Union + + +class BitPatternSet(Dataset): + """ + Binary multiple instance learning (MIL) data set comprising bit patterns as instances, + with implanted bit patterns unique to one of the classes. + """ + + def __init__(self, num_bags: int, num_instances: int, num_signals: int, num_signals_per_bag: int = 1, + fraction_targets: float = 0.5, num_bits: int = 8, dtype: torch.dtype = torch.float32, + seed_signals: int = 43, seed_data: int = 44): + """ + Create new binary bit pattern data set conforming to the specified properties. + + :param num_bags: amount of bags + :param num_instances: amount of instances per bag + :param num_signals: amount of unique signals used to distinguish both classes + :param num_signals_per_bag: amount of unique signals to be implanted per bag + :param fraction_targets: fraction of targets + :param num_bits: amount of bits per instance + :param dtype: data type of instances + :param seed_signals: random seed used to generate the signals of the data set (excl. samples) + :param seed_data: random seed used to generate the samples of the data set (excl. signals) + """ + super(BitPatternSet, self).__init__() + assert (type(num_bags) == int) and (num_bags > 0), r'"num_bags" must be a positive integer!' + assert (type(num_instances) == int) and (num_instances > 0), r'"num_instances" must be a positive integer!' + assert (type(num_signals) == int) and (num_signals > 0), r'"num_signals" must be a positive integer!' + assert (type(num_signals_per_bag) == int) and (num_signals_per_bag >= 0) and ( + num_signals_per_bag <= num_instances), r'"num_signals_per_bag" must be a non-negative integer!' + assert (type(fraction_targets) == float) and (fraction_targets > 0) and ( + fraction_targets < 1), r'"fraction_targets" must be in interval (0; 1)!' + assert (type(num_bits) == int) and (num_bits > 0), r'"num_bits" must be a positive integer!' + assert ((2 ** num_bits) - 1) > num_signals, r'"num_signals" must be smaller than "2 ** num_bits - 1"!' + assert type(seed_signals) == int, r'"seed_signals" must be an integer!' + assert type(seed_data) == int, r'"seed_data" must be an integer!' + + self.__num_bags = num_bags + self.__num_instances = num_instances + self.__num_signals = num_signals + self.__num_signals_per_bag = num_signals_per_bag + self.__fraction_targets = fraction_targets + self.__num_targets = min(self.__num_bags, max(1, ceil(self.__num_bags * self.__fraction_targets))) + self.__num_bits = num_bits + self.__dtype = dtype + self.__seed_signals = seed_signals + self.__seed_data = seed_data + self.__data, self.__targets, self.__signals = self._generate_bit_pattern_set() + + def __len__(self) -> int: + """ + Fetch amount of bags. + + :return: amount of bags + """ + return self.__num_bags + + def __getitem__(self, item_index: int) -> Dict[str, torch.Tensor]: + """ + Fetch specific bag. + + :param item_index: specific bag to fetch + :return: specific bag as dictionary of tensors + """ + return {r'data': self.__data[item_index].to(dtype=self.__dtype), + r'target': self.__targets[item_index].to(dtype=self.__dtype)} + + def _generate_bit_pattern_set(self) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """ + Generate underlying bit pattern data set. + + :return: tuple containing generated bags, targets and signals + """ + torch.random.manual_seed(seed=self.__seed_signals) + + # Generate signal patterns. + generated_signals = torch.randint(low=0, high=2, size=(self.__num_signals, self.__num_bits)) + check_instances = True + while check_instances: + generated_signals = torch.unique(input=generated_signals, dim=0) + generated_signals = generated_signals[generated_signals.sum(axis=1) != 0] + missing_signals = self.__num_signals - generated_signals.shape[0] + if missing_signals > 0: + generated_signals = torch.cat(tensors=( + generated_signals, torch.randint(low=0, high=2, size=(missing_signals, self.__num_bits))), dim=0) + else: + check_instances = False + + # Generate data and target tensors. + torch.random.manual_seed(seed=self.__seed_data) + generated_data = torch.randint(low=0, high=2, size=(self.__num_bags, self.__num_instances, self.__num_bits)) + generated_targets = torch.zeros(size=(self.__num_bags,), dtype=generated_data.dtype) + generated_targets[:self.__num_targets] = 1 + + # Check invalid (all-zero and signal) instances and re-sample them. + check_instances = True + while check_instances: + invalid_instances = (generated_data.sum(axis=2) == 0).logical_or( + torch.sum(torch.stack([(generated_data == _).all(axis=2) for _ in generated_signals]), axis=0)) + if invalid_instances.sum() > 0: + generated_data[invalid_instances] = torch.randint( + low=0, high=2, size=(invalid_instances.sum(), self.__num_bits)) + else: + check_instances = False + + # Re-implant signal into respective bags. + for data_index in range(self.__num_targets): + implantation_indices = [] + for _ in range(self.__num_signals_per_bag): + while True: + current_implantation_index = torch.randint(low=0, high=generated_data.shape[1], size=(1,)) + if current_implantation_index not in implantation_indices: + implantation_indices.append(current_implantation_index) + break + current_signal_index = torch.randint(low=0, high=generated_signals.shape[0], size=(1,)) + generated_data[data_index, current_implantation_index] = generated_signals[current_signal_index] + + return generated_data, generated_targets, generated_signals + + @property + def num_bags(self) -> int: + return self.__num_bags + + @property + def num_instances(self) -> int: + return self.__num_instances + + @property + def num_bits(self) -> int: + return self.__num_bits + + @property + def num_targets_high(self) -> int: + return self.__num_targets + + @property + def num_targets_low(self) -> int: + return self.__num_bags - self.__num_targets + + @property + def num_signals(self) -> int: + return self.__num_signals + + @property + def num_signals_per_bag(self) -> int: + return self.__num_signals_per_bag + + @property + def initial_seed(self) -> int: + return self.__seed + + @property + def bags(self) -> torch.Tensor: + return self.__data.clone() + + @property + def targets(self) -> torch.Tensor: + return self.__targets.clone() + + @property + def signals(self) -> torch.Tensor: + return self.__signals.clone() + + +class LatchSequenceSet(Dataset): + """ + Latch data set comprising patterns as one-hot encoded instances. + """ + + def __init__(self, num_samples: int, num_instances: int = 20, num_characters: int = 6, + dtype: torch.dtype = torch.float32, seed: int = 43): + """ + Create new latch sequence data set conforming to the specified properties. + + :param num_samples: amount of samples + :param num_instances: amount of instances per sample + :param num_characters: amount of different characters + :param dtype: data type of samples + :param seed: random seed used to generate the samples of the data set + """ + super(LatchSequenceSet, self).__init__() + assert (type(num_samples) == int) and (num_samples > 0), r'"num_samples" must be a positive integer!' + assert (type(num_instances) == int) and (num_instances > 0), r'"num_instances" must be a positive integer!' + assert (type(num_characters) == int) and (num_characters > 0), r'"num_characters" must be a positive integer!' + assert type(seed) == int, r'"seed" must be an integer!' + + self.__num_samples = num_samples + self.__num_instances = num_instances + self.__num_characters = num_characters + self.__dtype = dtype + self.__seed = seed + self.__data, self.__targets = self._generate_latch_sequences() + + def __len__(self) -> int: + """ + Fetch amount of samples. + + :return: amount of samples + """ + return self.__num_samples + + def __getitem__(self, item_index: int) -> Dict[str, torch.Tensor]: + """ + Fetch specific sample. + + :param item_index: specific sample to fetch + :return: specific sample as dictionary of tensors + """ + return {r'data': self.__data[item_index].to(dtype=self.__dtype), + r'target': self.__targets[item_index].to(dtype=self.__dtype)} + + def _generate_latch_sequences(self) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Generate underlying latch sequence data set. + + :return: tuple containing generated data and targets + """ + torch.random.manual_seed(seed=self.__seed) + + # Generate data and target tensors. + generated_data = torch.randint( + low=2, high=self.__num_characters, size=(self.__num_samples, self.__num_instances)) + generated_signal = torch.randint(low=0, high=2, size=(self.__num_samples,)) + generated_data[:, 0] = generated_signal + generated_data = torch.nn.functional.one_hot(input=generated_data, num_classes=self.__num_characters) + + return generated_data, generated_signal + + @property + def num_samples(self) -> int: + return self.__num_samples + + @property + def num_instances(self) -> int: + return self.__num_instances + + @property + def num_characters(self) -> int: + return self.__num_characters + + @property + def initial_seed(self) -> int: + return self.__seed + + @property + def targets(self) -> torch.Tensor: + return self.__targets.clone() diff --git a/src/mhnfs/hopfield/examples/bit_pattern/auxiliary/__init__.py b/src/mhnfs/hopfield/examples/bit_pattern/auxiliary/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/src/mhnfs/hopfield/examples/bit_pattern/auxiliary/data.py b/src/mhnfs/hopfield/examples/bit_pattern/auxiliary/data.py new file mode 100644 index 0000000000000000000000000000000000000000..2c3e393145921d6588d6b0adc41f036b6bd5f4a9 --- /dev/null +++ b/src/mhnfs/hopfield/examples/bit_pattern/auxiliary/data.py @@ -0,0 +1,252 @@ +import torch + +from math import ceil +from torch.utils.data import Dataset +from typing import Dict, Optional, Sequence, Tuple, Union + + +class BitPatternSet(Dataset): + """ + Binary multiple instance learning (MIL) data set comprising bit patterns as instances, + with implanted bit patterns unique to one of the classes. + """ + + def __init__(self, num_bags: int, num_instances: int, num_signals: int, num_signals_per_bag: int = 1, + fraction_targets: float = 0.5, num_bits: int = 8, dtype: torch.dtype = torch.float32, + seed_signals: int = 43, seed_data: int = 44): + """ + Create new binary bit pattern data set conforming to the specified properties. + + :param num_bags: amount of bags + :param num_instances: amount of instances per bag + :param num_signals: amount of unique signals used to distinguish both classes + :param num_signals_per_bag: amount of unique signals to be implanted per bag + :param fraction_targets: fraction of targets + :param num_bits: amount of bits per instance + :param dtype: data type of instances + :param seed_signals: random seed used to generate the signals of the data set (excl. samples) + :param seed_data: random seed used to generate the samples of the data set (excl. signals) + """ + super(BitPatternSet, self).__init__() + assert (type(num_bags) == int) and (num_bags > 0), r'"num_bags" must be a positive integer!' + assert (type(num_instances) == int) and (num_instances > 0), r'"num_instances" must be a positive integer!' + assert (type(num_signals) == int) and (num_signals > 0), r'"num_signals" must be a positive integer!' + assert (type(num_signals_per_bag) == int) and (num_signals_per_bag >= 0) and ( + num_signals_per_bag <= num_instances), r'"num_signals_per_bag" must be a non-negative integer!' + assert (type(fraction_targets) == float) and (fraction_targets > 0) and ( + fraction_targets < 1), r'"fraction_targets" must be in interval (0; 1)!' + assert (type(num_bits) == int) and (num_bits > 0), r'"num_bits" must be a positive integer!' + assert ((2 ** num_bits) - 1) > num_signals, r'"num_signals" must be smaller than "2 ** num_bits - 1"!' + assert type(seed_signals) == int, r'"seed_signals" must be an integer!' + assert type(seed_data) == int, r'"seed_data" must be an integer!' + + self.__num_bags = num_bags + self.__num_instances = num_instances + self.__num_signals = num_signals + self.__num_signals_per_bag = num_signals_per_bag + self.__fraction_targets = fraction_targets + self.__num_targets = min(self.__num_bags, max(1, ceil(self.__num_bags * self.__fraction_targets))) + self.__num_bits = num_bits + self.__dtype = dtype + self.__seed_signals = seed_signals + self.__seed_data = seed_data + self.__data, self.__targets, self.__signals = self._generate_bit_pattern_set() + + def __len__(self) -> int: + """ + Fetch amount of bags. + + :return: amount of bags + """ + return self.__num_bags + + def __getitem__(self, item_index: int) -> Dict[str, torch.Tensor]: + """ + Fetch specific bag. + + :param item_index: specific bag to fetch + :return: specific bag as dictionary of tensors + """ + return {r'data': self.__data[item_index].to(dtype=self.__dtype), + r'target': self.__targets[item_index].to(dtype=self.__dtype)} + + def _generate_bit_pattern_set(self) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """ + Generate underlying bit pattern data set. + + :return: tuple containing generated bags, targets and signals + """ + torch.random.manual_seed(seed=self.__seed_signals) + + # Generate signal patterns. + generated_signals = torch.randint(low=0, high=2, size=(self.__num_signals, self.__num_bits)) + check_instances = True + while check_instances: + generated_signals = torch.unique(input=generated_signals, dim=0) + generated_signals = generated_signals[generated_signals.sum(axis=1) != 0] + missing_signals = self.__num_signals - generated_signals.shape[0] + if missing_signals > 0: + generated_signals = torch.cat(tensors=( + generated_signals, torch.randint(low=0, high=2, size=(missing_signals, self.__num_bits))), dim=0) + else: + check_instances = False + + # Generate data and target tensors. + torch.random.manual_seed(seed=self.__seed_data) + generated_data = torch.randint(low=0, high=2, size=(self.__num_bags, self.__num_instances, self.__num_bits)) + generated_targets = torch.zeros(size=(self.__num_bags,), dtype=generated_data.dtype) + generated_targets[:self.__num_targets] = 1 + + # Check invalid (all-zero and signal) instances and re-sample them. + check_instances = True + while check_instances: + invalid_instances = (generated_data.sum(axis=2) == 0).logical_or( + torch.sum(torch.stack([(generated_data == _).all(axis=2) for _ in generated_signals]), axis=0)) + if invalid_instances.sum() > 0: + generated_data[invalid_instances] = torch.randint( + low=0, high=2, size=(invalid_instances.sum(), self.__num_bits)) + else: + check_instances = False + + # Re-implant signal into respective bags. + for data_index in range(self.__num_targets): + implantation_indices = [] + for _ in range(self.__num_signals_per_bag): + while True: + current_implantation_index = torch.randint(low=0, high=generated_data.shape[1], size=(1,)) + if current_implantation_index not in implantation_indices: + implantation_indices.append(current_implantation_index) + break + current_signal_index = torch.randint(low=0, high=generated_signals.shape[0], size=(1,)) + generated_data[data_index, current_implantation_index] = generated_signals[current_signal_index] + + return generated_data, generated_targets, generated_signals + + @property + def num_bags(self) -> int: + return self.__num_bags + + @property + def num_instances(self) -> int: + return self.__num_instances + + @property + def num_bits(self) -> int: + return self.__num_bits + + @property + def num_targets_high(self) -> int: + return self.__num_targets + + @property + def num_targets_low(self) -> int: + return self.__num_bags - self.__num_targets + + @property + def num_signals(self) -> int: + return self.__num_signals + + @property + def num_signals_per_bag(self) -> int: + return self.__num_signals_per_bag + + @property + def initial_seed(self) -> int: + return self.__seed + + @property + def bags(self) -> torch.Tensor: + return self.__data.clone() + + @property + def targets(self) -> torch.Tensor: + return self.__targets.clone() + + @property + def signals(self) -> torch.Tensor: + return self.__signals.clone() + + +class LatchSequenceSet(Dataset): + """ + Latch data set comprising patterns as one-hot encoded instances. + """ + + def __init__(self, num_samples: int, num_instances: int = 20, num_characters: int = 6, + dtype: torch.dtype = torch.float32, seed: int = 43): + """ + Create new latch sequence data set conforming to the specified properties. + + :param num_samples: amount of samples + :param num_instances: amount of instances per sample + :param num_characters: amount of different characters + :param dtype: data type of samples + :param seed: random seed used to generate the samples of the data set + """ + super(LatchSequenceSet, self).__init__() + assert (type(num_samples) == int) and (num_samples > 0), r'"num_samples" must be a positive integer!' + assert (type(num_instances) == int) and (num_instances > 0), r'"num_instances" must be a positive integer!' + assert (type(num_characters) == int) and (num_characters > 0), r'"num_characters" must be a positive integer!' + assert type(seed) == int, r'"seed" must be an integer!' + + self.__num_samples = num_samples + self.__num_instances = num_instances + self.__num_characters = num_characters + self.__dtype = dtype + self.__seed = seed + self.__data, self.__targets = self._generate_latch_sequences() + + def __len__(self) -> int: + """ + Fetch amount of samples. + + :return: amount of samples + """ + return self.__num_samples + + def __getitem__(self, item_index: int) -> Dict[str, torch.Tensor]: + """ + Fetch specific sample. + + :param item_index: specific sample to fetch + :return: specific sample as dictionary of tensors + """ + return {r'data': self.__data[item_index].to(dtype=self.__dtype), + r'target': self.__targets[item_index].to(dtype=self.__dtype)} + + def _generate_latch_sequences(self) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Generate underlying latch sequence data set. + + :return: tuple containing generated data and targets + """ + torch.random.manual_seed(seed=self.__seed) + + # Generate data and target tensors. + generated_data = torch.randint( + low=2, high=self.__num_characters, size=(self.__num_samples, self.__num_instances)) + generated_signal = torch.randint(low=0, high=2, size=(self.__num_samples,)) + generated_data[:, 0] = generated_signal + generated_data = torch.nn.functional.one_hot(input=generated_data, num_classes=self.__num_characters) + + return generated_data, generated_signal + + @property + def num_samples(self) -> int: + return self.__num_samples + + @property + def num_instances(self) -> int: + return self.__num_instances + + @property + def num_characters(self) -> int: + return self.__num_characters + + @property + def initial_seed(self) -> int: + return self.__seed + + @property + def targets(self) -> torch.Tensor: + return self.__targets.clone() diff --git a/src/mhnfs/hopfield/examples/bit_pattern/bit_pattern_demo.ipynb b/src/mhnfs/hopfield/examples/bit_pattern/bit_pattern_demo.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..e1755c9079da99dc1ea7af7e0d619b5082ea5dcf --- /dev/null +++ b/src/mhnfs/hopfield/examples/bit_pattern/bit_pattern_demo.ipynb @@ -0,0 +1,946 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Example: Bit Pattern Set

\n", + "\n", + "The dataset of this demonstration falls into the category of binary classification tasks in the domain of Multiple Instance Learning (MIL) problems. Each bag comprises a collection of bit pattern instances, wheres each instance is a sequence of 0s and 1s. The positive class has specific bit patterns injected, which are absent in the negative one. This demonstration shows, that Hopfield, HopfieldPooling and HopfieldLayer are capable of learning and filtering each bag with respect to the class-defining bit patterns.\n", + "\n", + "This demonstration instructs how to apply Hopfield, HopfieldPooling and HopfieldLayer for an exemplary Multiple Instance Learning problem.\n", + "\n", + "

In the chapters Adapt Hopfield-based Network, Adapt Hopfield-based Pooling and Adapt Hopfield-based Lookup you can explore and try the new functionalities of our new Hopfield layer.

\n", + "\n", + "In order to run this notebook, a few modules need to be imported. The installation of third-party modules is not covered here." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Import general modules used e.g. for plotting.\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import sys\n", + "import torch\n", + "\n", + "# Importing Hopfield-specific modules.\n", + "from auxiliary.data import BitPatternSet\n", + "from modules import Hopfield, HopfieldPooling, HopfieldLayer\n", + "\n", + "# Import auxiliary modules.\n", + "from distutils.version import LooseVersion\n", + "from typing import List, Tuple\n", + "\n", + "# Importing PyTorch specific modules.\n", + "from torch import Tensor\n", + "from torch.nn import Flatten, Linear, Module, Sequential\n", + "from torch.nn.functional import binary_cross_entropy_with_logits\n", + "from torch.nn.utils import clip_grad_norm_\n", + "from torch.optim import AdamW\n", + "from torch.utils.data import DataLoader\n", + "from torch.utils.data.sampler import SubsetRandomSampler\n", + "\n", + "# Set plotting style.\n", + "sns.set()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Specific minimum versions of Python itself as well as of some used modules is required." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Installed Python version: 3.8.8 (βœ“)\n", + "Installed PyTorch version: 1.7.0 (βœ“)\n" + ] + } + ], + "source": [ + "python_check = '(\\u2713)' if sys.version_info >= (3, 8) else '(\\u2717)'\n", + "pytorch_check = '(\\u2713)' if torch.__version__ >= LooseVersion(r'1.5') else '(\\u2717)'\n", + "\n", + "print(f'Installed Python version: {sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro} {python_check}')\n", + "print(f'Installed PyTorch version: {torch.__version__} {pytorch_check}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Create Dataset

\n", + "\n", + "The dataset itself falls into the category of binary classification tasks in the domain of Multiple Instance Learning (MIL) problems. Defining arguments are:\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ArgumentValue (used in this demo)Description
num_bags2048Amount of bags (samples) of the full dataset.
num_instances16Amount of instances per bag (sample).
num_signals8Amount of unique instances indicative for the positive class.
num_signals_per_bag1Amount of signals implanted into one bag of a positive class.
num_bits8Amount of \"bits\" (feature size) per instance.
...defaultThe remaining arguments are not explicitly used in this demo.
\n", + "\n", + "Let's define the dataset using previously mentioned properties as well as a logging directory for storing all auxiliary outputs like performance plots." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "bit_pattern_set = BitPatternSet(\n", + " num_bags=2048,\n", + " num_instances=16,\n", + " num_signals=8,\n", + " num_signals_per_bag=1,\n", + " num_bits=8)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "log_dir = f'resources/'\n", + "os.makedirs(log_dir, exist_ok=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Create Auxiliaries

\n", + "\n", + "Before digging into Hopfield-based networks, a few auxiliary variables and functions need to be defined. This is nothing special with respect to Hopfield-based networks, but rather common preparation work of (almost) every machine learning setting (e.g. definition of a data loader as well as a training loop). We will see, that this comprises the most work of this whole demo." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device(r'cuda:0' if torch.cuda.is_available() else r'cpu')\n", + "\n", + "# Create data loader of training set.\n", + "sampler_train = SubsetRandomSampler(list(range(256, 2048 - 256)))\n", + "data_loader_train = DataLoader(dataset=bit_pattern_set, batch_size=32, sampler=sampler_train)\n", + "\n", + "# Create data loader of validation set.\n", + "sampler_eval = SubsetRandomSampler(list(range(256)) + list(range(2048 - 256, 2048)))\n", + "data_loader_eval = DataLoader(dataset=bit_pattern_set, batch_size=32, sampler=sampler_eval)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def train_epoch(network: Module,\n", + " optimiser: AdamW,\n", + " data_loader: DataLoader\n", + " ) -> Tuple[float, float]:\n", + " \"\"\"\n", + " Execute one training epoch.\n", + " \n", + " :param network: network instance to train\n", + " :param optimiser: optimiser instance responsible for updating network parameters\n", + " :param data_loader: data loader instance providing training data\n", + " :return: tuple comprising training loss as well as accuracy\n", + " \"\"\"\n", + " network.train()\n", + " losses, accuracies = [], []\n", + " for sample_data in data_loader:\n", + " data, target = sample_data[r'data'], sample_data[r'target']\n", + " data, target = data.to(device=device), target.to(device=device)\n", + "\n", + " # Process data by Hopfield-based network.\n", + " model_output = network.forward(input=data)\n", + "\n", + " # Update network parameters.\n", + " optimiser.zero_grad()\n", + " loss = binary_cross_entropy_with_logits(input=model_output, target=target, reduction=r'mean')\n", + " loss.backward()\n", + " clip_grad_norm_(parameters=network.parameters(), max_norm=1.0, norm_type=2)\n", + " optimiser.step()\n", + "\n", + " # Compute performance measures of current model.\n", + " accuracy = (model_output.sigmoid().round() == target).to(dtype=torch.float32).mean()\n", + " accuracies.append(accuracy.detach().item())\n", + " losses.append(loss.detach().item())\n", + " \n", + " # Report progress of training procedure.\n", + " return (sum(losses) / len(losses), sum(accuracies) / len(accuracies))\n", + "\n", + "\n", + "def eval_iter(network: Module,\n", + " data_loader: DataLoader\n", + " ) -> Tuple[float, float]:\n", + " \"\"\"\n", + " Evaluate the current model.\n", + " \n", + " :param network: network instance to evaluate\n", + " :param data_loader: data loader instance providing validation data\n", + " :return: tuple comprising validation loss as well as accuracy\n", + " \"\"\"\n", + " network.eval()\n", + " with torch.no_grad():\n", + " losses, accuracies = [], []\n", + " for sample_data in data_loader:\n", + " data, target = sample_data[r'data'], sample_data[r'target']\n", + " data, target = data.to(device=device), target.to(device=device)\n", + "\n", + " # Process data by Hopfield-based network.\n", + " model_output = network.forward(input=data)\n", + " loss = binary_cross_entropy_with_logits(input=model_output, target=target, reduction=r'mean')\n", + "\n", + " # Compute performance measures of current model.\n", + " accuracy = (model_output.sigmoid().round() == target).to(dtype=torch.float32).mean()\n", + " accuracies.append(accuracy.detach().item())\n", + " losses.append(loss.detach().item())\n", + "\n", + " # Report progress of validation procedure.\n", + " return (sum(losses) / len(losses), sum(accuracies) / len(accuracies))\n", + "\n", + "\n", + "def operate(network: Module,\n", + " optimiser: AdamW,\n", + " data_loader_train: DataLoader,\n", + " data_loader_eval: DataLoader,\n", + " num_epochs: int = 1\n", + " ) -> Tuple[pd.DataFrame, pd.DataFrame]:\n", + " \"\"\"\n", + " Train the specified network by gradient descent using backpropagation.\n", + " \n", + " :param network: network instance to train\n", + " :param optimiser: optimiser instance responsible for updating network parameters\n", + " :param data_loader_train: data loader instance providing training data\n", + " :param data_loader_eval: data loader instance providing validation data\n", + " :param num_epochs: amount of epochs to train\n", + " :return: data frame comprising training as well as evaluation performance\n", + " \"\"\"\n", + " losses, accuracies = {r'train': [], r'eval': []}, {r'train': [], r'eval': []}\n", + " for epoch in range(num_epochs):\n", + " \n", + " # Train network.\n", + " performance = train_epoch(network, optimiser, data_loader_train)\n", + " losses[r'train'].append(performance[0])\n", + " accuracies[r'train'].append(performance[1])\n", + " \n", + " # Evaluate current model.\n", + " performance = eval_iter(network, data_loader_eval)\n", + " losses[r'eval'].append(performance[0])\n", + " accuracies[r'eval'].append(performance[1])\n", + " \n", + " # Report progress of training and validation procedures.\n", + " return pd.DataFrame(losses), pd.DataFrame(accuracies)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def set_seed(seed: int = 42) -> None:\n", + " \"\"\"\n", + " Set seed for all underlying (pseudo) random number sources.\n", + " \n", + " :param seed: seed to be used\n", + " :return: None\n", + " \"\"\"\n", + " torch.manual_seed(42)\n", + " torch.backends.cudnn.deterministic = True\n", + " torch.backends.cudnn.benchmark = False\n", + "\n", + "\n", + "def plot_performance(loss: pd.DataFrame,\n", + " accuracy: pd.DataFrame,\n", + " log_file: str\n", + " ) -> None:\n", + " \"\"\"\n", + " Plot and save loss and accuracy.\n", + " \n", + " :param loss: loss to be plotted\n", + " :param accuracy: accuracy to be plotted\n", + " :param log_file: target file for storing the resulting plot\n", + " :return: None\n", + " \"\"\"\n", + " fig, ax = plt.subplots(1, 2, figsize=(20, 7))\n", + " \n", + " loss_plot = sns.lineplot(data=loss, ax=ax[0])\n", + " loss_plot.set(xlabel=r'Epoch', ylabel=r'Cross-entropy Loss')\n", + " \n", + " accuracy_plot = sns.lineplot(data=accuracy, ax=ax[1])\n", + " accuracy_plot.set(xlabel=r'Epoch', ylabel=r'Accuracy')\n", + " \n", + " ax[1].yaxis.set_label_position(r'right')\n", + " fig.tight_layout()\n", + " fig.savefig(log_file)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Hopfield-based Network

\n", + "\n", + "The instantiation of the heart of a Hopfield-based network, the module Hopfield, is rather straightforward. Only one argument, the size of the input, needs to be set.\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ArgumentValue (used in this demo)Description
input_sizenum_bits (8)Size (depth) of the input (state pattern).
...defaultThe remaining arguments are not explicitly used in this example.
\n", + "\n", + "An additional output projection is defined, to downproject the result of Hopfield to the correct output size. Afterwards, everything is wrapped into a container of type torch.nn.Sequential and a corresponding optimiser is defined. Now the Hopfield-based network and all auxiliaries are set up and ready to associate!" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "set_seed()\n", + "hopfield = Hopfield(\n", + " input_size=bit_pattern_set.num_bits)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "output_projection = Linear(in_features=hopfield.output_size * bit_pattern_set.num_instances, out_features=1)\n", + "network = Sequential(hopfield, Flatten(), output_projection, Flatten(start_dim=0)).to(device=device)\n", + "optimiser = AdamW(params=network.parameters(), lr=1e-3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Operate Hopfield-based Network

" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "losses, accuracies = operate(\n", + " network=network,\n", + " optimiser=optimiser,\n", + " data_loader_train=data_loader_train,\n", + " data_loader_eval=data_loader_eval,\n", + " num_epochs=250)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance(loss=losses, accuracy=accuracies, log_file=f'{log_dir}/hopfield_base.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Adapt Hopfield-based Network

\n", + "

We can now explore the functionality of our Hopfield layer Hopfield.

\n", + "\n", + "As described in the paper the Hopfield layer allows:\n", + "- association of two sets\n", + "- multiple updates\n", + "- variable beta\n", + "- changing the dimension of the associative space\n", + "- pattern normalization\n", + "- static patterns for fixed pattern search\n", + "\n", + "This time, additional arguments are set to increase the training as well as the validation performance of the Hopfield-based network.\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ArgumentValue (used in this demo)Description
input_sizenum_bits (8)Size (depth) of the input (state pattern).
hidden_size8Size (depth) of the association space.
num_heads8Amount of parallel association heads.
update_steps_max3Number of updates in one Hopfield head.
scaling0.25Beta parameter that determines the kind of fixed point.
dropout0.5Dropout probability applied on the association matrix.
...defaultThe remaining arguments are not explicitly used in this example.
" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "set_seed()\n", + "hopfield = Hopfield(\n", + " input_size=bit_pattern_set.num_bits,\n", + " hidden_size=8,\n", + " num_heads=8,\n", + " update_steps_max=3,\n", + " scaling=0.25,\n", + " dropout=0.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "output_projection = Linear(in_features=hopfield.output_size * bit_pattern_set.num_instances, out_features=1)\n", + "network = Sequential(hopfield, Flatten(), output_projection, Flatten(start_dim=0)).to(device=device)\n", + "optimiser = AdamW(params=network.parameters(), lr=1e-3)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "losses, accuracies = operate(\n", + " network=network,\n", + " optimiser=optimiser,\n", + " data_loader_train=data_loader_train,\n", + " data_loader_eval=data_loader_eval,\n", + " num_epochs=250)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance(loss=losses, accuracy=accuracies, log_file=f'{log_dir}/hopfield_adapted.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Hopfield-based Pooling

\n", + "\n", + "The previous examples manually downprojected the result of Hopfield by applying a linear layer afterwards. It would've also been possible to apply some kind of pooling. Exactly for such use cases, the module HopfieldPooling might be the right choice. Internally, a state pattern is trained, which in turn is used to compute pooling weights with respect to the input." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "set_seed()\n", + "hopfield_pooling = HopfieldPooling(\n", + " input_size=bit_pattern_set.num_bits)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "output_projection = Linear(in_features=hopfield_pooling.output_size, out_features=1)\n", + "network = Sequential(hopfield_pooling, output_projection, Flatten(start_dim=0)).to(device=device)\n", + "optimiser = AdamW(params=network.parameters(), lr=1e-3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Operate Hopfield-based Pooling

" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "losses, accuracies = operate(\n", + " network=network,\n", + " optimiser=optimiser,\n", + " data_loader_train=data_loader_train,\n", + " data_loader_eval=data_loader_eval,\n", + " num_epochs=250)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance(loss=losses, accuracy=accuracies, log_file=f'{log_dir}/hopfield_pooling.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Adapt Hopfield-based Pooling

\n", + "

We can now again explore the functionality of our Hopfield-based pooling layer HopfieldPooling.

\n", + "\n", + "Again, additional arguments are set to increase the training as well as the validation performance of the Hopfield-based pooling.\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ArgumentValue (used in this demo)Description
input_sizenum_bits (8)Size (depth) of the input (state pattern).
hidden_size8Size (depth) of the association space.
num_heads8Amount of parallel association heads.
update_steps_max3Number of updates in one Hopfield head.
scaling0.25Beta parameter that determines the kind of fixed point.
dropout0.5Dropout probability applied on the association matrix.
...defaultThe remaining arguments are not explicitly used in this example.
" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "set_seed()\n", + "hopfield_pooling = HopfieldPooling(\n", + " input_size=bit_pattern_set.num_bits,\n", + " hidden_size=8,\n", + " num_heads=8,\n", + " update_steps_max=3,\n", + " scaling=0.25,\n", + " dropout=0.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "output_projection = Linear(in_features=hopfield_pooling.output_size, out_features=1)\n", + "network = Sequential(hopfield_pooling, output_projection, Flatten(start_dim=0)).to(device=device)\n", + "optimiser = AdamW(params=network.parameters(), lr=1e-3)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "losses, accuracies = operate(\n", + " network=network,\n", + " optimiser=optimiser,\n", + " data_loader_train=data_loader_train,\n", + " data_loader_eval=data_loader_eval,\n", + " num_epochs=250)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance(loss=losses, accuracy=accuracies, log_file=f'{log_dir}/hopfield_pooling_adapted.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Hopfield-based Lookup

\n", + "\n", + "In contrast to the first Hopfield setting, in which the state patterns as well as the stored patterns are directly dependent on the input, HopfieldLayer employs a trainable but fixed stored pattern matrix, which in turn acts as a learnable lookup table." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "bit_samples_unique = [_[r'data'] for _ in data_loader_train]\n", + "bit_samples_unique = torch.cat(bit_samples_unique).view(-1, bit_samples_unique[0].shape[2]).unique(dim=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "set_seed()\n", + "hopfield_lookup = HopfieldLayer(\n", + " input_size=bit_pattern_set.num_bits,\n", + " quantity=len(bit_samples_unique))" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "output_projection = Linear(in_features=hopfield_lookup.output_size * bit_pattern_set.num_instances, out_features=1)\n", + "network = Sequential(hopfield_lookup, Flatten(start_dim=1), output_projection, Flatten(start_dim=0)).to(device=device)\n", + "optimiser = AdamW(params=network.parameters(), lr=1e-3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Operate Hopfield-based Lookup

" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "losses, accuracies = operate(\n", + " network=network,\n", + " optimiser=optimiser,\n", + " data_loader_train=data_loader_train,\n", + " data_loader_eval=data_loader_eval,\n", + " num_epochs=250)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance(loss=losses, accuracy=accuracies, log_file=f'{log_dir}/hopfield_lookup.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Adapt Hopfield-based Lookup

\n", + "

We can now again explore the functionality of our Hopfield-based lookup layer HopfieldLayer.

\n", + "\n", + "This lookup setting is especially pronounced, if the state patterns are initialized with a subset of the training set (and optionally provide the corresponding training targets as pattern projection inputs).\n", + "\n", + "Again, additional arguments are set to increase the training as well as the validation performance of the Hopfield-based lookup.\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ArgumentValue (used in this demo)Description
lookup_weights_as_separatedTrueSeparate lookup weights from lookup target weights (e.g. to set lookup target weights separately).
lookup_targets_as_trainableFalseEmploy trainable lookup target weights (used as pattern projection input).
" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "set_seed()\n", + "hopfield_lookup = HopfieldLayer(\n", + " input_size=bit_pattern_set.num_bits,\n", + " quantity=len(bit_samples_unique),\n", + " lookup_weights_as_separated=True,\n", + " lookup_targets_as_trainable=False,\n", + " normalize_stored_pattern_affine=True,\n", + " normalize_pattern_projection_affine=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Initialize the trainable but fixed stored patterns with all unique samples from the training set. In this way, the Hopfield-based lookup already starts with meaningful stored patterns (instead of random noise). This may enhance the performance of the network, especially at the beginning of the training." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "with torch.no_grad():\n", + " hopfield_lookup.lookup_weights[:] = bit_samples_unique.unsqueeze(dim=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "output_projection = Linear(in_features=hopfield_lookup.output_size * bit_pattern_set.num_instances, out_features=1)\n", + "network = Sequential(hopfield_lookup, Flatten(start_dim=1), output_projection, Flatten(start_dim=0)).to(device=device)\n", + "optimiser = AdamW(params=network.parameters(), lr=1e-3)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "losses, accuracies = operate(\n", + " network=network,\n", + " optimiser=optimiser,\n", + " data_loader_train=data_loader_train,\n", + " data_loader_eval=data_loader_eval,\n", + " num_epochs=250)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance(loss=losses, accuracy=accuracies, log_file=f'{log_dir}/hopfield_lookup_adapted.pdf')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/src/mhnfs/hopfield/examples/bit_pattern/modules/__init__.py b/src/mhnfs/hopfield/examples/bit_pattern/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c11713739acb1aca3b32cca53acf0c3faf1fa9f6 --- /dev/null +++ b/src/mhnfs/hopfield/examples/bit_pattern/modules/__init__.py @@ -0,0 +1,898 @@ +import torch +import torch.nn as nn + +from math import sqrt +from torch import Tensor +from torch.nn import Module, Parameter +from typing import Optional, Tuple, Union + +from .activation import HopfieldCore + + +class Hopfield(Module): + """ + Module with underlying Hopfield association. + """ + + def __init__(self, + input_size: Optional[int] = None, + hidden_size: Optional[int] = None, + output_size: Optional[int] = None, + pattern_size: Optional[int] = None, + num_heads: int = 1, + scaling: Optional[Union[float, Tensor]] = None, + update_steps_max: Optional[Union[int, Tensor]] = 0, + update_steps_eps: Union[float, Tensor] = 1e-4, + + normalize_stored_pattern: bool = True, + normalize_stored_pattern_affine: bool = True, + normalize_state_pattern: bool = True, + normalize_state_pattern_affine: bool = True, + normalize_pattern_projection: bool = True, + normalize_pattern_projection_affine: bool = True, + normalize_hopfield_space: bool = False, + normalize_hopfield_space_affine: bool = False, + stored_pattern_as_static: bool = False, + state_pattern_as_static: bool = False, + pattern_projection_as_static: bool = False, + pattern_projection_as_connected: bool = False, + stored_pattern_size: Optional[int] = None, + pattern_projection_size: Optional[int] = None, + + batch_first: bool = True, + association_activation: Optional[str] = None, + dropout: float = 0.0, + input_bias: bool = True, + concat_bias_pattern: bool = False, + add_zero_association: bool = False, + disable_out_projection: bool = False + ): + """ + Initialise new instance of a Hopfield module. + + :param input_size: depth of the input (state pattern) + :param hidden_size: depth of the association space + :param output_size: depth of the output projection + :param pattern_size: depth of patterns to be selected + :param num_heads: amount of parallel association heads + :param scaling: scaling of association heads, often represented as beta (one entry per head) + :param update_steps_max: maximum count of association update steps (None equals to infinity) + :param update_steps_eps: minimum difference threshold between two consecutive association update steps + :param normalize_stored_pattern: apply normalization on stored patterns + :param normalize_stored_pattern_affine: additionally enable affine normalization of stored patterns + :param normalize_state_pattern: apply normalization on state patterns + :param normalize_state_pattern_affine: additionally enable affine normalization of state patterns + :param normalize_pattern_projection: apply normalization on the pattern projection + :param normalize_pattern_projection_affine: additionally enable affine normalization of pattern projection + :param normalize_hopfield_space: enable normalization of patterns in the Hopfield space + :param normalize_hopfield_space_affine: additionally enable affine normalization of patterns in Hopfield space + :param stored_pattern_as_static: interpret specified stored patterns as being static + :param state_pattern_as_static: interpret specified state patterns as being static + :param pattern_projection_as_static: interpret specified pattern projections as being static + :param pattern_projection_as_connected: connect pattern projection with stored pattern + :param stored_pattern_size: depth of input (stored pattern) + :param pattern_projection_size: depth of input (pattern projection) + :param batch_first: flag for specifying if the first dimension of data fed to "forward" reflects the batch size + :param association_activation: additional activation to be applied on the result of the Hopfield association + :param dropout: dropout probability applied on the association matrix + :param input_bias: bias to be added to input (state and stored pattern as well as pattern projection) + :param concat_bias_pattern: bias to be concatenated to stored pattern as well as pattern projection + :param add_zero_association: add a new batch of zeros to stored pattern as well as pattern projection + :param disable_out_projection: disable output projection + """ + super(Hopfield, self).__init__() + assert type(batch_first) == bool, f'"batch_first" needs to be a boolean, not {type(batch_first)}.' + assert (association_activation is None) or (type(association_activation) == str) + + # Initialise Hopfield association module. + self.association_core = HopfieldCore( + embed_dim=input_size, num_heads=num_heads, dropout=dropout, bias=input_bias, + add_bias_kv=concat_bias_pattern, add_zero_attn=add_zero_association, kdim=stored_pattern_size, + vdim=pattern_projection_size, head_dim=hidden_size, pattern_dim=pattern_size, out_dim=output_size, + disable_out_projection=disable_out_projection, key_as_static=stored_pattern_as_static, + query_as_static=state_pattern_as_static, value_as_static=pattern_projection_as_static, + value_as_connected=pattern_projection_as_connected, normalize_pattern=normalize_hopfield_space, + normalize_pattern_affine=normalize_hopfield_space_affine) + self.association_activation = None + if association_activation is not None: + self.association_activation = getattr(torch, association_activation, None) + + # Initialise stored pattern normalization. + self.norm_stored_pattern = None + if normalize_stored_pattern_affine: + assert normalize_stored_pattern, "affine normalization without normalization has no effect." + if normalize_stored_pattern: + normalized_shape = input_size if stored_pattern_size is None else stored_pattern_size + assert normalized_shape is not None, "stored pattern size required for setting up normalisation" + self.norm_stored_pattern = nn.LayerNorm( + normalized_shape=normalized_shape, elementwise_affine=normalize_stored_pattern_affine) + + # Initialise state pattern normalization. + self.norm_state_pattern = None + if normalize_state_pattern_affine: + assert normalize_state_pattern, "affine normalization without normalization has no effect." + if normalize_state_pattern: + assert input_size is not None, "input size required for setting up normalisation" + self.norm_state_pattern = nn.LayerNorm( + normalized_shape=input_size, elementwise_affine=normalize_state_pattern_affine) + + # Initialise pattern projection normalization. + self.norm_pattern_projection = None + if normalize_pattern_projection_affine: + assert normalize_pattern_projection, "affine normalization without normalization has no effect." + if normalize_pattern_projection: + normalized_shape = input_size if pattern_projection_size is None else pattern_projection_size + assert normalized_shape is not None, "pattern projection size required for setting up normalisation" + self.norm_pattern_projection = nn.LayerNorm( + normalized_shape=normalized_shape, elementwise_affine=normalize_pattern_projection_affine) + + # Initialise remaining auxiliary properties. + if self.association_core.static_execution: + self.__scaling = 1.0 if scaling is None else scaling + else: + assert self.association_core.head_dim > 0, f'invalid hidden dimension encountered.' + self.__scaling = (1.0 / sqrt(self.association_core.head_dim)) if scaling is None else scaling + self.__batch_first = batch_first + self.__update_steps_max = update_steps_max + self.__update_steps_eps = update_steps_eps + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset Hopfield association. + + :return: None + """ + for module in (self.association_core, self.norm_stored_pattern, + self.norm_state_pattern, self.norm_pattern_projection): + if hasattr(module, r'reset_parameters'): + module.reset_parameters() + + def _maybe_transpose(self, *args: Tuple[Tensor, ...]) -> Union[Tensor, Tuple[Tensor, ...]]: + """ + Eventually transpose specified data. + + :param args: tensors to eventually transpose (dependent on the state of "batch_first") + :return: eventually transposed tensors + """ + transposed_result = tuple(_.transpose(0, 1) for _ in args) if self.__batch_first else args + return transposed_result[0] if len(transposed_result) == 1 else transposed_result + + def _associate(self, data: Union[Tensor, Tuple[Tensor, Tensor, Tensor]], + return_raw_associations: bool = False, return_projected_patterns: bool = False, + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tuple[Optional[Tensor], ...]: + """ + Apply Hopfield association module on specified data. + + :param data: data to be processed by Hopfield core module + :param return_raw_associations: return raw association (softmax) values, unmodified + :param return_projected_patterns: return pattern projection values, unmodified + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: Hopfield-processed input data + """ + assert (type(data) == Tensor) or ((type(data) == tuple) and (len(data) == 3)), \ + r'either one tensor to be used as "stored pattern", "state pattern" and' \ + r' "pattern_projection" must be provided, or three separate ones.' + if type(data) == Tensor: + stored_pattern, state_pattern, pattern_projection = data, data, data + else: + stored_pattern, state_pattern, pattern_projection = data + + # Optionally transpose data. + stored_pattern, state_pattern, pattern_projection = self._maybe_transpose( + stored_pattern, state_pattern, pattern_projection) + + # Optionally apply stored pattern normalization. + if self.norm_stored_pattern is not None: + stored_pattern = self.norm_stored_pattern(input=stored_pattern.reshape( + shape=(-1, stored_pattern.shape[2]))).reshape(shape=stored_pattern.shape) + + # Optionally apply state pattern normalization. + if self.norm_state_pattern is not None: + state_pattern = self.norm_state_pattern(input=state_pattern.reshape( + shape=(-1, state_pattern.shape[2]))).reshape(shape=state_pattern.shape) + + # Optionally apply pattern projection normalization. + if self.norm_pattern_projection is not None: + pattern_projection = self.norm_pattern_projection(input=pattern_projection.reshape( + shape=(-1, pattern_projection.shape[2]))).reshape(shape=pattern_projection.shape) + + # Apply Hopfield association and optional activation function. + return self.association_core( + query=state_pattern, key=stored_pattern, value=pattern_projection, + key_padding_mask=stored_pattern_padding_mask, need_weights=False, attn_mask=association_mask, + scaling=self.__scaling, update_steps_max=self.__update_steps_max, update_steps_eps=self.__update_steps_eps, + return_raw_associations=return_raw_associations, return_pattern_projections=return_projected_patterns) + + def forward(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Apply Hopfield association on specified data. + + :param input: data to be processed by Hopfield association module + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: Hopfield-processed input data + """ + association_output = self._maybe_transpose(self._associate( + data=input, return_raw_associations=False, + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask)[0]) + if self.association_activation is not None: + association_output = self.association_activation(association_output) + return association_output + + def get_association_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield association matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: association matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self._associate( + data=input, return_raw_associations=True, + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask)[2] + + def get_projected_pattern_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield projected pattern matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: pattern projection matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self._associate( + data=input, return_projected_patterns=True, + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask)[3] + + @property + def batch_first(self) -> bool: + return self.__batch_first + + @property + def scaling(self) -> Union[float, Tensor]: + return self.__scaling.clone() if type(self.__scaling) == Tensor else self.__scaling + + @property + def stored_pattern_dim(self) -> Optional[int]: + return self.association_core.kdim + + @property + def state_pattern_dim(self) -> Optional[int]: + return self.association_core.embed_dim + + @property + def pattern_projection_dim(self) -> Optional[int]: + return self.association_core.vdim + + @property + def input_size(self) -> Optional[int]: + return self.state_pattern_dim + + @property + def hidden_size(self) -> Optional[int]: + return self.association_core.head_dim + + @property + def output_size(self) -> Optional[int]: + return self.association_core.out_dim + + @property + def pattern_size(self) -> Optional[int]: + return self.association_core.pattern_dim + + @property + def update_steps_max(self) -> Optional[Union[int, Tensor]]: + return self.__update_steps_max.clone() if type(self.__update_steps_max) == Tensor else self.__update_steps_max + + @property + def update_steps_eps(self) -> Optional[Union[float, Tensor]]: + return self.__update_steps_eps.clone() if type(self.__update_steps_eps) == Tensor else self.__update_steps_eps + + @property + def stored_pattern_as_static(self) -> bool: + return self.association_core.key_as_static + + @property + def state_pattern_as_static(self) -> bool: + return self.association_core.query_as_static + + @property + def pattern_projection_as_static(self) -> bool: + return self.association_core.value_as_static + + @property + def normalize_stored_pattern(self) -> bool: + return self.norm_stored_pattern is not None + + @property + def normalize_stored_pattern_affine(self) -> bool: + return self.normalize_stored_pattern and self.norm_stored_pattern.elementwise_affine + + @property + def normalize_state_pattern(self) -> bool: + return self.norm_state_pattern is not None + + @property + def normalize_state_pattern_affine(self) -> bool: + return self.normalize_state_pattern and self.norm_state_pattern.elementwise_affine + + @property + def normalize_pattern_projection(self) -> bool: + return self.norm_pattern_projection is not None + + @property + def normalize_pattern_projection_affine(self) -> bool: + return self.normalize_pattern_projection and self.norm_pattern_projection.elementwise_affine + + @property + def normalize_hopfield_space(self) -> bool: + return self.hopfield.normalize_hopfield_space + + @property + def normalize_hopfield_space_affine(self) -> bool: + return self.hopfield.normalize_hopfield_space_affine + + +class HopfieldPooling(Module): + """ + Wrapper class encapsulating a trainable but fixed state pattern and "Hopfield" in + one combined module to be used as a Hopfield-based pooling layer. + """ + + def __init__(self, + input_size: int, + hidden_size: Optional[int] = None, + output_size: Optional[int] = None, + pattern_size: Optional[int] = None, + num_heads: int = 1, + scaling: Optional[Union[float, Tensor]] = None, + update_steps_max: Optional[Union[int, Tensor]] = 0, + update_steps_eps: Union[float, Tensor] = 1e-4, + + normalize_stored_pattern: bool = True, + normalize_stored_pattern_affine: bool = True, + normalize_state_pattern: bool = True, + normalize_state_pattern_affine: bool = True, + normalize_pattern_projection: bool = True, + normalize_pattern_projection_affine: bool = True, + normalize_hopfield_space: bool = False, + normalize_hopfield_space_affine: bool = False, + stored_pattern_as_static: bool = False, + state_pattern_as_static: bool = False, + pattern_projection_as_static: bool = False, + pattern_projection_as_connected: bool = False, + stored_pattern_size: Optional[int] = None, + pattern_projection_size: Optional[int] = None, + + batch_first: bool = True, + association_activation: Optional[str] = None, + dropout: float = 0.0, + input_bias: bool = True, + concat_bias_pattern: bool = False, + add_zero_association: bool = False, + disable_out_projection: bool = False, + quantity: int = 1, + trainable: bool = True + ): + """ + Initialise a new instance of a Hopfield-based pooling layer. + + :param input_size: depth of the input (state pattern) + :param hidden_size: depth of the association space + :param output_size: depth of the output projection + :param pattern_size: depth of patterns to be selected + :param num_heads: amount of parallel association heads + :param scaling: scaling of association heads, often represented as beta (one entry per head) + :param update_steps_max: maximum count of association update steps (None equals to infinity) + :param update_steps_eps: minimum difference threshold between two consecutive association update steps + :param normalize_stored_pattern: apply normalization on stored patterns + :param normalize_stored_pattern_affine: additionally enable affine normalization of stored patterns + :param normalize_state_pattern: apply normalization on state patterns + :param normalize_state_pattern_affine: additionally enable affine normalization of state patterns + :param normalize_pattern_projection: apply normalization on the pattern projection + :param normalize_pattern_projection_affine: additionally enable affine normalization of pattern projection + :param normalize_hopfield_space: enable normalization of patterns in the Hopfield space + :param normalize_hopfield_space_affine: additionally enable affine normalization of patterns in Hopfield space + :param stored_pattern_as_static: interpret specified stored patterns as being static + :param state_pattern_as_static: interpret specified state patterns as being static + :param pattern_projection_as_static: interpret specified pattern projections as being static + :param pattern_projection_as_connected: connect pattern projection with stored pattern + :param stored_pattern_size: depth of input (stored pattern) + :param pattern_projection_size: depth of input (pattern projection) + :param batch_first: flag for specifying if the first dimension of data fed to "forward" reflects the batch size + :param association_activation: additional activation to be applied on the result of the Hopfield association + :param dropout: dropout probability applied on the association matrix + :param input_bias: bias to be added to input (state and stored pattern as well as pattern projection) + :param concat_bias_pattern: bias to be concatenated to stored pattern as well as pattern projection + :param add_zero_association: add a new batch of zeros to stored pattern as well as pattern projection + :param disable_out_projection: disable output projection + :param quantity: amount of state patterns + :param trainable: state pattern used for pooling is trainable + """ + super(HopfieldPooling, self).__init__() + self.hopfield = Hopfield( + input_size=input_size, hidden_size=hidden_size, output_size=output_size, pattern_size=pattern_size, + num_heads=num_heads, scaling=scaling, update_steps_max=update_steps_max, update_steps_eps=update_steps_eps, + normalize_stored_pattern=normalize_stored_pattern, + normalize_stored_pattern_affine=normalize_stored_pattern_affine, + normalize_state_pattern=normalize_state_pattern, + normalize_state_pattern_affine=normalize_state_pattern_affine, + normalize_pattern_projection=normalize_pattern_projection, + normalize_pattern_projection_affine=normalize_pattern_projection_affine, + normalize_hopfield_space=normalize_hopfield_space, + normalize_hopfield_space_affine=normalize_hopfield_space_affine, + stored_pattern_as_static=stored_pattern_as_static, state_pattern_as_static=state_pattern_as_static, + pattern_projection_as_static=pattern_projection_as_static, + pattern_projection_as_connected=pattern_projection_as_connected, stored_pattern_size=stored_pattern_size, + pattern_projection_size=pattern_projection_size, batch_first=batch_first, + association_activation=association_activation, dropout=dropout, input_bias=input_bias, + concat_bias_pattern=concat_bias_pattern, add_zero_association=add_zero_association, + disable_out_projection=disable_out_projection) + self._quantity = quantity + pooling_weight_size = self.hopfield.hidden_size if state_pattern_as_static else self.hopfield.input_size + self.pooling_weights = nn.Parameter(torch.empty(size=(*( + (1, quantity) if batch_first else (quantity, 1) + ), input_size if pooling_weight_size is None else pooling_weight_size)), requires_grad=trainable) + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset pooling weights and underlying Hopfield association. + + :return: None + """ + if hasattr(self.hopfield, r'reset_parameters'): + self.hopfield.reset_parameters() + + # Explicitly initialise pooling weights. + nn.init.normal_(self.pooling_weights, mean=0.0, std=0.02) + + def _prepare_input(self, input: Union[Tensor, Tuple[Tensor, Tensor]]) -> Tuple[Tensor, Tensor, Tensor]: + """ + Prepare input for Hopfield association. + + :param input: data to be prepared + :return: stored pattern, expanded state pattern as well as pattern projection + """ + assert (type(input) == Tensor) or ((type(input) == tuple) and (len(input) == 2)), \ + r'either one tensor to be used as "stored pattern" and' \ + r' "pattern_projection" must be provided, or two separate ones.' + if type(input) == Tensor: + stored_pattern, pattern_projection = input, input + else: + stored_pattern, pattern_projection = input + + batch_size = stored_pattern.shape[0 if self.batch_first else 1] + return stored_pattern, self.pooling_weights.expand(size=(*( + (batch_size, self.quantity) if self.batch_first else (self.quantity, batch_size) + ), self.pooling_weights.shape[2])), pattern_projection + + def forward(self, input: Union[Tensor, Tuple[Tensor, Tensor]], stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Compute Hopfield-based pooling on specified data. + + :param input: data to be pooled + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: Hopfield-pooled input data + """ + return self.hopfield( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask).flatten(start_dim=1) + + def get_association_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield association matrix used for pooling gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: association matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self.hopfield.get_association_matrix( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + def get_projected_pattern_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield projected pattern matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: pattern projection matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self.hopfield.get_projected_pattern_matrix( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + @property + def batch_first(self) -> bool: + return self.hopfield.batch_first + + @property + def scaling(self) -> Union[float, Tensor]: + return self.hopfield.scaling + + @property + def stored_pattern_dim(self) -> Optional[int]: + return self.hopfield.stored_pattern_dim + + @property + def state_pattern_dim(self) -> Optional[int]: + return self.hopfield.state_pattern_dim + + @property + def pattern_projection_dim(self) -> Optional[int]: + return self.hopfield.pattern_projection_dim + + @property + def input_size(self) -> Optional[int]: + return self.hopfield.input_size + + @property + def hidden_size(self) -> int: + return self.hopfield.hidden_size + + @property + def output_size(self) -> Optional[int]: + return self.hopfield.output_size + + @property + def pattern_size(self) -> Optional[int]: + return self.hopfield.pattern_size + + @property + def quantity(self) -> int: + return self._quantity + + @property + def update_steps_max(self) -> Optional[Union[int, Tensor]]: + return self.hopfield.update_steps_max + + @property + def update_steps_eps(self) -> Optional[Union[float, Tensor]]: + return self.hopfield.update_steps_eps + + @property + def stored_pattern_as_static(self) -> bool: + return self.hopfield.stored_pattern_as_static + + @property + def state_pattern_as_static(self) -> bool: + return self.hopfield.state_pattern_as_static + + @property + def pattern_projection_as_static(self) -> bool: + return self.hopfield.pattern_projection_as_static + + @property + def normalize_stored_pattern(self) -> bool: + return self.hopfield.normalize_stored_pattern + + @property + def normalize_stored_pattern_affine(self) -> bool: + return self.hopfield.normalize_stored_pattern_affine + + @property + def normalize_state_pattern(self) -> bool: + return self.hopfield.normalize_state_pattern + + @property + def normalize_state_pattern_affine(self) -> bool: + return self.hopfield.normalize_state_pattern_affine + + @property + def normalize_pattern_projection(self) -> bool: + return self.hopfield.normalize_pattern_projection + + @property + def normalize_pattern_projection_affine(self) -> bool: + return self.hopfield.normalize_pattern_projection_affine + + +class HopfieldLayer(Module): + """ + Wrapper class encapsulating a trainable but fixed stored pattern, pattern projection and "Hopfield" in + one combined module to be used as a Hopfield-based pooling layer. + """ + + def __init__(self, + input_size: int, + hidden_size: Optional[int] = None, + output_size: Optional[int] = None, + pattern_size: Optional[int] = None, + num_heads: int = 1, + scaling: Optional[Union[float, Tensor]] = None, + update_steps_max: Optional[Union[int, Tensor]] = 0, + update_steps_eps: Union[float, Tensor] = 1e-4, + lookup_weights_as_separated: bool = False, + lookup_targets_as_trainable: bool = True, + + normalize_stored_pattern: bool = True, + normalize_stored_pattern_affine: bool = True, + normalize_state_pattern: bool = True, + normalize_state_pattern_affine: bool = True, + normalize_pattern_projection: bool = True, + normalize_pattern_projection_affine: bool = True, + normalize_hopfield_space: bool = False, + normalize_hopfield_space_affine: bool = False, + stored_pattern_as_static: bool = False, + state_pattern_as_static: bool = False, + pattern_projection_as_static: bool = False, + pattern_projection_as_connected: bool = False, + stored_pattern_size: Optional[int] = None, + pattern_projection_size: Optional[int] = None, + + batch_first: bool = True, + association_activation: Optional[str] = None, + dropout: float = 0.0, + input_bias: bool = True, + concat_bias_pattern: bool = False, + add_zero_association: bool = False, + disable_out_projection: bool = False, + quantity: int = 1, + trainable: bool = True + ): + """ + Initialise a new instance of a Hopfield-based lookup layer. + + :param input_size: depth of the input (state pattern) + :param hidden_size: depth of the association space + :param output_size: depth of the output projection + :param pattern_size: depth of patterns to be selected + :param num_heads: amount of parallel association heads + :param scaling: scaling of association heads, often represented as beta (one entry per head) + :param update_steps_max: maximum count of association update steps (None equals to infinity) + :param update_steps_eps: minimum difference threshold between two consecutive association update steps + :param lookup_weights_as_separated: separate lookup weights from lookup target weights + :param lookup_targets_as_trainable: employ trainable lookup target weights (used as pattern projection input) + :param normalize_stored_pattern: apply normalization on stored patterns + :param normalize_stored_pattern_affine: additionally enable affine normalization of stored patterns + :param normalize_state_pattern: apply normalization on state patterns + :param normalize_state_pattern_affine: additionally enable affine normalization of state patterns + :param normalize_pattern_projection: apply normalization on the pattern projection + :param normalize_pattern_projection_affine: additionally enable affine normalization of pattern projection + :param normalize_hopfield_space: enable normalization of patterns in the Hopfield space + :param normalize_hopfield_space_affine: additionally enable affine normalization of patterns in Hopfield space + :param stored_pattern_as_static: interpret specified stored patterns as being static + :param state_pattern_as_static: interpret specified state patterns as being static + :param pattern_projection_as_static: interpret specified pattern projections as being static + :param pattern_projection_as_connected: connect pattern projection with stored pattern + :param stored_pattern_size: depth of input (stored pattern) + :param pattern_projection_size: depth of input (pattern projection) + :param batch_first: flag for specifying if the first dimension of data fed to "forward" reflects the batch size + :param association_activation: additional activation to be applied on the result of the Hopfield association + :param dropout: dropout probability applied on the association matrix + :param input_bias: bias to be added to input (state and stored pattern as well as pattern projection) + :param concat_bias_pattern: bias to be concatenated to stored pattern as well as pattern projection + :param add_zero_association: add a new batch of zeros to stored pattern as well as pattern projection + :param disable_out_projection: disable output projection + :param quantity: amount of stored patterns + :param trainable: stored pattern used for lookup is trainable + """ + super(HopfieldLayer, self).__init__() + self.hopfield = Hopfield( + input_size=input_size, hidden_size=hidden_size, output_size=output_size, pattern_size=pattern_size, + num_heads=num_heads, scaling=scaling, update_steps_max=update_steps_max, update_steps_eps=update_steps_eps, + normalize_stored_pattern=normalize_stored_pattern, + normalize_stored_pattern_affine=normalize_stored_pattern_affine, + normalize_state_pattern=normalize_state_pattern, + normalize_state_pattern_affine=normalize_state_pattern_affine, + normalize_pattern_projection=normalize_pattern_projection, + normalize_pattern_projection_affine=normalize_pattern_projection_affine, + normalize_hopfield_space=normalize_hopfield_space, + normalize_hopfield_space_affine=normalize_hopfield_space_affine, + stored_pattern_as_static=stored_pattern_as_static, state_pattern_as_static=state_pattern_as_static, + pattern_projection_as_static=pattern_projection_as_static, + pattern_projection_as_connected=pattern_projection_as_connected, stored_pattern_size=stored_pattern_size, + pattern_projection_size=pattern_projection_size, batch_first=batch_first, + association_activation=association_activation, dropout=dropout, input_bias=input_bias, + concat_bias_pattern=concat_bias_pattern, add_zero_association=add_zero_association, + disable_out_projection=disable_out_projection) + self._quantity = quantity + lookup_weight_size = self.hopfield.hidden_size if stored_pattern_as_static else self.hopfield.stored_pattern_dim + self.lookup_weights = nn.Parameter(torch.empty(size=(*( + (1, quantity) if batch_first else (quantity, 1) + ), input_size if lookup_weight_size is None else lookup_weight_size)), requires_grad=trainable) + + if lookup_weights_as_separated: + target_weight_size = self.lookup_weights.shape[ + 2] if pattern_projection_size is None else pattern_projection_size + self.target_weights = nn.Parameter(torch.empty(size=(*( + (1, quantity) if batch_first else (quantity, 1) + ), target_weight_size)), requires_grad=lookup_targets_as_trainable) + else: + self.register_parameter(name=r'target_weights', param=None) + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset lookup and lookup target weights, including underlying Hopfield association. + + :return: None + """ + if hasattr(self.hopfield, r'reset_parameters'): + self.hopfield.reset_parameters() + + # Explicitly initialise lookup and target weights. + nn.init.normal_(self.lookup_weights, mean=0.0, std=0.02) + if self.target_weights is not None: + nn.init.normal_(self.target_weights, mean=0.0, std=0.02) + + def _prepare_input(self, input: Tensor) -> Tuple[Tensor, Tensor, Tensor]: + """ + Prepare input for Hopfield association. + + :param input: data to be prepared + :return: stored pattern, expanded state pattern as well as pattern projection + """ + batch_size = input.shape[0 if self.batch_first else 1] + stored_pattern = self.lookup_weights.expand(size=(*( + (batch_size, self.quantity) if self.batch_first else (self.quantity, batch_size) + ), self.lookup_weights.shape[2])) + if self.target_weights is None: + pattern_projection = stored_pattern + else: + pattern_projection = self.target_weights.expand(size=(*( + (batch_size, self.quantity) if self.batch_first else (self.quantity, batch_size) + ), self.target_weights.shape[2])) + + return stored_pattern, input, pattern_projection + + def forward(self, input: Tensor, stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Compute Hopfield-based lookup on specified data. + + :param input: data to used in lookup + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: result of Hopfield-based lookup on input data + """ + return self.hopfield( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + def get_association_matrix(self, input: Tensor, stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield association matrix used for lookup gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: association matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self.hopfield.get_association_matrix( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + def get_projected_pattern_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield projected pattern matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: pattern projection matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self.hopfield.get_projected_pattern_matrix( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + @property + def batch_first(self) -> bool: + return self.hopfield.batch_first + + @property + def scaling(self) -> Union[float, Tensor]: + return self.hopfield.scaling + + @property + def stored_pattern_dim(self) -> Optional[int]: + return self.hopfield.stored_pattern_dim + + @property + def state_pattern_dim(self) -> Optional[int]: + return self.hopfield.state_pattern_dim + + @property + def pattern_projection_dim(self) -> Optional[int]: + return self.hopfield.pattern_projection_dim + + @property + def input_size(self) -> Optional[int]: + return self.hopfield.input_size + + @property + def hidden_size(self) -> int: + return self.hopfield.hidden_size + + @property + def output_size(self) -> Optional[int]: + return self.hopfield.output_size + + @property + def pattern_size(self) -> Optional[int]: + return self.hopfield.pattern_size + + @property + def quantity(self) -> int: + return self._quantity + + @property + def update_steps_max(self) -> Optional[Union[int, Tensor]]: + return self.hopfield.update_steps_max + + @property + def update_steps_eps(self) -> Optional[Union[float, Tensor]]: + return self.hopfield.update_steps_eps + + @property + def stored_pattern_as_static(self) -> bool: + return self.hopfield.stored_pattern_as_static + + @property + def state_pattern_as_static(self) -> bool: + return self.hopfield.state_pattern_as_static + + @property + def pattern_projection_as_static(self) -> bool: + return self.hopfield.pattern_projection_as_static + + @property + def normalize_stored_pattern(self) -> bool: + return self.hopfield.normalize_stored_pattern + + @property + def normalize_stored_pattern_affine(self) -> bool: + return self.hopfield.normalize_stored_pattern_affine + + @property + def normalize_state_pattern(self) -> bool: + return self.hopfield.normalize_state_pattern + + @property + def normalize_state_pattern_affine(self) -> bool: + return self.hopfield.normalize_state_pattern_affine + + @property + def normalize_pattern_projection(self) -> bool: + return self.hopfield.normalize_pattern_projection + + @property + def normalize_pattern_projection_affine(self) -> bool: + return self.hopfield.normalize_pattern_projection_affine diff --git a/src/mhnfs/hopfield/examples/bit_pattern/modules/activation.py b/src/mhnfs/hopfield/examples/bit_pattern/modules/activation.py new file mode 100644 index 0000000000000000000000000000000000000000..6dcd6e56cddb954cf6b049687bdf5e7783aa2bc9 --- /dev/null +++ b/src/mhnfs/hopfield/examples/bit_pattern/modules/activation.py @@ -0,0 +1,337 @@ +import torch +import torch.nn as nn + +from torch import Tensor +from torch.nn import Linear, Module, Parameter +from typing import Optional + +from .functional import hopfield_core_forward + +try: + from torch.nn.modules.linear import _LinearWithBias +except ImportError: + _LinearWithBias = None + + +class HopfieldCore(Module): + r"""Allows the model to jointly attend to information + from different representation subspaces. + See references: "Hopfield Networks is All You Need" and + "Attention Is All You Need" (on which this implementation is partly based on). + + .. math:: + \text{HopfieldHead}(Q, K, V) = \text{Concat}(head_1,\dots,head_h)W^O + \text{where} head_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V) + + Args: + embed_dim: total dimension of the model. + num_heads: parallel attention heads. + dropout: a Dropout layer on attn_output_weights. Default: 0.0. + bias: add bias as module parameter. Default: True. + add_bias_kv: add bias to the key and value sequences at dim=0. + add_zero_attn: add a new batch of zeros to the key and + value sequences at dim=1. + kdim: total number of features in key. Default: None. + vdim: total number of features in value. Default: None. + + Note: if kdim and vdim are None, they will be set to embed_dim such that + query, key, and value have the same number of features. + + Examples:: + + >>> hopfield_attn = HopfieldCore(embed_dim, num_heads) + >>> attn_output, attn_output_weights, attn_matrix = hopfield_attn(query, key, value) + """ + __annotations__ = { + 'bias_k': torch._jit_internal.Optional[torch.Tensor], + 'bias_v': torch._jit_internal.Optional[torch.Tensor], + } + + def __init__(self, + embed_dim=None, # type: Optional[int] + num_heads=1, # type: int + dropout=0.0, # type: float + bias=True, # type: bool + add_bias_kv=False, # type: bool + add_zero_attn=False, # type: bool + kdim=None, # type: Optional[int] + vdim=None, # type: Optional[int] + + head_dim=None, # type: Optional[int] + pattern_dim=None, # type: Optional[int] + out_dim=None, # type: Optional[int] + disable_out_projection=False, # type: bool + key_as_static=False, # type: bool + query_as_static=False, # type: bool + value_as_static=False, # type: bool + value_as_connected=False, # type: bool + normalize_pattern=False, # type: bool + normalize_pattern_affine=False # type: bool + ): + super(HopfieldCore, self).__init__() + + assert (type(key_as_static) == bool) and (type(query_as_static) == bool) and (type(value_as_static) == bool) + self.key_as_static, self.query_as_static, self.value_as_static = key_as_static, query_as_static, value_as_static + num_non_static = 3 - (self.key_as_static + self.query_as_static + self.value_as_static) + assert 0 <= num_non_static < 4 + + self.value_as_connected = value_as_connected + self.normalize_pattern, self.normalize_pattern_affine = normalize_pattern, normalize_pattern_affine + self.disable_out_projection = disable_out_projection + + # In case of a static-only executions, check corresponding projections and normalizations. + self.static_execution = self._check_execution_mode() + if self.static_execution: + embed_dim, kdim, vdim = None, None, None + if embed_dim is None: + assert self.static_execution, r'static-only execution requires all projections to be deactivated.' + + # Check and set all other properties, conditioned on . + self.embed_dim = embed_dim + self.kdim = kdim if kdim is not None else embed_dim + self.vdim = vdim if vdim is not None else embed_dim + self._qkv_same_embed_dim = all(( + self.kdim == embed_dim, self.vdim == embed_dim, pattern_dim is None, not self.value_as_connected)) + assert (not self.value_as_connected) or (self.kdim == self.vdim), r'key and value need to be of same dimension.' + + self.num_heads = num_heads + self.dropout = dropout + self.head_dim = None + self.pattern_dim = pattern_dim + self.virtual_hopfield_dim = None + self.virtual_pattern_dim = None + if not self.static_execution: + if head_dim is None: + self.head_dim = embed_dim // num_heads + assert self.head_dim * num_heads == self.embed_dim, "embed_dim must be divisible by num_heads." + else: + assert head_dim > 0, "dimension of the association space has to be positive." + self.head_dim = head_dim + if self.pattern_dim is None: + self.pattern_dim = self.head_dim + self.virtual_hopfield_dim = self.num_heads * self.head_dim + self.virtual_pattern_dim = self.num_heads * self.pattern_dim + + self.out_dim = embed_dim if out_dim is None else out_dim + assert disable_out_projection or (self.out_dim > 0), "output projection dimension has to be positive." + + if normalize_pattern_affine: + assert normalize_pattern, "affine pattern normalization without pattern normalization has no effect." + self.p_norm_weight = Parameter(torch.Tensor(head_dim)) + self.p_norm_bias = Parameter(torch.Tensor(head_dim)) + else: + self.register_parameter('p_norm_weight', None) + self.register_parameter('p_norm_bias', None) + + if self._qkv_same_embed_dim is False: + if query_as_static: + self.register_parameter('q_proj_weight', None) + else: + self.q_proj_weight = Parameter(torch.Tensor(self.virtual_hopfield_dim, embed_dim)) + if key_as_static: + self.register_parameter('k_proj_weight', None) + else: + self.k_proj_weight = Parameter(torch.Tensor(self.virtual_hopfield_dim, self.kdim)) + if value_as_static: + self.register_parameter('v_proj_weight', None) + else: + self.v_proj_weight = Parameter(torch.Tensor( + self.virtual_pattern_dim, + self.virtual_hopfield_dim if (value_as_connected and not key_as_static) else self.vdim)) + self.register_parameter('in_proj_weight', None) + else: + if num_non_static > 0: + self.in_proj_weight = Parameter(torch.empty( + (not query_as_static) * self.virtual_hopfield_dim + + (not key_as_static) * self.virtual_hopfield_dim + + (not value_as_static) * self.virtual_pattern_dim, embed_dim)) + else: + self.register_parameter('in_proj_weight', None) + self.register_parameter('q_proj_weight', None) + self.register_parameter('k_proj_weight', None) + self.register_parameter('v_proj_weight', None) + + if bias and (num_non_static > 0): + self.in_proj_bias = Parameter(torch.empty( + (not query_as_static) * self.virtual_hopfield_dim + + (not key_as_static) * self.virtual_hopfield_dim + self.virtual_pattern_dim)) + else: + self.register_parameter('in_proj_bias', None) + if disable_out_projection: + self.register_parameter('out_proj', None) + else: + if bias and _LinearWithBias is not None: + self.out_proj = _LinearWithBias(self.virtual_pattern_dim, self.out_dim) + else: + self.out_proj = Linear(self.virtual_pattern_dim, self.out_dim, bias=bias) + + self.bias_k, self.bias_v = None, None + if add_bias_kv: + if not key_as_static: + self.bias_k = Parameter(torch.empty(1, 1, self.virtual_hopfield_dim)) + if not value_as_static: + self.bias_v = Parameter(torch.empty(1, 1, self.virtual_hopfield_dim)) + assert not (self.bias_k is None and self.bias_v is None), r'cannot set key/value bias if both are static.' + + self.add_zero_attn = add_zero_attn + self.reset_parameters() + + def _check_execution_mode(self) -> bool: + return all(( + self.key_as_static, self.query_as_static, self.value_as_static, not self.value_as_connected, + not self.normalize_pattern, not self.normalize_pattern_affine, self.disable_out_projection + )) + + def reset_parameters(self): + if self.p_norm_weight is not None: + nn.init.ones_(self.p_norm_weight) + nn.init.zeros_(self.p_norm_bias) + + if self._qkv_same_embed_dim and (self.in_proj_weight is not None): + nn.init.normal_(self.in_proj_weight, mean=0.0, std=0.02) + else: + if self.q_proj_weight is not None: + nn.init.normal_(self.q_proj_weight, mean=0.0, std=0.02) + if self.k_proj_weight is not None: + nn.init.normal_(self.k_proj_weight, mean=0.0, std=0.02) + if self.v_proj_weight is not None: + nn.init.normal_(self.v_proj_weight, mean=0.0, std=0.02) + + if self.in_proj_bias is not None: + nn.init.constant_(self.in_proj_bias, 0.0) + if not self.disable_out_projection: + nn.init.normal_(self.out_proj.weight, mean=0.0, std=0.02) + if self.out_proj.bias is not None: + nn.init.constant_(self.out_proj.bias, 0.0) + if self.bias_k is not None: + nn.init.normal_(self.bias_k, mean=0.0, std=0.02) + if self.bias_v is not None: + nn.init.normal_(self.bias_v, mean=0.0, std=0.02) + + def __setstate__(self, state): + super(HopfieldCore, self).__setstate__(state) + + def forward(self, + query, # type: Tensor + key, # type: Tensor + value, # type: Tensor + key_padding_mask=None, # type: Optional[Tensor] + need_weights=True, # type: bool + attn_mask=None, # type: Optional[Tensor] + + scaling=None, # type: Optional[Tensor] + update_steps_max=0, # type: Optional[int] + update_steps_eps=1e-4, # type: float + return_raw_associations=False, # type: bool + return_pattern_projections=False # type: bool + ): + # type: (...) -> Tuple[Tensor, Optional[Tensor], Optional[Tensor]] + r""" + Args: + query, key, value: map a query and a set of key-value pairs to an output. + See "Attention Is All You Need" for more details. + See "Hopfield Networks is All You Need" for more details in the setting of Hopfield networks. + key_padding_mask: if provided, specified padding elements in the key will + be ignored by the attention. When given a binary mask and a value is True, + the corresponding value on the attention layer will be ignored. When given + a byte mask and a value is non-zero, the corresponding value on the attention + layer will be ignored. + need_weights: output attn_output_weights. + attn_mask: 2D or 3D mask that prevents attention to certain positions. A 2D mask will be broadcasted for all + the batches while a 3D mask allows to specify a different mask for the entries of each batch. + + scaling: scaling of association heads, often represented as beta (one entry per head). + update_steps_max: maximum count of association update steps (None equals to infinity). + update_steps_eps: minimum difference threshold between two consecutive association update steps. + return_raw_associations: return raw association (softmax) values, unmodified. + return_pattern_projections: return pattern projection values, unmodified. + + Shape: + - Inputs: + - query: :math:`(L, N, E)` where L is the target sequence length, N is the batch size, E is + the embedding dimension. + - key: :math:`(S, N, E)`, where S is the source sequence length, N is the batch size, E is + the embedding dimension. + - value: :math:`(S, N, E)` where S is the source sequence length, N is the batch size, E is + the embedding dimension. + - key_padding_mask: :math:`(N, S)` where N is the batch size, S is the source sequence length. + If a ByteTensor is provided, the non-zero positions will be ignored while the position + with the zero positions will be unchanged. If a BoolTensor is provided, the positions with the + value of ``True`` will be ignored while the position with the value of ``False`` will be unchanged. + - attn_mask: 2D mask :math:`(L, S)` where L is the target sequence length, S is the source sequence length. + 3D mask :math:`(N*num_heads, L, S)` where N is the batch size, L is the target sequence length, + S is the source sequence length. attn_mask ensure that position i is allowed to attend the unmasked + positions. If a ByteTensor is provided, the non-zero positions are not allowed to attend + while the zero positions will be unchanged. If a BoolTensor is provided, positions with ``True`` + is not allowed to attend while ``False`` values will be unchanged. If a FloatTensor + is provided, it will be added to the attention weight. + + - scaling: :math:`(num_heads,)`, where num_heads is the amount of heads. + + - Outputs: + - attn_output: :math:`(L, N, E)` where L is the target sequence length, N is the batch size, + E is the embedding dimension. + - attn_output_weights: :math:`(N, L, S)` where N is the batch size, + L is the target sequence length, S is the source sequence length. + - attn_raw: :math:``(N, num_heads, L, S)`, where N is the batch size, + L is the target sequence length, S is the source sequence length. + """ + if self.query_as_static and self.key_as_static: + assert query.shape[2] == key.shape[2], \ + f'query shape[2] of {query.shape[2]} and key shape[2] of {key.shape[2]} need to be equal' + head_dim, embed_dim_to_check = query.shape[2], query.shape[2] + else: + assert self.query_as_static or (query.shape[2] == self.embed_dim), \ + f'query shape[2] of {query.shape[2]} invalid, needs to be {self.embed_dim}.' + assert (not self.query_as_static) or (self.query_as_static and query.shape[2] == self.head_dim), \ + f'query shape[2] of {query.shape[2]} invalid, needs to be {self.head_dim}' + + assert self.key_as_static or (key.shape[2] == self.kdim), \ + f'key shape[2] of {key.shape[2]} invalid, needs to be {self.kdim}.' + assert (not self.key_as_static) or (self.key_as_static and key.shape[2] == self.head_dim), \ + f'key shape[2] of {key.shape[2]} invalid, needs to be {self.head_dim}' + head_dim, embed_dim_to_check = self.head_dim, self.head_dim if self.query_as_static else self.embed_dim + + assert self.value_as_static or (value.shape[2] == self.vdim), \ + f'value shape[2] of {value.shape[2]} invalid, needs to be {self.vdim}.' + assert any(( + not self.value_as_static, self.value_as_static and value.shape[2] == self.pattern_dim, + self.disable_out_projection) + ), f'value shape[2] of {value.shape[2]} invalid, needs to be {self.pattern_dim}' + + out_weights, out_bias = None, None + if not self.disable_out_projection: + out_weights, out_bias = self.out_proj.weight, self.out_proj.bias + + if not self._qkv_same_embed_dim: + return hopfield_core_forward( + query=query, key=key, value=value, embed_dim_to_check=embed_dim_to_check, num_heads=self.num_heads, + in_proj_weight=self.in_proj_weight, in_proj_bias=self.in_proj_bias, bias_k=self.bias_k, + bias_v=self.bias_v, add_zero_attn=self.add_zero_attn, dropout_p=self.dropout, + out_proj_weight=out_weights, out_proj_bias=out_bias, training=self.training, + key_padding_mask=key_padding_mask, need_weights=need_weights, attn_mask=attn_mask, + use_separate_proj_weight=True, q_proj_weight=self.q_proj_weight, k_proj_weight=self.k_proj_weight, + v_proj_weight=self.v_proj_weight, + + key_as_static=self.key_as_static, query_as_static=self.query_as_static, + value_as_static=self.value_as_static, value_as_connected=self.value_as_connected, + normalize_pattern=self.normalize_pattern, + p_norm_weight=self.p_norm_weight, p_norm_bias=self.p_norm_bias, + head_dim=head_dim, pattern_dim=self.pattern_dim, scaling=scaling, + update_steps_max=update_steps_max, update_steps_eps=update_steps_eps, + return_raw_associations=return_raw_associations, return_projected_patterns=return_pattern_projections) + else: + return hopfield_core_forward( + query=query, key=key, value=value, embed_dim_to_check=embed_dim_to_check, num_heads=self.num_heads, + in_proj_weight=self.in_proj_weight, in_proj_bias=self.in_proj_bias, bias_k=self.bias_k, + bias_v=self.bias_v, add_zero_attn=self.add_zero_attn, dropout_p=self.dropout, + out_proj_weight=out_weights, out_proj_bias=out_bias, training=self.training, + key_padding_mask=key_padding_mask, need_weights=need_weights, attn_mask=attn_mask, + + key_as_static=self.key_as_static, query_as_static=self.query_as_static, + value_as_static=self.value_as_static, value_as_connected=self.value_as_connected, + normalize_pattern=self.normalize_pattern, + p_norm_weight=self.p_norm_weight, p_norm_bias=self.p_norm_bias, + head_dim=head_dim, pattern_dim=self.pattern_dim, scaling=scaling, + update_steps_max=update_steps_max, update_steps_eps=update_steps_eps, + return_raw_associations=return_raw_associations, return_projected_patterns=return_pattern_projections) diff --git a/src/mhnfs/hopfield/examples/bit_pattern/modules/functional.py b/src/mhnfs/hopfield/examples/bit_pattern/modules/functional.py new file mode 100644 index 0000000000000000000000000000000000000000..2619c45fd87dc5f0348db393aa9b305611b4dd32 --- /dev/null +++ b/src/mhnfs/hopfield/examples/bit_pattern/modules/functional.py @@ -0,0 +1,450 @@ +import torch +import torch.nn as nn + +from torch.tensor import Tensor +from typing import Optional, Tuple, Union + + +def hopfield_core_forward(query, # type: Tensor + key, # type: Tensor + value, # type: Tensor + embed_dim_to_check, # type: int + num_heads, # type: int + in_proj_weight, # type: Optional[Tensor] + in_proj_bias, # type: Optional[Tensor] + bias_k, # type: Optional[Tensor] + bias_v, # type: Optional[Tensor] + add_zero_attn, # type: bool + dropout_p, # type: float + out_proj_weight, # type: Tensor + out_proj_bias, # type: Tensor + training=True, # type: bool + key_padding_mask=None, # type: Optional[Tensor] + need_weights=True, # type: bool + attn_mask=None, # type: Optional[Tensor] + use_separate_proj_weight=False, # type: bool + q_proj_weight=None, # type: Optional[Tensor] + k_proj_weight=None, # type: Optional[Tensor] + v_proj_weight=None, # type: Optional[Tensor] + static_k=None, # type: Optional[Tensor] + static_v=None, # type: Optional[Tensor] + + key_as_static=False, # type: bool + query_as_static=False, # type: bool + value_as_static=False, # type: bool + value_as_connected=False, # type: bool + normalize_pattern=False, # type: bool + p_norm_weight=None, # type: Optional[Tensor] + p_norm_bias=None, # type: Optional[Tensor] + head_dim=None, # type: Optional[int] + pattern_dim=None, # type: Optional[int] + scaling=None, # type: Optional[Union[float, Tensor]] + update_steps_max=0, # type: Optional[Union[int, Tensor]] + update_steps_eps=1e-4, # type: Union[float, Tensor] + return_raw_associations=False, # type: bool + return_projected_patterns=False # type: bool + ): + # type: (...) -> Tuple[Tensor, Optional[Tensor]] + r""" + Args: + query, key, value: map a query and a set of key-value pairs to an output. + See "Attention Is All You Need" for more details. + See "Hopfield Networks is All You Need" for more details in the setting of Hopfield networks. + embed_dim_to_check: total dimension of the model (in case of default head dimension). + num_heads: parallel attention heads. + in_proj_weight, in_proj_bias: input projection weight and bias. + bias_k, bias_v: bias of the key and value sequences to be added at dim=0. + add_zero_attn: add a new batch of zeros to the key and + value sequences at dim=1. + dropout_p: probability of an element to be zeroed. + out_proj_weight, out_proj_bias: the output projection weight and bias. + training: apply dropout if is ``True``. + key_padding_mask: if provided, specified padding elements in the key will + be ignored by the attention. This is an binary mask. When the value is True, + the corresponding value on the attention layer will be filled with -inf. + need_weights: output attn_output_weights. + attn_mask: 2D or 3D mask that prevents attention to certain positions. A 2D mask will be broadcasted for all + the batches while a 3D mask allows to specify a different mask for the entries of each batch. + use_separate_proj_weight: the function accept the proj. weights for query, key, + and value in different forms. If false, in_proj_weight will be used, which is + a combination of q_proj_weight, k_proj_weight, v_proj_weight. + q_proj_weight, k_proj_weight, v_proj_weight, in_proj_bias: input projection weight and bias. + static_k, static_v: static key and value used for attention operators. + + key_as_static: interpret specified key as being static. + query_as_static: interpret specified key as being static. + value_as_static: interpret specified key as being static. + value_as_connected: connect value projection with key projection. + normalize_pattern: enable normalization of patterns. + p_norm_weight, p_norm_bias: pattern normalization weight and bias. + head_dim: dimensionality of each head. + pattern_dim: dimensionality of each projected value input. + scaling: scaling of association heads, often represented as beta (one entry per head). + update_steps_max: maximum count of association update steps (None equals to infinity). + update_steps_eps: minimum difference threshold between two consecutive association update steps. + return_raw_associations: return raw association (softmax) values, unmodified. + return_projected_patterns: return pattern projection values, unmodified. + + Shape: + Inputs: + - query: :math:`(L, N, E)` where L is the target sequence length, N is the batch size, E is + the embedding dimension. + - key: :math:`(S, N, E)`, where S is the source sequence length, N is the batch size, E is + the embedding dimension. + - value: :math:`(S, N, E)` where S is the source sequence length, N is the batch size, E is + the embedding dimension. + - key_padding_mask: :math:`(N, S)` where N is the batch size, S is the source sequence length. + If a ByteTensor is provided, the non-zero positions will be ignored while the zero positions + will be unchanged. If a BoolTensor is provided, the positions with the + value of ``True`` will be ignored while the position with the value of ``False`` will be unchanged. + - attn_mask: 2D mask :math:`(L, S)` where L is the target sequence length, S is the source sequence length. + 3D mask :math:`(N*num_heads, L, S)` where N is the batch size, L is the target sequence length, + S is the source sequence length. attn_mask ensures that position i is allowed to attend the unmasked + positions. If a ByteTensor is provided, the non-zero positions are not allowed to attend + while the zero positions will be unchanged. If a BoolTensor is provided, positions with ``True`` + are not allowed to attend while ``False`` values will be unchanged. If a FloatTensor + is provided, it will be added to the attention weight. + - static_k: :math:`(N*num_heads, S, head_dim)`, where S is the source sequence length, N is the batch size. + - static_v: :math:`(N*num_heads, S, head_dim)`, where S is the source sequence length, N is the batch size. + + - scaling: :math:`(num_heads,)`, where num_heads is the amount of heads. + + Outputs: + - attn_output: :math:`(L, N, E)`, where L is the target sequence length, N is the batch size, + E is the embedding dimension. + - attn_output_weights: :math:`(N, L, S)`, where N is the batch size, + L is the target sequence length, S is the source sequence length. + - attn_raw: :math:``(N, num_heads, L, S)`, where N is the batch size, + L is the target sequence length, S is the source sequence length. + """ + if not torch.jit.is_scripting(): + tens_ops = (query, key, value, in_proj_weight, in_proj_bias, bias_k, bias_v, + out_proj_weight, out_proj_bias) + if any([type(t) is not Tensor for t in tens_ops]) and nn.functional.has_torch_function(tens_ops): + return nn.functional.handle_torch_function( + hopfield_core_forward, tens_ops, query, key, value, + embed_dim_to_check, num_heads, in_proj_weight, in_proj_bias, + bias_k, bias_v, add_zero_attn, dropout_p, out_proj_weight, + out_proj_bias, training=training, key_padding_mask=key_padding_mask, + need_weights=need_weights, attn_mask=attn_mask, + use_separate_proj_weight=use_separate_proj_weight, + q_proj_weight=q_proj_weight, k_proj_weight=k_proj_weight, + v_proj_weight=v_proj_weight, static_k=static_k, static_v=static_v, + key_as_static=key_as_static, query_as_static=query_as_static, + value_as_static=value_as_static, value_as_connected=value_as_connected, + normalize_pattern=normalize_pattern, p_norm_weight=p_norm_weight, p_norm_bias=p_norm_bias, + head_dim=head_dim, pattern_dim=pattern_dim, scaling=scaling, update_steps_max=update_steps_max, + update_steps_eps=update_steps_eps, return_raw_associations=return_raw_associations) + tgt_len, bsz, embed_dim = query.shape[0], value.shape[1], query.shape[2] + assert embed_dim == embed_dim_to_check + # allow MHA to have different sizes for the feature dimension + assert key.size(0) == value.size(0) and key.size(1) == value.size(1) + + assert (scaling is None) or (type(scaling) in (float, torch.Tensor)) + if type(scaling) == torch.Tensor: + assert scaling.ndimension() == 1 and scaling.shape[0] == num_heads, "only one entry per head." + + assert (update_steps_max is None) or (type(update_steps_max) in (int, torch.Tensor)) + if type(update_steps_max) == torch.Tensor: + assert update_steps_max.ndimension() == 1 and update_steps_max.shape[0] == num_heads, "only one entry per head." + elif type(update_steps_max) == int: + update_steps_max = torch.tensor([update_steps_max] * num_heads, dtype=torch.int32, device=query.device) + elif update_steps_max is None: + update_steps_max = -torch.ones(size=(num_heads,), dtype=torch.int32, device=query.device) + + assert type(update_steps_eps) in (float, torch.Tensor) + if type(update_steps_eps) == torch.Tensor: + assert update_steps_eps.ndimension() == 1 and update_steps_eps.shape[0] == num_heads, "only one entry per head." + assert (update_steps_eps <= 0.0).sum() == 0, "only positive thresholds allowed." + update_steps_eps = update_steps_eps.to(device=query.device) + elif type(update_steps_eps) == float: + assert update_steps_eps > 0, "only positive thresholds allowed." + update_steps_eps = torch.tensor([update_steps_eps] * num_heads, dtype=query.dtype, device=query.device) + + # Adapt dimensionality of each each. + if head_dim is None: + head_dim = embed_dim // num_heads + assert head_dim * num_heads == embed_dim, r'embed_dim must be divisible by num_heads.' + hopfield_dim = num_heads * head_dim + + # Adapt dimensionality of each value projection. + if pattern_dim is None: + pattern_dim = head_dim + assert (not value_as_connected) or (pattern_dim == head_dim) + + q, k, v, xi, src_len = None, None, None, None, 0 + update_step, xi_old, xi_difference_norm = 0, None, float(r'+inf') + update_active_heads = torch.tensor([[[True]]] * num_heads * bsz, device=query.device) + assert update_active_heads.any(), "at least one head needs to be active." + + #################################################################################################################### + # BEGIN HOPFIELD UPDATE ITERATION # + #################################################################################################################### + + while update_active_heads.any(): + + # The query is already projected into the "Hopfield" space at "update_step" equals 0. + # No more projection necessary if "update_step" greater than 0. + if update_step == 0: + if not use_separate_proj_weight: + + if torch.equal(query, key) and torch.equal(key, value) and not ( + key_as_static or query_as_static or value_as_static): + # self-attention + q, k, v = nn.functional.linear(query, in_proj_weight, in_proj_bias).chunk(3, dim=-1) + + elif torch.equal(key, value) and not (key_as_static or value_as_static): + # encoder-decoder attention + _start, _end = 0, hopfield_dim + if query_as_static: + q = query.repeat(1, num_heads, 1) + else: + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + q = nn.functional.linear(query, _w, _b) + _start = hopfield_dim + _end = None + + if key is None: + assert value is None + k = None + v = None + else: + + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + k, v = nn.functional.linear(key, _w, _b).chunk(2, dim=-1) + + else: + _start, _end = 0, hopfield_dim + if query_as_static: + q = query.repeat(1, num_heads, 1) + else: + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + q = nn.functional.linear(query, _w, _b) + _start += hopfield_dim + _end += hopfield_dim + + if key_as_static: + k = key.repeat(1, num_heads, 1) + else: + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + k = nn.functional.linear(key, _w, _b) + _start += hopfield_dim + _end += hopfield_dim + + if value_as_static: + v = value.repeat(1, num_heads, 1) + else: + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + v = nn.functional.linear(value, _w, _b) + else: + _start, _end = 0, hopfield_dim + if query_as_static: + q = query.repeat(1, num_heads, 1) + else: + q_proj_weight_non_opt = torch.jit._unwrap_optional(q_proj_weight) + len1, len2 = q_proj_weight_non_opt.size() + assert len1 == hopfield_dim and len2 == query.size(-1) + if in_proj_bias is not None: + q = nn.functional.linear(query, q_proj_weight_non_opt, in_proj_bias[_start:_end]) + _start += hopfield_dim + _end += hopfield_dim + else: + q = nn.functional.linear(query, q_proj_weight_non_opt, in_proj_bias) + + v = value + if key_as_static: + k = key.repeat(1, num_heads, 1) + else: + k_proj_weight_non_opt = torch.jit._unwrap_optional(k_proj_weight) + len1, len2 = k_proj_weight_non_opt.size() + assert len1 == hopfield_dim and len2 == key.size(-1) + + _bias = None if in_proj_bias is None else in_proj_bias[_start:_end] + k = nn.functional.linear(key, k_proj_weight_non_opt, _bias) + if value_as_connected: + v = nn.functional.linear(v, k_proj_weight_non_opt, _bias) + _start += hopfield_dim + _end += num_heads * pattern_dim + + if value_as_static: + if not (value_as_connected or key_as_static): + v = v.repeat(1, num_heads, 1) + else: + v_proj_weight_non_opt = torch.jit._unwrap_optional(v_proj_weight) + len1, len2 = v_proj_weight_non_opt.size() + assert len1 == (num_heads * pattern_dim) and len2 == v.size(-1) + if in_proj_bias is not None: + v = nn.functional.linear(v, v_proj_weight_non_opt, in_proj_bias[_start:]) + else: + v = nn.functional.linear(v, v_proj_weight_non_opt, in_proj_bias) + + if attn_mask is not None: + assert attn_mask.dtype == torch.float32 or attn_mask.dtype == torch.float64 or \ + attn_mask.dtype == torch.float16 or attn_mask.dtype == torch.uint8 or \ + attn_mask.dtype == torch.bool, \ + 'Only float, byte, and bool types are supported for attn_mask, not {}'.format(attn_mask.dtype) + if attn_mask.dtype == torch.uint8: + warnings.warn( + "Byte tensor for attn_mask in nn.HopfieldCore is deprecated. Use bool tensor instead.") + attn_mask = attn_mask.to(torch.bool) + + if attn_mask.dim() == 2: + attn_mask = attn_mask.unsqueeze(0) + if list(attn_mask.size()) != [1, query.size(0), key.size(0)]: + raise RuntimeError('The size of the 2D attn_mask is not correct.') + elif attn_mask.dim() == 3: + if list(attn_mask.size()) != [bsz * num_heads, query.size(0), key.size(0)]: + raise RuntimeError('The size of the 3D attn_mask is not correct.') + else: + raise RuntimeError("attn_mask's dimension {} is not supported".format(attn_mask.dim())) + # attn_mask's dim is 3 now. + + # Optionally normalize patterns. + if normalize_pattern: + q = torch.nn.functional.layer_norm( + input=q.reshape(shape=(-1, head_dim)), normalized_shape=(head_dim,), + weight=p_norm_weight, bias=p_norm_bias).reshape(shape=q.shape) + k = torch.nn.functional.layer_norm( + input=k.reshape(shape=(-1, head_dim)), normalized_shape=(head_dim,), + weight=p_norm_weight, bias=p_norm_bias).reshape(shape=k.shape) + + else: + active_xi = xi.masked_select(mask=update_active_heads).view(size=(-1, *xi.shape[1:])) + active_k = k.masked_select(mask=update_active_heads).view(size=(-1, *k.shape[1:])) + q = torch.masked_scatter(input=q, mask=update_active_heads, source=torch.bmm(active_xi, active_k)) + + # Optionally scale association heads (each head separately). + if type(scaling) == float: + q = q * scaling + elif type(scaling) == torch.Tensor: + q = q * scaling.view(1, 1, -1).repeat(repeats=(1, 1, q.shape[2] // scaling.shape[0])) + + if update_step == 0: + # convert ByteTensor key_padding_mask to bool + if key_padding_mask is not None and key_padding_mask.dtype == torch.uint8: + warnings.warn( + "Byte tensor for key_padding_mask in nn.HopfieldCore is deprecated. Use bool tensor instead.") + key_padding_mask = key_padding_mask.to(torch.bool) + + if bias_k is not None and bias_v is not None: + if static_k is None and static_v is None and key_as_static is None and value_as_static is None: + k = torch.cat([k, bias_k.repeat(1, bsz, 1)]) + v = torch.cat([v, bias_v.repeat(1, bsz, 1)]) + if attn_mask is not None: + attn_mask = nn.functional.pad(attn_mask, [0, 1]) + if key_padding_mask is not None: + key_padding_mask = nn.functional.pad(key_padding_mask, [0, 1]) + else: + assert static_k is None, "bias cannot be added to static key." + assert static_v is None, "bias cannot be added to static value." + assert not key_as_static, "bias cannot be added to static key." + assert not value_as_static, "bias cannot be added to static value." + else: + assert bias_k is None + assert bias_v is None + + q = q.contiguous().view(tgt_len, -1, head_dim).transpose(0, 1) + if k is not None: + k = k.contiguous().view(-1, bsz * num_heads, head_dim).transpose(0, 1) + if v is not None: + v = v.contiguous().view(v.shape[0], bsz * num_heads, -1).transpose(0, 1) + + if static_k is not None: + assert static_k.size(0) == bsz * num_heads + assert static_k.size(2) == head_dim + k = static_k + + if static_v is not None: + assert static_v.size(0) == bsz * num_heads + assert static_v.size(2) == pattern_dim + v = static_v + + src_len = k.size(1) + + if key_padding_mask is not None: + assert key_padding_mask.size(0) == bsz + assert key_padding_mask.size(1) == src_len + + if add_zero_attn: + src_len += 1 + k = torch.cat([k, torch.zeros((k.size(0), 1) + k.size()[2:], dtype=k.dtype, device=k.device)], dim=1) + v = torch.cat([v, torch.zeros((v.size(0), 1) + v.size()[2:], dtype=v.dtype, device=v.device)], dim=1) + if attn_mask is not None: + attn_mask = nn.functional.pad(attn_mask, [0, 1]) + if key_padding_mask is not None: + key_padding_mask = nn.functional.pad(key_padding_mask, [0, 1]) + + attn_output_weights = torch.bmm(q, k.transpose(1, 2)) + assert list(attn_output_weights.size()) == [bsz * num_heads, tgt_len, src_len] + + if attn_mask is not None: + if attn_mask.dtype == torch.bool: + attn_output_weights.masked_fill_(attn_mask, float('-inf')) + else: + attn_output_weights += attn_mask + + if key_padding_mask is not None: + attn_output_weights = attn_output_weights.view(bsz, num_heads, tgt_len, src_len) + attn_output_weights = attn_output_weights.masked_fill( + key_padding_mask.unsqueeze(1).unsqueeze(2), + float('-inf'), + ) + attn_output_weights = attn_output_weights.view(bsz * num_heads, tgt_len, src_len) + + # Compute new xi for Hopfield retrieve iterations. + if xi is None: + xi = nn.functional.softmax(attn_output_weights, dim=-1) + else: + xi = torch.masked_scatter(input=xi, mask=update_active_heads, source=nn.functional.softmax( + attn_output_weights.masked_select(mask=update_active_heads).view(size=(-1, *xi.shape[1:])), dim=-1)) + + # Compute threshold-based stopping criterion for Hopfield retrieve iterations. + with torch.no_grad(): + xi_active = xi.view(size=(bsz, num_heads, tgt_len, src_len)) + update_active_heads = (update_step < update_steps_max) | (update_steps_max < 0) + if xi_old is not None: + update_active_heads &= ((xi_old - xi_active).norm(p=2, dim=(2, 3)).max(axis=0)[0]) > update_steps_eps + update_active_heads = update_active_heads.unsqueeze(dim=1).unsqueeze(dim=2).repeat(repeats=(bsz, 1, 1)) + xi_old = xi_active + update_step += 1 + + #################################################################################################################### + # END HOPFIELD UPDATE ITERATION # + #################################################################################################################### + + attn_output_weights = nn.functional.dropout(xi, p=dropout_p, training=training) + attn_output = torch.bmm(attn_output_weights, v) + assert list(attn_output.shape[:2]) == [bsz * num_heads, tgt_len] + attn_output = attn_output.transpose(0, 1).contiguous().view(tgt_len, bsz, -1) + if out_proj_weight is not None: + assert attn_output.shape[2] == num_heads * pattern_dim + attn_output = nn.functional.linear(attn_output, out_proj_weight, out_proj_bias) + + xi = xi.view(bsz, num_heads, tgt_len, src_len) if return_raw_associations else None + v = v.view(bsz, num_heads, src_len, -1) if return_projected_patterns else None + if need_weights: + # average attention weights over heads + attn_output_weights = attn_output_weights.view(bsz, num_heads, tgt_len, src_len) + return attn_output, attn_output_weights.sum(dim=1) / num_heads, xi, v + else: + return attn_output, None, xi, v diff --git a/src/mhnfs/hopfield/examples/bit_pattern/modules/transformer.py b/src/mhnfs/hopfield/examples/bit_pattern/modules/transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..884e0cb4b57610cf1daf8147f2c3d59f17824750 --- /dev/null +++ b/src/mhnfs/hopfield/examples/bit_pattern/modules/transformer.py @@ -0,0 +1,209 @@ +import torch +import torch.nn as nn + +from copy import deepcopy +from torch import Tensor +from torch.nn.modules import Module +from typing import Optional, Tuple, Union + +from . import Hopfield + + +class HopfieldEncoderLayer(Module): + """ + Module with underlying Hopfield association to be used as an encoder in transformer-like architectures. + """ + + def __init__(self, + hopfield_association: Hopfield, + dim_feedforward: int = 2048, + dropout: float = 0.1, + activation: str = r'relu' + ): + """ + Initialise a new instance of a Hopfield association-based encoder module. + + :param hopfield_association: instance of Hopfield association module + :param dim_feedforward: depth of the linear projections applied internally + :param activation: activation to be applied on the result of the internal linear projections + :param dropout: dropout probability to be applied internally + """ + super(HopfieldEncoderLayer, self).__init__() + self.hopfield_association = deepcopy(hopfield_association) + + self.linear_residual = nn.Linear(self.hopfield_association.state_pattern_dim, dim_feedforward) + self.dropout_residual = nn.Dropout(dropout) + self.linear_output = nn.Linear(dim_feedforward, self.hopfield_association.state_pattern_dim) + + self.norm_residual = nn.LayerNorm(self.hopfield_association.state_pattern_dim) + self.norm_output = nn.LayerNorm(self.hopfield_association.state_pattern_dim) + self.dropout_hopfield_association = nn.Dropout(dropout) + self.dropout_output = nn.Dropout(dropout) + + self.activation_residual = getattr(torch, activation, None) + assert self.activation_residual is not None, r'invalid activation function supplied.' + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset parameters, including Hopfield association. + + :return: None + """ + for module in (self.hopfield_association, self.linear_residual, + self.linear_output, self.norm_residual, self.norm_output): + if hasattr(module, r'reset_parameters'): + module.reset_parameters() + + def forward(self, src: Tensor, src_mask: Optional[Tensor] = None, + src_key_padding_mask: Optional[Tensor] = None) -> Tensor: + """ + Apply Hopfield encoding on specified data. + + :param src: data to be processed by Hopfield encoder module + :param src_mask: mask to be applied on association matrix + :param src_key_padding_mask: mask to be applied on stored patterns + :return: Hopfield-encoded input data + """ + data_associated = self.hopfield_association( + input=src, stored_pattern_padding_mask=src_key_padding_mask, association_mask=src_mask) + src = src + self.dropout_hopfield_association(input=data_associated) + src = self.norm_residual(input=src) + + result_residual_inner = self.activation_residual(input=self.linear_residual(input=src)) + data_associated = self.linear_output(input=self.dropout_residual(input=result_residual_inner)) + src = src + self.dropout_output(input=data_associated) + + return self.norm_output(input=src) + + def get_association_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]]) -> Tensor: + """ + Fetch Hopfield association matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :return: association matrix as computed by the Hopfield core module + """ + return self.hopfield_association.get_association_matrix(input=input) + + @property + def batch_first(self) -> int: + return self.hopfield_association.batch_first + + @property + def input_size(self) -> int: + return self.hopfield_association.input_size + + @property + def output_size(self) -> int: + return self.linear_output.out_features + + +class HopfieldDecoderLayer(Module): + + def __init__(self, + hopfield_association_self: Hopfield, + hopfield_association_cross: Hopfield, + dim_feedforward: int = 2048, + dropout: float = 0.1, + activation: str = r'relu' + ): + """ + Initialise a new instance of a Hopfield association-based encoder module. + + :param hopfield_association_self: instance of Hopfield self-association module + :param hopfield_association_cross: instance of Hopfield cross-association module + :param dim_feedforward: depth of the linear projections applied internally + :param dropout: dropout probability to be applied internally + :param activation: activation to be applied on the result of the internal linear projections + """ + super(HopfieldDecoderLayer, self).__init__() + self.hopfield_association_self = deepcopy(hopfield_association_self) + self.hopfield_association_cross = deepcopy(hopfield_association_cross) + + self.linear_residual = nn.Linear(self.hopfield_association_self.state_pattern_dim, dim_feedforward) + self.dropout_residual = nn.Dropout(dropout) + self.linear_output = nn.Linear(dim_feedforward, self.hopfield_association_self.state_pattern_dim) + + self.norm_residual_self = nn.LayerNorm(self.hopfield_association_self.state_pattern_dim) + self.norm_residual_cross = nn.LayerNorm(self.hopfield_association_self.state_pattern_dim) + self.norm_output = nn.LayerNorm(self.hopfield_association_self.state_pattern_dim) + self.dropout_hopfield_association_self = nn.Dropout(dropout) + self.dropout_hopfield_association_cross = nn.Dropout(dropout) + self.dropout_output = nn.Dropout(dropout) + + self.activation_residual = getattr(torch, activation, None) + assert self.activation_residual is not None, r'invalid activation function supplied.' + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset parameters, including Hopfield association. + + :return: None + """ + for module in (self.hopfield_association_self, self.hopfield_association_cross, + self.linear_residual, self.linear_output, self.norm_residual_self, + self.norm_residual_cross, self.norm_output): + if hasattr(module, r'reset_parameters'): + module.reset_parameters() + + def forward(self, tgt: Tensor, memory: Tensor, tgt_mask: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, tgt_key_padding_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None) -> Tensor: + """ + Apply Hopfield decoding on specified data. + + :param tgt: data to be processed by Hopfield decoder module (self-association) + :param memory: data to be processed by Hopfield encoder module (cross-association) + :param tgt_mask: mask to be applied on self-association matrix + :param memory_mask: mask to be applied on cross-association matrix + :param tgt_key_padding_mask: mask to be applied on stored patterns + :param memory_key_padding_mask: mask to be applied on state patterns as well as pattern projection + :return: Hopfield-decoded input + """ + data_associated = self.hopfield_association_self( + input=tgt, stored_pattern_padding_mask=tgt_key_padding_mask, + association_mask=tgt_mask) + tgt = tgt + self.dropout_hopfield_association_self(input=data_associated) + tgt = self.norm_residual_self(input=tgt) + + data_associated = self.hopfield_association_cross( + input=(memory, tgt, memory), stored_pattern_padding_mask=memory_key_padding_mask, + association_mask=memory_mask) + tgt = tgt + self.dropout_hopfield_association_cross(input=data_associated) + tgt = self.norm_residual_cross(input=tgt) + + result_residual_inner = self.activation_residual(input=self.linear_residual(input=tgt)) + data_associated = self.linear_output(input=self.dropout_residual(input=result_residual_inner)) + tgt = tgt + self.dropout_output(input=data_associated) + return self.norm_output(input=tgt) + + def get_association_matrix_self(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]]) -> Tensor: + """ + Fetch Hopfield self-association matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :return: association matrix as computed by the Hopfield core module + """ + return self.hopfield_association_self.get_association_matrix(input=input) + + def get_association_matrix_cross(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]]) -> Tensor: + """ + Fetch Hopfield cross-association matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :return: association matrix as computed by the Hopfield core module + """ + return self.hopfield_association_cross.get_association_matrix(input=input) + + @property + def batch_first(self) -> int: + return self.hopfield_association_self.batch_first + + @property + def input_size(self) -> int: + return self.hopfield_association_self.input_size + + @property + def output_size(self) -> int: + return self.linear_output_self.out_features diff --git a/src/mhnfs/hopfield/examples/bit_pattern/resources/hopfield_adapted.pdf b/src/mhnfs/hopfield/examples/bit_pattern/resources/hopfield_adapted.pdf new file mode 100644 index 0000000000000000000000000000000000000000..ff2b69a1262910659023ec30d589b806dda52785 Binary files /dev/null and b/src/mhnfs/hopfield/examples/bit_pattern/resources/hopfield_adapted.pdf differ diff --git a/src/mhnfs/hopfield/examples/bit_pattern/resources/hopfield_base.pdf b/src/mhnfs/hopfield/examples/bit_pattern/resources/hopfield_base.pdf new file mode 100644 index 0000000000000000000000000000000000000000..bfb48f53d397db6a964c29c6d98868bf413ceba5 Binary files /dev/null and b/src/mhnfs/hopfield/examples/bit_pattern/resources/hopfield_base.pdf differ diff --git a/src/mhnfs/hopfield/examples/bit_pattern/resources/hopfield_lookup.pdf b/src/mhnfs/hopfield/examples/bit_pattern/resources/hopfield_lookup.pdf new file mode 100644 index 0000000000000000000000000000000000000000..04f508591e7386d44cfdb211a9c69b056ed64ad3 Binary files /dev/null and b/src/mhnfs/hopfield/examples/bit_pattern/resources/hopfield_lookup.pdf differ diff --git a/src/mhnfs/hopfield/examples/bit_pattern/resources/hopfield_lookup_adapted.pdf b/src/mhnfs/hopfield/examples/bit_pattern/resources/hopfield_lookup_adapted.pdf new file mode 100644 index 0000000000000000000000000000000000000000..6bf00e7255e2fe19981f78692a7ca43b1b55b3ad Binary files /dev/null and b/src/mhnfs/hopfield/examples/bit_pattern/resources/hopfield_lookup_adapted.pdf differ diff --git a/src/mhnfs/hopfield/examples/bit_pattern/resources/hopfield_pooling.pdf b/src/mhnfs/hopfield/examples/bit_pattern/resources/hopfield_pooling.pdf new file mode 100644 index 0000000000000000000000000000000000000000..176f73ac652d4b1fa7620dee9320a842afceb22e Binary files /dev/null and b/src/mhnfs/hopfield/examples/bit_pattern/resources/hopfield_pooling.pdf differ diff --git a/src/mhnfs/hopfield/examples/bit_pattern/resources/hopfield_pooling_adapted.pdf b/src/mhnfs/hopfield/examples/bit_pattern/resources/hopfield_pooling_adapted.pdf new file mode 100644 index 0000000000000000000000000000000000000000..e58252a1cafc2cdd695675cf94fd31890b4b88e5 Binary files /dev/null and b/src/mhnfs/hopfield/examples/bit_pattern/resources/hopfield_pooling_adapted.pdf differ diff --git a/src/mhnfs/hopfield/examples/latch_sequence/auxiliary/__init__.py b/src/mhnfs/hopfield/examples/latch_sequence/auxiliary/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/src/mhnfs/hopfield/examples/latch_sequence/auxiliary/data.py b/src/mhnfs/hopfield/examples/latch_sequence/auxiliary/data.py new file mode 100644 index 0000000000000000000000000000000000000000..2c3e393145921d6588d6b0adc41f036b6bd5f4a9 --- /dev/null +++ b/src/mhnfs/hopfield/examples/latch_sequence/auxiliary/data.py @@ -0,0 +1,252 @@ +import torch + +from math import ceil +from torch.utils.data import Dataset +from typing import Dict, Optional, Sequence, Tuple, Union + + +class BitPatternSet(Dataset): + """ + Binary multiple instance learning (MIL) data set comprising bit patterns as instances, + with implanted bit patterns unique to one of the classes. + """ + + def __init__(self, num_bags: int, num_instances: int, num_signals: int, num_signals_per_bag: int = 1, + fraction_targets: float = 0.5, num_bits: int = 8, dtype: torch.dtype = torch.float32, + seed_signals: int = 43, seed_data: int = 44): + """ + Create new binary bit pattern data set conforming to the specified properties. + + :param num_bags: amount of bags + :param num_instances: amount of instances per bag + :param num_signals: amount of unique signals used to distinguish both classes + :param num_signals_per_bag: amount of unique signals to be implanted per bag + :param fraction_targets: fraction of targets + :param num_bits: amount of bits per instance + :param dtype: data type of instances + :param seed_signals: random seed used to generate the signals of the data set (excl. samples) + :param seed_data: random seed used to generate the samples of the data set (excl. signals) + """ + super(BitPatternSet, self).__init__() + assert (type(num_bags) == int) and (num_bags > 0), r'"num_bags" must be a positive integer!' + assert (type(num_instances) == int) and (num_instances > 0), r'"num_instances" must be a positive integer!' + assert (type(num_signals) == int) and (num_signals > 0), r'"num_signals" must be a positive integer!' + assert (type(num_signals_per_bag) == int) and (num_signals_per_bag >= 0) and ( + num_signals_per_bag <= num_instances), r'"num_signals_per_bag" must be a non-negative integer!' + assert (type(fraction_targets) == float) and (fraction_targets > 0) and ( + fraction_targets < 1), r'"fraction_targets" must be in interval (0; 1)!' + assert (type(num_bits) == int) and (num_bits > 0), r'"num_bits" must be a positive integer!' + assert ((2 ** num_bits) - 1) > num_signals, r'"num_signals" must be smaller than "2 ** num_bits - 1"!' + assert type(seed_signals) == int, r'"seed_signals" must be an integer!' + assert type(seed_data) == int, r'"seed_data" must be an integer!' + + self.__num_bags = num_bags + self.__num_instances = num_instances + self.__num_signals = num_signals + self.__num_signals_per_bag = num_signals_per_bag + self.__fraction_targets = fraction_targets + self.__num_targets = min(self.__num_bags, max(1, ceil(self.__num_bags * self.__fraction_targets))) + self.__num_bits = num_bits + self.__dtype = dtype + self.__seed_signals = seed_signals + self.__seed_data = seed_data + self.__data, self.__targets, self.__signals = self._generate_bit_pattern_set() + + def __len__(self) -> int: + """ + Fetch amount of bags. + + :return: amount of bags + """ + return self.__num_bags + + def __getitem__(self, item_index: int) -> Dict[str, torch.Tensor]: + """ + Fetch specific bag. + + :param item_index: specific bag to fetch + :return: specific bag as dictionary of tensors + """ + return {r'data': self.__data[item_index].to(dtype=self.__dtype), + r'target': self.__targets[item_index].to(dtype=self.__dtype)} + + def _generate_bit_pattern_set(self) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """ + Generate underlying bit pattern data set. + + :return: tuple containing generated bags, targets and signals + """ + torch.random.manual_seed(seed=self.__seed_signals) + + # Generate signal patterns. + generated_signals = torch.randint(low=0, high=2, size=(self.__num_signals, self.__num_bits)) + check_instances = True + while check_instances: + generated_signals = torch.unique(input=generated_signals, dim=0) + generated_signals = generated_signals[generated_signals.sum(axis=1) != 0] + missing_signals = self.__num_signals - generated_signals.shape[0] + if missing_signals > 0: + generated_signals = torch.cat(tensors=( + generated_signals, torch.randint(low=0, high=2, size=(missing_signals, self.__num_bits))), dim=0) + else: + check_instances = False + + # Generate data and target tensors. + torch.random.manual_seed(seed=self.__seed_data) + generated_data = torch.randint(low=0, high=2, size=(self.__num_bags, self.__num_instances, self.__num_bits)) + generated_targets = torch.zeros(size=(self.__num_bags,), dtype=generated_data.dtype) + generated_targets[:self.__num_targets] = 1 + + # Check invalid (all-zero and signal) instances and re-sample them. + check_instances = True + while check_instances: + invalid_instances = (generated_data.sum(axis=2) == 0).logical_or( + torch.sum(torch.stack([(generated_data == _).all(axis=2) for _ in generated_signals]), axis=0)) + if invalid_instances.sum() > 0: + generated_data[invalid_instances] = torch.randint( + low=0, high=2, size=(invalid_instances.sum(), self.__num_bits)) + else: + check_instances = False + + # Re-implant signal into respective bags. + for data_index in range(self.__num_targets): + implantation_indices = [] + for _ in range(self.__num_signals_per_bag): + while True: + current_implantation_index = torch.randint(low=0, high=generated_data.shape[1], size=(1,)) + if current_implantation_index not in implantation_indices: + implantation_indices.append(current_implantation_index) + break + current_signal_index = torch.randint(low=0, high=generated_signals.shape[0], size=(1,)) + generated_data[data_index, current_implantation_index] = generated_signals[current_signal_index] + + return generated_data, generated_targets, generated_signals + + @property + def num_bags(self) -> int: + return self.__num_bags + + @property + def num_instances(self) -> int: + return self.__num_instances + + @property + def num_bits(self) -> int: + return self.__num_bits + + @property + def num_targets_high(self) -> int: + return self.__num_targets + + @property + def num_targets_low(self) -> int: + return self.__num_bags - self.__num_targets + + @property + def num_signals(self) -> int: + return self.__num_signals + + @property + def num_signals_per_bag(self) -> int: + return self.__num_signals_per_bag + + @property + def initial_seed(self) -> int: + return self.__seed + + @property + def bags(self) -> torch.Tensor: + return self.__data.clone() + + @property + def targets(self) -> torch.Tensor: + return self.__targets.clone() + + @property + def signals(self) -> torch.Tensor: + return self.__signals.clone() + + +class LatchSequenceSet(Dataset): + """ + Latch data set comprising patterns as one-hot encoded instances. + """ + + def __init__(self, num_samples: int, num_instances: int = 20, num_characters: int = 6, + dtype: torch.dtype = torch.float32, seed: int = 43): + """ + Create new latch sequence data set conforming to the specified properties. + + :param num_samples: amount of samples + :param num_instances: amount of instances per sample + :param num_characters: amount of different characters + :param dtype: data type of samples + :param seed: random seed used to generate the samples of the data set + """ + super(LatchSequenceSet, self).__init__() + assert (type(num_samples) == int) and (num_samples > 0), r'"num_samples" must be a positive integer!' + assert (type(num_instances) == int) and (num_instances > 0), r'"num_instances" must be a positive integer!' + assert (type(num_characters) == int) and (num_characters > 0), r'"num_characters" must be a positive integer!' + assert type(seed) == int, r'"seed" must be an integer!' + + self.__num_samples = num_samples + self.__num_instances = num_instances + self.__num_characters = num_characters + self.__dtype = dtype + self.__seed = seed + self.__data, self.__targets = self._generate_latch_sequences() + + def __len__(self) -> int: + """ + Fetch amount of samples. + + :return: amount of samples + """ + return self.__num_samples + + def __getitem__(self, item_index: int) -> Dict[str, torch.Tensor]: + """ + Fetch specific sample. + + :param item_index: specific sample to fetch + :return: specific sample as dictionary of tensors + """ + return {r'data': self.__data[item_index].to(dtype=self.__dtype), + r'target': self.__targets[item_index].to(dtype=self.__dtype)} + + def _generate_latch_sequences(self) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Generate underlying latch sequence data set. + + :return: tuple containing generated data and targets + """ + torch.random.manual_seed(seed=self.__seed) + + # Generate data and target tensors. + generated_data = torch.randint( + low=2, high=self.__num_characters, size=(self.__num_samples, self.__num_instances)) + generated_signal = torch.randint(low=0, high=2, size=(self.__num_samples,)) + generated_data[:, 0] = generated_signal + generated_data = torch.nn.functional.one_hot(input=generated_data, num_classes=self.__num_characters) + + return generated_data, generated_signal + + @property + def num_samples(self) -> int: + return self.__num_samples + + @property + def num_instances(self) -> int: + return self.__num_instances + + @property + def num_characters(self) -> int: + return self.__num_characters + + @property + def initial_seed(self) -> int: + return self.__seed + + @property + def targets(self) -> torch.Tensor: + return self.__targets.clone() diff --git a/src/mhnfs/hopfield/examples/latch_sequence/latch_sequence_demo.ipynb b/src/mhnfs/hopfield/examples/latch_sequence/latch_sequence_demo.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..0d01559cd2c1af8c7f49dce43e93de42623b4a49 --- /dev/null +++ b/src/mhnfs/hopfield/examples/latch_sequence/latch_sequence_demo.ipynb @@ -0,0 +1,1047 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Example: Latch Problem

\n", + "\n", + "We study an easy example of learning long-term dependencies by using a simple latch task (see [Hochreiter and Mozer](https://link.springer.com/chapter/10.1007/3-540-44668-0_92)). The essence of this task is that a sequence of inputs is presented, beginning with one of two symbols, A or B, and after a variable number of time steps, the model has to output a corresponding symbol. Thus, the task requires memorizing the original input over time. It has to be noted, that both class-defining symbols must only appear at the first position of a sequence. This task was specifically designed to demonstrate the capability of recurrent neural networks to capture long term dependencies. This demonstration shows, that Hopfield, HopfieldPooling and HopfieldLayer adapt extremely fast to this specific task, concentrating only on the first entry of the sequence.\n", + "\n", + "This demonstration instructs how to apply Hopfield, HopfieldPooling and HopfieldLayer for an exemplary sequential task, potentially substituting LSTM and GRU layers.\n", + "\n", + "NOTA BENE: No tweeking of the exemplary LSTM network is done. The focus is put on the technical details. Feel free to tune yourself and see what works better :)\n", + "\n", + "

In the chapters Adapt Hopfield-based Network, Adapt Hopfield-based Pooling and Adapt Hopfield-based Lookup you can explore and try the new functionalities of our new Hopfield layer.

\n", + "\n", + "In order to run this notebook, a few modules need to be imported. The installation of third-party modules is not covered here." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Import general modules used e.g. for plotting.\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import sys\n", + "import torch\n", + "\n", + "# Importing Hopfield-specific modules.\n", + "from auxiliary.data import LatchSequenceSet\n", + "from modules import Hopfield, HopfieldPooling, HopfieldLayer\n", + "\n", + "# Import auxiliary modules.\n", + "from distutils.version import LooseVersion\n", + "from typing import List, Tuple\n", + "\n", + "# Importing PyTorch specific modules.\n", + "from torch import Tensor\n", + "from torch.nn import Flatten, Linear, LSTM, Module, Sequential\n", + "from torch.nn.functional import binary_cross_entropy_with_logits\n", + "from torch.nn.utils import clip_grad_norm_\n", + "from torch.optim import AdamW\n", + "from torch.utils.data import DataLoader\n", + "from torch.utils.data.sampler import SubsetRandomSampler\n", + "\n", + "# Set plotting style.\n", + "sns.set()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Specific minimum versions of Python itself as well as of some used modules is required." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Installed Python version: 3.8.8 (βœ“)\n", + "Installed PyTorch version: 1.7.0 (βœ“)\n" + ] + } + ], + "source": [ + "python_check = '(\\u2713)' if sys.version_info >= (3, 8) else '(\\u2717)'\n", + "pytorch_check = '(\\u2713)' if torch.__version__ >= LooseVersion(r'1.5') else '(\\u2717)'\n", + "\n", + "print(f'Installed Python version: {sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro} {python_check}')\n", + "print(f'Installed PyTorch version: {torch.__version__} {pytorch_check}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Create Dataset

\n", + "\n", + "We study an easy example of learning long-term dependencies by using a simple latch task. \n", + "The latch task was introcuded by Hochreiter and Mozer:
\n", + "Sepp Hochreiter, Michael Mozer, 2001. A discrete probabilistic memory model for discovering dependencies in time. Artificial Neural Networks -- ICANN 2001, 13, pp.661-668.

\n", + "The essence of this task is that a sequence of inputs is presented, beginning with one of two symbols, A or B, and after a variable number of time steps, the model has to output a corresponding symbol. Thus, the task requires memorizing the original input over time. It has to be noted, that both class-defining symbols must only appear at the first position of an instance. Defining arguments are:\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ArgumentValue (used in this demo)Description
num_samples4096Amount of samples of the full dataset.
num_instances32Amount of instances per sample (sample length).
num_characters20Amount of different characters (size of the one-hot encoded vector).
\n", + "\n", + "Let's define the dataset using previously mentioned properties as well as a logging directory for storing all auxiliary outputs like performance plots." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "latch_sequence_set = LatchSequenceSet(\n", + " num_samples=4096,\n", + " num_instances=32,\n", + " num_characters=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "log_dir = f'resources/'\n", + "os.makedirs(log_dir, exist_ok=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Create Auxiliaries

\n", + "\n", + "Before digging into Hopfield-based networks, a few auxiliary variables and functions need to be defined. This is nothing special with respect to Hopfield-based networks, but rather common preparation work of (almost) every machine learning setting (e.g. definition of a data loader as well as a training loop). We will see, that this comprises the most work of this whole demo." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device(r'cuda:0' if torch.cuda.is_available() else r'cpu')\n", + "\n", + "# Create data loader of training set.\n", + "sampler_train = SubsetRandomSampler(list(range(512, 4096 - 512)))\n", + "data_loader_train = DataLoader(dataset=latch_sequence_set, batch_size=32, sampler=sampler_train)\n", + "\n", + "# Create data loader of validation set.\n", + "sampler_eval = SubsetRandomSampler(list(range(512)) + list(range(4096 - 512, 4096)))\n", + "data_loader_eval = DataLoader(dataset=latch_sequence_set, batch_size=32, sampler=sampler_eval)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def train_epoch(network: Module,\n", + " optimiser: AdamW,\n", + " data_loader: DataLoader\n", + " ) -> Tuple[float, float]:\n", + " \"\"\"\n", + " Execute one training epoch.\n", + " \n", + " :param network: network instance to train\n", + " :param optimiser: optimiser instance responsible for updating network parameters\n", + " :param data_loader: data loader instance providing training data\n", + " :return: tuple comprising training loss as well as accuracy\n", + " \"\"\"\n", + " network.train()\n", + " losses, accuracies = [], []\n", + " for sample_data in data_loader:\n", + " data, target = sample_data[r'data'], sample_data[r'target']\n", + " data, target = data.to(device=device), target.to(device=device)\n", + "\n", + " # Process data by Hopfield-based network.\n", + " model_output = network.forward(input=data)\n", + "\n", + " # Update network parameters.\n", + " optimiser.zero_grad()\n", + " loss = binary_cross_entropy_with_logits(input=model_output, target=target, reduction=r'mean')\n", + " loss.backward()\n", + " clip_grad_norm_(parameters=network.parameters(), max_norm=1.0, norm_type=2)\n", + " optimiser.step()\n", + "\n", + " # Compute performance measures of current model.\n", + " accuracy = (model_output.sigmoid().round() == target).to(dtype=torch.float32).mean()\n", + " accuracies.append(accuracy.detach().item())\n", + " losses.append(loss.detach().item())\n", + " \n", + " # Report progress of training procedure.\n", + " return (sum(losses) / len(losses), sum(accuracies) / len(accuracies))\n", + "\n", + "\n", + "def eval_iter(network: Module,\n", + " data_loader: DataLoader\n", + " ) -> Tuple[float, float]:\n", + " \"\"\"\n", + " Evaluate the current model.\n", + " \n", + " :param network: network instance to evaluate\n", + " :param data_loader: data loader instance providing validation data\n", + " :return: tuple comprising validation loss as well as accuracy\n", + " \"\"\"\n", + " network.eval()\n", + " with torch.no_grad():\n", + " losses, accuracies = [], []\n", + " for sample_data in data_loader:\n", + " data, target = sample_data[r'data'], sample_data[r'target']\n", + " data, target = data.to(device=device), target.to(device=device)\n", + "\n", + " # Process data by Hopfield-based network.\n", + " model_output = network.forward(input=data)\n", + " loss = binary_cross_entropy_with_logits(input=model_output, target=target, reduction=r'mean')\n", + "\n", + " # Compute performance measures of current model.\n", + " accuracy = (model_output.sigmoid().round() == target).to(dtype=torch.float32).mean()\n", + " accuracies.append(accuracy.detach().item())\n", + " losses.append(loss.detach().item())\n", + "\n", + " # Report progress of validation procedure.\n", + " return (sum(losses) / len(losses), sum(accuracies) / len(accuracies))\n", + "\n", + "\n", + "def operate(network: Module,\n", + " optimiser: AdamW,\n", + " data_loader_train: DataLoader,\n", + " data_loader_eval: DataLoader,\n", + " num_epochs: int = 1\n", + " ) -> Tuple[pd.DataFrame, pd.DataFrame]:\n", + " \"\"\"\n", + " Train the specified network by gradient descent using backpropagation.\n", + " \n", + " :param network: network instance to train\n", + " :param optimiser: optimiser instance responsible for updating network parameters\n", + " :param data_loader_train: data loader instance providing training data\n", + " :param data_loader_eval: data loader instance providing validation data\n", + " :param num_epochs: amount of epochs to train\n", + " :return: data frame comprising training as well as evaluation performance\n", + " \"\"\"\n", + " losses, accuracies = {r'train': [], r'eval': []}, {r'train': [], r'eval': []}\n", + " for epoch in range(num_epochs):\n", + " \n", + " # Train network.\n", + " performance = train_epoch(network, optimiser, data_loader_train)\n", + " losses[r'train'].append(performance[0])\n", + " accuracies[r'train'].append(performance[1])\n", + " \n", + " # Evaluate current model.\n", + " performance = eval_iter(network, data_loader_eval)\n", + " losses[r'eval'].append(performance[0])\n", + " accuracies[r'eval'].append(performance[1])\n", + " \n", + " # Report progress of training and validation procedures.\n", + " return pd.DataFrame(losses), pd.DataFrame(accuracies)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def set_seed(seed: int = 42) -> None:\n", + " \"\"\"\n", + " Set seed for all underlying (pseudo) random number sources.\n", + " \n", + " :param seed: seed to be used\n", + " :return: None\n", + " \"\"\"\n", + " torch.manual_seed(42)\n", + " torch.backends.cudnn.deterministic = True\n", + " torch.backends.cudnn.benchmark = False\n", + "\n", + "\n", + "def plot_performance(loss: pd.DataFrame,\n", + " accuracy: pd.DataFrame,\n", + " log_file: str\n", + " ) -> None:\n", + " \"\"\"\n", + " Plot and save loss and accuracy.\n", + " \n", + " :param loss: loss to be plotted\n", + " :param accuracy: accuracy to be plotted\n", + " :param log_file: target file for storing the resulting plot\n", + " :return: None\n", + " \"\"\"\n", + " fig, ax = plt.subplots(1, 2, figsize=(20, 7))\n", + " \n", + " loss_plot = sns.lineplot(data=loss, ax=ax[0])\n", + " loss_plot.set(xlabel=r'Epoch', ylabel=r'Cross-entropy Loss')\n", + " \n", + " accuracy_plot = sns.lineplot(data=accuracy, ax=ax[1])\n", + " accuracy_plot.set(xlabel=r'Epoch', ylabel=r'Accuracy')\n", + " \n", + " ax[1].yaxis.set_label_position(r'right')\n", + " fig.tight_layout()\n", + " fig.savefig(log_file)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

LSTM-based Network

\n", + "\n", + "The instantiation of the heart of an LSTM-based network, the module LSTM, is rather straightforward. Only two arguments, the size of the input as well as the site of the hidden state, need to be set.\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ArgumentValue (used in this demo)Description
input_sizenum_characters (20)Size (depth) of the input.
hidden_size4Size (depth) of the hidden state.
...defaultThe remaining arguments are not explicitly used in this example.
\n", + "\n", + "An additional output projection is defined, to downproject the hidden state of the last time step of the LSTM to the correct output size. Afterwards, everything is wrapped into a container of type torch.nn.Sequential and a corresponding optimiser is defined." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "class LSTMNetwork(Module):\n", + " def __init__(self, input_size: int, hidden_size: int):\n", + " \"\"\"\n", + " Initialize a new instance of an LSTM-based network.\n", + " \n", + " :param input size: size (depth) of the input\n", + " :param hidden_size: size (depth) of the hidden state\n", + " \"\"\"\n", + " super(LSTMNetwork, self).__init__()\n", + " self.lstm = LSTM(input_size, hidden_size, batch_first=True)\n", + " self.projection = Linear(hidden_size, 1)\n", + " \n", + " def forward(self, input: Tensor) -> Tensor:\n", + " \"\"\"\n", + " Compute result of LSTM-based network on specified data.\n", + " \n", + " :param input: data to be processed by the LSTM-based network\n", + " :return: result as computed by the LSTM-based network\n", + " \"\"\"\n", + " out, _ = self.lstm.forward(input=input) \n", + " return self.projection.forward(input=out[:, -1, :]).flatten()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "set_seed()\n", + "network = LSTMNetwork(\n", + " input_size=latch_sequence_set.num_characters,\n", + " hidden_size=4).to(device=device)\n", + "optimiser = AdamW(params=network.parameters(), lr=1e-3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Operate LSTM-based Network

" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "losses, accuracies = operate(\n", + " network=network,\n", + " optimiser=optimiser,\n", + " data_loader_train=data_loader_train,\n", + " data_loader_eval=data_loader_eval,\n", + " num_epochs=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance(loss=losses, accuracy=accuracies, log_file=f'{log_dir}/lstm_base.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Hopfield-based Network

\n", + "\n", + "The instantiation of the heart of a Hopfield-based network, the module Hopfield, is even simpler. Only one argument, the size of the input, needs to be set.\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ArgumentValue (used in this demo)Description
input_sizenum_characters (20)Size (depth) of the input (state pattern).
...defaultThe remaining arguments are not explicitly used in this example.
\n", + "\n", + "An additional output projection is defined, to downproject the result of Hopfield to the correct output size. Afterwards, everything is wrapped into a container of type torch.nn.Sequential and a corresponding optimiser is defined. Now the Hopfield-based network and all auxiliaries are set up and ready to associate!" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "set_seed()\n", + "hopfield = Hopfield(\n", + " input_size=latch_sequence_set.num_characters)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "output_projection = Linear(in_features=hopfield.output_size * latch_sequence_set.num_instances, out_features=1)\n", + "network = Sequential(hopfield, Flatten(), output_projection, Flatten(start_dim=0)).to(device=device)\n", + "optimiser = AdamW(params=network.parameters(), lr=1e-3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Operate Hopfield-based Network

" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "losses, accuracies = operate(\n", + " network=network,\n", + " optimiser=optimiser,\n", + " data_loader_train=data_loader_train,\n", + " data_loader_eval=data_loader_eval,\n", + " num_epochs=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance(loss=losses, accuracy=accuracies, log_file=f'{log_dir}/hopfield_base.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Adapt Hopfield-based Network

\n", + "

We can now explore the functionality of our Hopfield layer Hopfield.

\n", + "\n", + "As described in the paper the Hopfield layer allows:\n", + "- association of two sets\n", + "- multiple updates\n", + "- variable beta\n", + "- changing the dimension of the associative space\n", + "- pattern normalization\n", + "- static patterns for fixed pattern search\n", + "\n", + "This time, additional arguments are set to influence the training as well as the validation performance of the Hopfield-based network.\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ArgumentValue (used in this demo)Description
input_sizenum_characters (20)Size (depth) of the input (state pattern).
hidden_size8Size (depth) of the association space.
num_heads8Amount of parallel association heads.
update_steps_max3Number of updates in one Hopfield head.
scaling0.25Beta parameter that determines the kind of fixed point.
dropout0.5Dropout probability applied on the association matrix.
...defaultThe remaining arguments are not explicitly used in this example.
" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "set_seed()\n", + "hopfield = Hopfield(\n", + " input_size=latch_sequence_set.num_characters,\n", + " hidden_size=8,\n", + " num_heads=8,\n", + " update_steps_max=3,\n", + " scaling=0.25,\n", + " dropout=0.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "output_projection = Linear(in_features=hopfield.output_size * latch_sequence_set.num_instances, out_features=1)\n", + "network = Sequential(hopfield, Flatten(), output_projection, Flatten(start_dim=0)).to(device=device)\n", + "optimiser = AdamW(params=network.parameters(), lr=1e-3)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "losses, accuracies = operate(\n", + " network=network,\n", + " optimiser=optimiser,\n", + " data_loader_train=data_loader_train,\n", + " data_loader_eval=data_loader_eval,\n", + " num_epochs=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance(loss=losses, accuracy=accuracies, log_file=f'{log_dir}/hopfield_adapted.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Hopfield-based Pooling

\n", + "\n", + "The previous examples manually downprojected the result of Hopfield by applying a linear layer afterwards. It would've also been possible to apply some kind of pooling. Exactly for such use cases, the module HopfieldPooling might be the right choice. Internally, a state pattern is trained, which in turn is used to compute pooling weights with respect to the input." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "set_seed()\n", + "hopfield_pooling = HopfieldPooling(\n", + " input_size=latch_sequence_set.num_characters)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "output_projection = Linear(in_features=hopfield_pooling.output_size, out_features=1)\n", + "network = Sequential(hopfield_pooling, output_projection, Flatten(start_dim=0)).to(device=device)\n", + "optimiser = AdamW(params=network.parameters(), lr=1e-3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Operate Hopfield-based Pooling

" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "losses, accuracies = operate(\n", + " network=network,\n", + " optimiser=optimiser,\n", + " data_loader_train=data_loader_train,\n", + " data_loader_eval=data_loader_eval,\n", + " num_epochs=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance(loss=losses, accuracy=accuracies, log_file=f'{log_dir}/hopfield_pooling.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Adapt Hopfield-based Pooling

\n", + "

We can now again explore the functionality of our Hopfield-based pooling layer HopfieldPooling.

\n", + "\n", + "Again, additional arguments are set to influence the training as well as the validation performance of the Hopfield-based pooling.\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ArgumentValue (used in this demo)Description
input_sizenum_characters (20)Size (depth) of the input (state pattern).
hidden_size8Size (depth) of the association space.
num_heads8Amount of parallel association heads.
update_steps_max3Number of updates in one Hopfield head.
scaling0.25Beta parameter that determines the kind of fixed point.
dropout0.5Dropout probability applied on the association matrix.
...defaultThe remaining arguments are not explicitly used in this example.
" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "set_seed()\n", + "hopfield_pooling = HopfieldPooling(\n", + " input_size=latch_sequence_set.num_characters,\n", + " hidden_size=8,\n", + " num_heads=8,\n", + " update_steps_max=3,\n", + " scaling=0.25,\n", + " dropout=0.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "output_projection = Linear(in_features=hopfield_pooling.output_size, out_features=1)\n", + "network = Sequential(hopfield_pooling, output_projection, Flatten(start_dim=0)).to(device=device)\n", + "optimiser = AdamW(params=network.parameters(), lr=1e-3)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "losses, accuracies = operate(\n", + " network=network,\n", + " optimiser=optimiser,\n", + " data_loader_train=data_loader_train,\n", + " data_loader_eval=data_loader_eval,\n", + " num_epochs=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance(loss=losses, accuracy=accuracies, log_file=f'{log_dir}/hopfield_pooling_adapted.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Hopfield-based Lookup

\n", + "\n", + "In contrast to the first Hopfield setting, in which the state patterns as well as the stored patterns are directly dependent on the input, HopfieldLayer employs a trainable but fixed stored pattern matrix, which in turn acts as a learnable lookup table." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "latch_samples_unique = [_[r'data'] for _ in data_loader_train]\n", + "latch_samples_unique = torch.cat(latch_samples_unique).view(-1, latch_samples_unique[0].shape[2]).unique(dim=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "set_seed()\n", + "hopfield_lookup = HopfieldLayer(\n", + " input_size=latch_sequence_set.num_characters,\n", + " quantity=len(latch_samples_unique))" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "output_projection = Linear(in_features=hopfield_lookup.output_size * latch_sequence_set.num_instances, out_features=1)\n", + "network = Sequential(hopfield_lookup, Flatten(start_dim=1), output_projection, Flatten(start_dim=0)).to(device=device)\n", + "optimiser = AdamW(params=network.parameters(), lr=1e-3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Operate Hopfield-based Lookup

" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "losses, accuracies = operate(\n", + " network=network,\n", + " optimiser=optimiser,\n", + " data_loader_train=data_loader_train,\n", + " data_loader_eval=data_loader_eval,\n", + " num_epochs=18)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABZQAAAHsCAYAAABFbSiOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABvCUlEQVR4nO3deXhU5fn/8c+ZLclMZghLAohWW7FiBerCTzEgalVQIKKAiksREaq2lsrXoqC2KC4o1eJS2yparYoVagXFWkSxKgq24rdfBFHUuouEsGUmM0lmO78/khmNE8x6Mtv7dV29yjnPOTP3PBm5ntzc534M0zRNAQAAAAAAAADQAlu6AwAAAAAAAAAAZAcSygAAAAAAAACAViGhDAAAAAAAAABoFRLKAAAAAAAAAIBWIaEMAAAAAAAAAGgVEsoAAAAAAAAAgFYhoQwAAAAAAAAAaBVHugPoiN27g4rHzS59z549i7VzZ02Xvmc+YX6txfxai/m1FvNrLebXWsyvtdoyvzaboe7dPRZHZA3WvrmH+bUW82st5tdazK+1mF9rMb/WyoS1b1YnlONxs8sX1Yn3hXWYX2sxv9Zifq3F/FqL+bUW82utfJhf1r65ifm1FvNrLebXWsyvtZhfazG/1kr3/NLyAgAAAAAAAADQKiSUAQAAAAAAAACtktUtLwAAANA6pmmqpqZatbU1isdj6Q6nU23fblM8Hm9yzmazq6ioWMXF3WQYRpoiAwAAAHIPCWUAAIA8sHt3lQzDUI8evWW3O3Iqyepw2BSNfpVQNk1TsVhUgcAe7d5dpR49ytIYHQAAAJBbaHkBAACQB8LhOpWU9JTD4cypZHJzDMOQw+FUSUlPhcN16Q4HAAAAyCkklAEAAPKCKcPIr6Vfw+dlh3EAAACgM+XXbxUAAAAAAAAAgHYjoQwAAIAuV1NTozlzftnq6999d7NuueUGCyMCAAAA0BpsygcAAIAuFwj49f77W1p9/YABP9Ds2T+wMCIAAAAArUFCGQAAAF3ujjt+ox07qjRnzi/1yScfqVu3EhUUFOimmxZo/vwbVFW1XTt2VGnIkKM0e/av9J//vKk//ek+/e539+myy36iH/zgUG3Y8H/as2e3rrjiKh111DHp/kgAAABAXiChDAAAkIde2/ilXn3rS0tee/jgvho2qO+3XnP55bP0859frBkz/kdnnnma/vrXu9W37z56/vmVOuig7+vGG29VJBLR+eefqS1b3k25PxKJ6t57H9Srr76ie++9h4QyAAAA0EVIKAMAACCtunfvob5995EknXzyKdq8eZOWLn1MH3/8kaqrq1VbG0q55+ijGxLI3/vegfL7/V0aLwAAAJDPSCgDAADkoWGDWq4i7ioFBQXJPz/xxON66aUXddppZ2jixKP00Uf/lWmaKfe4XC5JkmEYzY4DAAAAsIYt3QEAAAAg/9jtdsVisZTzb7zxL5122niNHHmqwuGw3n//PcXj8TREuHc1NTUaO3asPv/885Sxd955R+PHj9eoUaN0zTXXKBqNSpK2bt2q8847T6eccoouvfRSBYPBrg4bAAAA6BQklAEAANDlevToqd69++jmm69vcv6ss87Vgw/ep8mTz9add96ugQMH68svt6YpylQbNmzQOeeco48//rjZ8VmzZunXv/61nnvuOZmmqaVLl0qSrr/+ep177rlauXKlBg4cqN///vddGDUAAADQeWh5AQAAgC7ncDj0xz/+KeX8kUf+P/3lL082e88RRwyRJP3ud/clz/Xtu4+WL/+7otGuqWJeunSp5s6dqyuvvDJl7IsvvlBdXZ0OO+wwSdL48eN111136cwzz9Qbb7yhe+65J3n+/PPP16xZs7okZgAAAKAzkVBug5f/7wvZnQ4NP7R3ukMBAABAGtx00017Hdu+fbtKS0uTx6WlpaqsrNTu3btVXFwsh8PR5Hw22PrIrxWJRFPOuyvmSJLq1i5WfOenKeMFx5wre6/9FdmyRpH3Xk0Zd35/uJwHH6vYjk9Uv+6xlHFbz++osPw8SVJoxXzVR+L6cmdQX2+XvcQ+TpJ0QvxVlZk7U17jn7Zh2m700qHxdzXQ3JIyvsk4WG/bBqjM3KET4q+ljG83euqftuGSpLNjT6WMd0YM7zgO0Vvm99MaQybMg1UxGIaS35l8ngerYpgUf0rNtbDPt3ng74fsjIG/H/j7IR0xrCo5W7+YOFg2m9FsbNmEhHIbbPpwl7ZX15FQBgAAQIp4PC7D+OoXBNM0k5sGfv28pJTj1ujZs7jDMbbVVklOZ+qvDKWlXknSjiKXws2Md+/uUUGpV4GthQo0M+71Fspb6lV9zKOdzYy7ilzq1fgeW50OBWrrVBeOyet2KfE72H6lvobX2uNSYcSe8hq9u3lU4PKpZ7BIhaHU8Z7uIu3n8akkXKvC6tRxr9Ol/Uoa3qOwKnW8M2IocRekPYZMmAdiyM4YCjIghkyYB/5+IAZiSI2Bvx+aj+GAft1UWurtlIRyYi2WLoaZxdti79xZo3i868J/+Lkt+t/3qnTHz4d32Xvmm9JSr6qqAukOI2cxv9Zifq3F/FqL+bVWJszvtm2fqE+f/dMag1UcDtteW15883PbbEanJGZ/9KMf6eGHH9a+++6bPPfFF19oypQpev755yVJ69ev11133aUHHnhARx99tN544w3Z7XZ9+eWXOv/887V69eo2vWdXr32lzPjuStLTr32k5Ws+0n2zjpfDnjvbwGTK/OYq5tdazK+1mF9rMb/WYn6t1Zb57ay1b8rrdvor5jCf26lAKKxYhu00DgAAgPTr16+fCgoK9Oabb0qSnnrqKY0YMUJOp1NDhgzRs88+K0lavny5RowYkc5Qs04gGJGn0JFTyWQAAIBsxYqsDXwel0xTqglF0h0KAAAAMsT06dO1ceNGSdJtt92m+fPn65RTTlEoFNLkyZMlSXPnztXSpUs1evRorV+/XpdffnkaI84+1aGwvG5XusMAAACA6KHcJr7GRaw/FFG34oI0RwMAAIB0efHFF5N/XrRoUfLPAwYM0BNPPJFyfb9+/fTII490SWy5KBAMy+d2pjsMAAAAiArlNvE2LmL9wXCaIwEAAADyhz8Uls9DhTIAAEAmIKHcBolFrD9EQhkAACDdHnjgXj3wwL3pDgNdwB8My0tCGQAAICOQUG6DREI5QIUyAAAA0CWisbiCddFk+zkAAACkFz2U28Bd4JDDbqiaCmUAAJADQivmN3veXTFHklS3drHiOz9NGS845lzZe+2vyJY1irz36l7vb8kjjzykf/7zecVicR199FBFo1GVlvbWOeecL0m65ppZGjlytPbbbz8tXPgb1dbWavfuXfrxj6fo9NMntvZjIsvV1DZsiE3LCwAAgMxAhXIbGIahbsUFCgQj6Q4FAAAgq73++lpt2fKOFi16WA8+uFhVVVXy+brphReekySFQkFt2rRR5eXDtWLFU7rggot0//0P6667/qh77rkrzdGjKyX2L2FTPgAAgMxAhXIbdSsuoIcyAADICS1VEheWn/et486Dj5Xz4GPb9d7r1/9bmzdv0kUX/ViSVF9fp969+ygcrtfnn3+mjRs3aNiwY+V0OnXZZZfrX/9ap0ceeVD//e8Hqq0Ntes9kZ0Sa28vLS8AAAAyAgnlNiopLtCu6tp0hwEAAJDV4vGYzjrrHE2a1NDeIhAIyG63y+Mp1urVq7Rp01s6//wpkqRf/3q2vF6fhg07VieeODJZxYz8kHg6sBstLwAAADICLS/aqMRboAAVygAAAB1yxBH/T88996xCoZCi0ajmzLlCL720WiNHnqIXX3xen3/+mQYPPkyS9MYb/9a0aZfo2GOP1+uvr5UkxWKxNEaPrkSFMgAAQGahQrmNGlpeRGSapgzDSHc4AAAAWWn48BH64IP39JOfTFE8HtPRR5fr1FPHNuxZ0a1Ehx46KLnWmjp1ui69dJoKClw68MCD1LfvPvryy61p/gToKv5gWA67oaICe7pDAQAAgEgot1lJsUuRaFx14ZiKCpg+AACA9poyZZqmTJmWcv6uu/7Y5HjSpPOTrTG+7qKLLrYsNmQOfygsr9tFMQcAAECGoOVFG5V4CySJjfkAAACALhAIReSjfzIAAEDGIKHcRt2KGxLKic1BAAAAAFjHHwzLR/9kAACAjEFCuY0SCeXqIBXKAAAgu5imme4QulS+fd5c5Q+F5XM70x0GAAAAGpFQbqPujS0vArS8AAAAWcRudygSya/1SyQSlt3OnhfZzDRN+YO0vAAAAMgkJJTbyOehhzIAAMg+xcUl2rOnSuFwfc5X7pqmqXC4Xnv2VKm4uCTd4aAD6sIxRWNxeWl5AQAAkDEo2Wgjp8Mmd4GDHsoAACCrFBV5JEnV1TsUi0XTHE3nstlsisfjTc7Z7Q55vd2TnxvZyd/YZs7noeUFAABApiCh3A4+j0vVVCgDAIAsU1TkyckEa2mpV1VVgXSHAQskngpkUz4AAIDMQcuLdvC5nQqwKR8AAABgKX/jU4H0UAYAAMgcJJTbwetx0UMZAAAAsFhiI2x6KAMAAGQOEsrt4PO4kv3cAAAAAFgjseb2uumhDAAAkClIKLeDz+1SsC6qaCze8sUAAAAA2sUfCstT6JDDzq8tAAAAmYKVWTv4GiskamojaY4EAAAAyF3+UIT+yQAAABmGhHI7JBa1tL0AAAAArOMPhumfDAAAkGFIKLdDYlHLxnwAAACAdQKhcPLpQAAAAGQGEsrtkKhQDgRpeQEAAABYxR8M0/ICAAAgw5BQbgdfY4VyNS0vAAAAAEtEY3EF66LJtTcAAAAyAwnldigqsMthNxSg5QUAAABgiUCo4WlALxXKAAAAGYWEcjsYhiGv20UPZQAAAMAiieINKpQBAAAyCwnldvJ5XPLTQxkAAACwRKJ4w+dhUz4AAIBMQkK5nXxUKAMAAACW8QepUAYAAMhEJJTbyed20kMZAAAAsEjiaUAvCWUAAICMQkK5nRpaXoRlmma6QwEAAAByTiAUlsNuU1GBPd2hAAAA4GtIKLeT1+1SNGaqtj6W7lAAAACAnOMPheXzOGUYRrpDAQAAwNeQUG6nxOYgtL0AAAAAOp8/GKHdBQAAQAYiodxOPk/D4rY6SEIZAAAA6Gz+UFjdPCSUAQAAMg0J5XZK7DZNhTIAAADQ+QKhsLxuZ7rDAAAAwDeQUG6nxON3/lAkzZEAAAAAucU0TfmD4WQRBwAAADKHpQnlFStWaPTo0Ro5cqQWL1681+teeukl/ehHP7IylE6XqJbw0/ICAAAA6FS19TFFYyY9lAEAADKQw6oXrqys1MKFC/Xkk0/K5XJp0qRJOvroo9W/f/8m1+3YsUO33nqrVWFYxmG3yVPokJ+WFwAAAECnSrSVo4cyAABA5rGsQnnt2rUaOnSoSkpK5Ha7NWrUKK1cuTLlumuvvVaXXXaZVWFYyudxKUCFMgAAANCpEhtfez30UAYAAMg0liWUt2/frtLS0uRxWVmZKisrm1zz8MMP6wc/+IF++MMfWhWGpXxuFy0vAAAAgE6WqFCmhzIAAEDmsazlRTwel2EYyWPTNJscv/fee1q1apUeeughbdu2rV3v0bNncYfjbI/SUq8kqVcPtz7e6k8eo3Mwn9Zifq3F/FqL+bUW82st5tdazG9uSWx87aPlBQAAQMaxLKHcp08frV+/PnlcVVWlsrKy5PHKlStVVVWlCRMmKBKJaPv27Tr33HP12GOPtfo9du6sUTxudmrcLSkt9aqqKiBJKrAb2hOoSx6j474+v+h8zK+1mF9rMb/WYn6txfxaqy3za7MZaStKQOsl2soVF9HyAgAAINNY1vKivLxc69at065du1RbW6tVq1ZpxIgRyfEZM2boueee01NPPaX77rtPZWVlbUomZwKfx6VgXVTRWDzdoQAAAAA5ozoUlqfQIYfdsl9XAAAA0E6WrdB69+6tmTNnavLkyTr99NM1duxYDR48WNOnT9fGjRutetsulejpFmh8JA8AAABAxwWCYdpdAAAAZCjLWl5IUkVFhSoqKpqcW7RoUcp1++67r1588UUrQ7GEtzGh7A+G1d1bkOZoAAAAgNzgD0XYkA8AACBD8QxZB3RrrJrwN+5CDQAAAKDj/MGwvFQoAwAAZCQSyh3g9TRsEuIPklAGAAAAOksgFJbPzYZ8AAAAmYiEcgfQQxkAAADoXNFYXMG6KD2UAQAAMhQJ5Q4odNnldNioUAYAAAA6SaJYgx7KAAAAmYmEcgcYhiGf20kPZQAAAKCTJIo1vCSUAQAAMhIJ5Q7yul0klAEAAIBOEmhcW/s89FAGAADIRCSUO8jncdHyAgAAAOgk/mRCmQplAACATERCuYN8bheb8gEAAACdxB+khzIAAEAmI6HcQV6PU/5gWKZppjsUAAAAIOv5Q2E57DYVuuzpDgUAAADNIKHcQd3cLsXipkL10XSHAgAAAGS9QDCsbh6nDMNIdygAAABoBgnlDvI29najjzIAAADQcf5QRF7aXQAAAGQsEsodlOjtRh9lAAAAoOP8wTAb8gEAAGQwEsod5KNCGQAAAOg0/lBYXrcz3WEAAABgL0god5CvcbHrD5FQBgAAADrCNE0FQlQoAwAAZDISyh1U7HbKEBXKAAAAQEfV1kcVjZnJtnIAAADIPCSUO8hus8lT5JSfHsoAAABAhyTW1CSUAQAAMhcJ5U7g87gUoEIZAAAA6JDEU3+0vAAAAMhcJJQ7gc/tpIcyAAAA0EGBxjU1m/IBAABkLhLKncDncdFDGQAAAOggKpQBAAAyHwnlTuB1u+ihDAAAAHRQYk1dXESFMgAAQKYiodwJfG6nauujikTj6Q4FAAAAyFr+UFjFRU457PyaAgAAkKlYqXWCxCN5AfooAwAAAO3mD4bpnwwAAJDhSCh3Ap+7IaHMxnwAAABA+wWC4eTaGgAAAJmJhHIn8DZWKPuD9FEGAAAA2ssfirAhHwAAQIYjodwJfMmEMhXKAAAAQHsFQlQoAwAAZDoSyp3A19jnjR7KAAAAQPtEY3EF66LyeuihDAAAkMlIKHeCAqddLoeNHsoAAABAOwVCDe3jqFAGAADIbCSUO4FhGPJ5XLS8AAAAANopsZamhzIAAEBmI6HcSbxul/whNuUDAAAA2iPxtB8VygAAAJmNhHIn8bmdClChDAAAALRLokKZHsoAAACZjYRyJ/F5XKqmhzIAAADQLvRQBgAAyA4klDuJz+NSTSiiuGmmOxQAAAAg6/hDYTkdNhW67OkOBQAAAN+ChHIn8bpdisVNheqi6Q4FAAAAyDr+YFg+t1OGYaQ7FAAAAHwLEsqdxNfY681PH2UAAICctmLFCo0ePVojR47U4sWLU8ZffvllVVRUqKKiQldccYWCwaAkadmyZRo+fLjGjRuncePGaeHChV0dekbzh8Ly0u4CAAAg4znSHUCuSPR6C4TCkjzpDQYAAACWqKys1MKFC/Xkk0/K5XJp0qRJOvroo9W/f39Jkt/v1+zZs/XII4+of//+WrRokRYuXKhrr71WmzZt0uzZszV27Ng0f4rMFAhG1K2YhDIAAECmo0K5kyQSyv7GzUQAAACQe9auXauhQ4eqpKREbrdbo0aN0sqVK5PjH3/8sfbZZ59kgvmEE07QCy+8IEnauHGjli1bpoqKCv3yl79UdXV1Wj5DpvKHwmzIBwAAkAWoUO4kPk9jQpmWFwAAADlr+/btKi0tTR6XlZXprbfeSh4fcMAB2rZtm959910NGDBA//jHP7Rjxw5JUmlpqaZOnaojjjhCv/3tbzVv3jzdfvvtrX7vnj2LO++DtEFpqdfy9zBNU4FQWL17ebrk/TJJvn3ersb8Wov5tRbzay3m11rMr7XSPb8klDtJcZFThkgoAwAA5LJ4PN5k0zjTNJsc+3w+3XrrrfrVr36leDyus846S05nw14b99xzT/K6adOm6eSTT27Te+/cWaN43OzgJ2ib0lKvqqoClr9PqC6iaMyU01CXvF+m6Kr5zVfMr7WYX2sxv9Zifq3F/FqrLfNrsxmWFCXQ8qKT2GyGit3Oxh7KAAAAyEV9+vRRVVVV8riqqkplZWXJ41gspj59+uivf/2r/va3v+mQQw7Rfvvtp0AgoIceeih5nWmastvtXRl6Rku0jfN6aHkBAACQ6UgodyKfx6VqKpQBAAByVnl5udatW6ddu3aptrZWq1at0ogRI5LjhmFo6tSpqqyslGmaeuihhzR69Gi53W7df//92rBhgyTp0UcfbXOFci5LPOVHD2UAAIDMR8uLTuRzuxRgUz4AAICc1bt3b82cOVOTJ09WJBLRxIkTNXjwYE2fPl0zZszQoEGDNG/ePE2bNk3hcFjHHHOMLrroItntdt1xxx267rrrVFdXpwMOOEALFixI98fJGImEstftTHMkAAAAaAkJ5U7kdTv18TZ6xAAAAOSyiooKVVRUNDm3aNGi5J+PP/54HX/88Sn3DRkyRMuWLbM6vKyUaBvXjZYXAAAAGY+WF53I53GxKR8AAADQRom2ccVUKAMAAGQ8EsqdyOd2qS4cUzgSS3coAAAAQNYIhCIqLnLKbuPXEwAAgEzHiq0T+Rof0aOPMgAAANB6/lA4uZYGAABAZiOh3IkSu1L7Q7S9AAAAAForEAzLR7sLAACArEBCuRN5PQ2LYPooAwAAAK1XHYrI66ZCGQAAIBuQUO5EVCgDAAAAbddQoUxCGQAAIBuQUO5EyYQyFcoAAABAq0RjcYXqo/J5aHkBAACQDUgod6ICl10FTjub8gEAAACtlCjG8LIpHwAAQFYgodzJvG4nLS8AAACAVkoUY9DyAgAAIDuQUO5k3TwuWl4AAAAArZQoxvBRoQwAAJAVSCh3Mq/bJX+QlhcAAABAaySKMXxueigDAABkAxLKnczncSpAywsAAACgVRIVyl5aXgAAAGQFEsqdzOdxKRCKKG6a6Q4FAAAAyHiBYEROh02FLnu6QwEAAEArkFDuZF63S3HTVLCWthcAAABAS/yhsHxulwzDSHcoAAAAaAUSyp0ssTu1P0RCGQAAAGiJPxiWz0P/ZAAAgGxBQrmTJXanTmwuAgAAAGDv/KEw/ZMBAACyCAnlTpbYnZqN+QAAAICWBUKRZFEGAAAAMh8J5U7mpUIZAAAAaBXTNBtaXlChDAAAkDVIKHey4iKnDKPh0T0AAAAAexeqjyoWN5NP+QEAACDzkVDuZDbDkNftkj/IpnwAAADAt0k81eel5QUAAEDWIKFsAZ/bSQ9lAAAAoAWBUEMRBj2UAQAAsgcJZQv4PC56KAMAAAAtSKyZ6aEMAACQPUgoW8DndtFDGQAAAGhBYs1MD2UAAIDsQULZAl63S/4QPZQBAACAb+MPhmVIKiahDAAAkDVIKFvA53GqPhxTfSSW7lAAAACAjOUPReQpcspu49cSAACAbMHKzQKJHnAB+igDAAAAexUIhtmQDwAAIMuQULaAt3FRTNsLAAAAYO/8oTD9kwEAALIMCWULdEsklKlQBgAAAPbKH4pQoQwAAJBlSChbwNtYZZHYtRoAAABAKn8wLK+bhDIAAEA2IaFsgWQPZRLKAAAAQLMi0bhq66O0vAAAAMgyJJQt4HLaVeiyq5qWFwAAAECzEsUXtLwAAADILiSULeJzuxRgUz4AAACgWYn2cD5aXgAAAGQVEsoW8XqcbMoHAAAA7IU/2FB84aVCGQAAIKuQULaIz+1iUz4AAABgL5ItL+ihDAAAkFVIKFvE53EpQIUyAAAA0Cw/PZQBAACyEglli3jdLgVqI4rHzXSHAgAAAGQcfzAsl8OmAqc93aEAAACgDUgoW6SbxyXTlGpq2ZgPAAAA+CZ/MCKv2yXDMNIdCgAAANqAhLJFvI294OijDAAAAKQKhMK0uwAAAMhCJJQt4nM3LI7powwAAACk8gfDbMgHAACQhSxNKK9YsUKjR4/WyJEjtXjx4pTx559/XhUVFRozZoxmz56tcDh3kq+Jagt/iJYXAAAAwDf5Q2F5qVAGAADIOpYllCsrK7Vw4UI99thjWr58uZYsWaIPPvggOR4KhTRv3jw9+OCD+vvf/676+notW7bMqnC6XDKhTIUyAAAA0IRpmgqEIsmn+gAAAJA9LEsor127VkOHDlVJSYncbrdGjRqllStXJsfdbrdefPFF9erVS7W1tdq5c6d8Pp9V4XQ5d6FDNsOghzIAAADwDaH6qGJxkx7KAAAAWchh1Qtv375dpaWlyeOysjK99dZbTa5xOp16+eWXdeWVV6qsrEzDhw9v03v07FncKbG2VWmpt1XXlXhdisRbfz0aMF/WYn6txfxai/m1FvNrLebXWsxvdkk8xUcPZQAAgOxjWUI5Ho/LMIzksWmaTY4TjjvuOP3rX//Sb3/7W1133XW6/fbbW/0eO3fWKB43OyXe1iot9aqqKtCqaz2FTm3fGWz19Wjb/KLtmF9rMb/WYn6txfxai/m1Vlvm12Yz0laUgK8kEsr0UAYAAMg+lrW86NOnj6qqqpLHVVVVKisrSx7v2bNHr776avK4oqJCW7ZssSqctPC5nbS8AAAAAL4h0LhxdTd6KAMAAGQdyxLK5eXlWrdunXbt2qXa2lqtWrVKI0aMSI6bpqlZs2Zp69atkqSVK1fqiCOOsCqctPB5XGzKBwAAAHxDNRXKAAAAWcuylhe9e/fWzJkzNXnyZEUiEU2cOFGDBw/W9OnTNWPGDA0aNEg33HCDLr74YhmGof79++v666+3Kpy08LpdVCgDAAAA3xAIhWVIKi6y7NcRAAAAWMTSFVxFRYUqKiqanFu0aFHyzyeddJJOOukkK0NIK5/HpXAkrvpwTAUue7rDAQAAADKCPxSRp8gpu82yByYBAABgEVZwFvI19oSjShkAAAD4SiAYVjfaXQAAAGQlEsoW8nmckkQfZQAAAOBrqkNhed3OdIcBAACAdiChbCEvFcoAAABAikAwLB8VygAAAFmJhLKFEo/xBUKRNEcCAAAAZA5/KJJsDwcAAIDsQkLZQonH+KppeQEAAABIkiLRmGrro/JSoQwAAJCVSChbyOmwq6jArgAJZQAAAEDSV0/v+eihDAAAkJVIKFvM53bRQxkAAABolFgb0/ICAAAgO5FQtpjX45KfCmUAAABAkuQPNlYo0/ICAAAgK5FQtpjP7WJTPgAAAKBRotiCHsoAAADZiYSyxXweWl4AAAAACYFkywt6KAMAAGSjViWUa2pqJEmbN2/W8uXLFYlQcdtaPrdTNaGIYvF4ukMBAAAA0s4fCsvltKnQ5Uh3KAAAAGiHFhPKd955p+bOnautW7dq2rRpevLJJ3Xdddd1QWi5wet2yZRUUxtNdygAAABA2vmDYTbkAwAAyGItJpRffvll3XjjjVq1apXGjBmjhx9+WO+++25XxJYTujX2hguwMR8AAAAgfygiLwllAACArNWqlhdFRUVau3athg4dKkkKh0mOtpa3sTdcNX2UAQAAAAWCYfonAwAAZLEWE8rdu3fXddddp02bNqm8vFy33XabysrKuiK2nOCjQhkAAABI8ofCyTUyAAAAsk+LCeVbb71VZWVluvfee1VUVCTDMHTrrbd2RWw5IbFY9ofYyBAAAAD5LW6aCoQiJJQBAACyWItbK/fq1UuTJ09WcXGxNm/erAMPPFDdunXrithygrvAIbvNkJ8KZQAAAOS5UF1UsbhJD2UAAIAs1mJC+c4779Snn36qK664QtOmTVP//v31xhtv6KabbuqK+LKeYRjyup3y00MZAAAAeS7QuCb2eeihDAAAkK1abHnx8ssv68Ybb9SqVas0ZswYPfzww3r33Xe7Irac4fO46KEMAACAvJd4as9HhTIAAEDWajGhLElFRUVau3athg4dKkkKh0mOtoXP7aJCGQAAAHkvsa8ICWUAAIDs1WJCuXv37rruuuu0adMmlZeX67bbblNZWVlXxJYzvG6X/EE25QMAAEB+S1Qoe9mUDwAAIGu1mFC+9dZbVVZWpvvuu09FRUUyDEO33nprV8SWM7p5XAqEwjJNM92hAAAAAGkTCIVlSPIW0UMZAAAgW7W4KV+vXr00btw4/fvf/9Y777yjiRMnqlevXl0RW87wepwKR+OqC8dUVNDilAMAAAA5yR8Mq9jtlM1mpDsUAAAAtFOLFcpr1qzRhAkT9MILL2j16tWaOHGiXnjhha6ILWckesQF6KMMAACAPOYPReifDAAAkOVaLJe988479eijj6p///6SpPfff1+zZs3SSSedZHlwucLX2CPOH4qorHuagwEAAADSxB8KJ9fGAAAAyE4tVihHIpFkMlmSDjroIMViMUuDyjWJKozEJiQAAABAPvIHw/K66Z8MAACQzVpMKBcWFmrjxo3J440bN6qoqMjSoHJNYtHsp+UFAAAA8lggFKblBQAAQJZrseXFrFmzdMkll2j//feXYRj68MMPdeedd3ZFbDkj8VhfgAplAAAA5KlINKba+pi8tLwAAADIai0mlIcMGaK///3v2rBhg+LxuA477DB1704j4LZw2G1yFzjkD0bSHQoAAACQFom1cDcSygAAAFmtxZYXklRSUqLjjjtOJ5xwgrp3765zzjnH6rhyjtfjouUFAAAA8lZiLUwPZQAAgOzWqoTyN23ZsqWz48h53dxOBUgoAwAAZL0VK1Zo9OjRGjlypBYvXpwy/vLLL6uiokIVFRW64oorFAwGJUlbt27Veeedp1NOOUWXXnpp8ny+SKyF6aEMAACQ3dqVUEbbeT0uVdNDGQAAIKtVVlZq4cKFeuyxx7R8+XItWbJEH3zwQXLc7/dr9uzZWrhwoVasWKEBAwZo4cKFkqTrr79e5557rlauXKmBAwfq97//fbo+RlokWl74aHkBAACQ1UgodxGf26VAiB7KAAAA2Wzt2rUaOnSoSkpK5Ha7NWrUKK1cuTI5/vHHH2ufffZR//79JUknnHCCXnjhBUUiEb3xxhsaNWqUJGn8+PFN7ssHfiqUAQAAcsJeN+W78cYbmz1vmqYiERKjbeXzuFRTG1EsHpfdRh4fAAAgG23fvl2lpaXJ47KyMr311lvJ4wMOOEDbtm3Tu+++qwEDBugf//iHduzYod27d6u4uFgOR8Pyu7S0VJWVlW167549izvnQ7RRaam3U14nakoFLrv27VfSKa+XKzprftE85tdazK+1mF9rMb/WYn6tle753WtCuaSkZK83XXzxxVbEktN8jZuPBEIRlRQXpDkaAAAAtEc8HpdhGMlj0zSbHPt8Pt1666361a9+pXg8rrPOOktOpzPlOkkpxy3ZubNG8bjZsQ/QRqWlXlVVBTrltSp31Mhb5Oy018sFnTm/SMX8Wov5tRbzay3m11rMr7XaMr82m2FJUcJeE8qXXXZZp79ZPvM2PtrnD4ZJKAMAAGSpPn36aP369cnjqqoqlZWVJY9jsZj69Omjv/71r5Kkt956S/vtt5969OihQCCgWCwmu92ecl8+8AfD9E8GAADIAfRe6CKJxTN9lAEAALJXeXm51q1bp127dqm2tlarVq3SiBEjkuOGYWjq1KmqrKyUaZp66KGHNHr0aDmdTg0ZMkTPPvusJGn58uVN7ssH/lCE/skAAAA5gIRyF0kklP3BcJojAQAAQHv17t1bM2fO1OTJk3X66adr7NixGjx4sKZPn66NGzfKZrNp3rx5mjZtmk455RT5fD5ddNFFkqS5c+dq6dKlGj16tNavX6/LL788vR+mi/lDYXkb28ABAAAgfXbv3t2h+/fa8iIhGo0mNw9B+yV6KCd2twYAAEB2qqioUEVFRZNzixYtSv75+OOP1/HHH59yX79+/fTII49YHV5GipumakIRWl4AAABkgDFjxuiYY47ROeecoyFDhrT5/hYrlE844QQtXLhQX3zxRbsCRIOiAoccdoOEMgAAAPJOqC6qWNyk5QUAAEAGePHFF1VeXq4FCxaooqJCixcvVk1NTavvbzGhvHTpUtntdp1//vm6+OKL9dJLL8k0u3Z36VxgGIa8bhctLwAAAJB3Emtgr4eWFwAAAOlWWFioCRMmaOnSpbr22mv1pz/9Sccee6yuv/76VrXDaDGh3LdvX82YMUOrV6/WmWeeqRtuuEEnnnii7r//foXDJEfbwud2sSkfAAAA8k6g8Sk9KpQBAAAywyuvvKKf//znmjlzpk466SQ9/vjj6tu3r37605+2eG+rmiP/97//1V//+lc988wzOuywwzR+/HitWbNGv/jFL/SHP/yhwx8gX/g8VCgDAAAg/1Q3roHpoQwAAJB+J5xwgkpKSnTuuefqN7/5jQoLCyVJBx98sJYsWdLi/S0mlM855xx99tlnmjBhgp544gn16dNHUsNmI0OHDu1g+PnF53bqix2t70cCAAAA5ILEU3pUKAMAAKTf7bffroMPPlgej0fhcFg7d+5Uz549JUmrV69u8f4WW16ce+65+uc//6mZM2cmk8mSZLPZ9M9//rMDoecfr8clfzBCD2oAAADkFX8wLMOQiovooQwAAJBu27Zt0xlnnCFJ+uKLLzRmzBi9+OKLrb6/xQrlU089VUuWLNGrr74qu92uE044QRMmTJAkeTyedoadn3xul6KxuOrCMRUVtKrbCAAAAJD1AqGwvEVO2WxGukMBAADIe3/84x/18MMPS5K++93vatmyZfrpT3+qH/3oR626v8Ws5k033aQPPvhA48aNk2ma+tvf/qZPP/1UM2fO7FjkecjXuKu1PxgmoQwAAIC8UR0My0v/ZAAAgIwQj8ebdKLo27ev4vF4q+9vseXFa6+9pj/96U+aOHGizjzzTD344INauXJl+6LNc4mecf4QG/MBAAAgfwRCEfonAwAAZIgePXro8ccfVzQaVSwW0xNPPKFevXq1+v4WE8o9evRQLBZLHhuGIZ/P175o81xiV2t/MJLmSAAAAICu4w+F5XXTPxkAACATzJs3T0uXLtXgwYM1ePBgLV26VHPnzm31/S32XRgwYIDOPfdcjR8/Xna7Xc8++6y6d++uBx98UJJ04YUXtj/6POOlQhkAAAB5yB8MJ4srAAAAkF4HHHCAnnzySVVXV8tut6u4uLhN97eYUK6vr9fBBx+st99+W5K07777SpLee++9doSb3xJVGYEgCWUAAADkh3AkprpwjJYXAAAAGWLXrl16+umnFQwGZZqm4vG4PvnkE91+++2tur/FhPL8+fMlSV988YWi0aj233//jkWcxxx2mzyFDiqUAQAAkDcCoYZ2b1QoAwAAZIbLL79chYWF+uCDD1ReXq61a9fqyCOPbPX9LfZQ/uSTTzRmzBidfvrpGj9+vE466ST997//7VDQ+czncclPhTIAAADyRKKYggplAACAzLB161bdd999GjFihM4//3z95S9/0Ycfftjq+1tMKM+bN0/Tpk3TG2+8oTfffFOXXnqprr/++g4Fnc+8bpf8ITblAwAAQH5IFFN4PWzKBwAAkAl69eolqaGX8nvvvafevXsrGo22+v4WE8o7d+7UGWeckTyeMGGCdu/e3Y5QITVUKAdoeQEAAIA8QYUyAABAZunZs6fuv/9+DRw4UH/729/04osvqq6urtX3t5hQjsVi2rNnT/J4165d7QoUDXxuJy0vAAAAkDeSPZRJKAMAAGSEefPmyeVyaciQIRo4cKDuuusu/fKXv2z1/S1uynf++efr7LPP1qmnnirDMPTss8/qggsu6FDQ+czndilYF1U0FpfD3mI+HwAAAMhq/mBYBU67Clz2dIcCAAAASbfeeqsWLFggSZo1a5ZmzZrVpvtbTCiPHz9e+++/v9asWaN4PK65c+eqvLy8fdEiubt1IBRRd29BmqMBAAAArOUPheV10z8ZAAAgU7zzzjsyTVOGYbTr/hYTyhMnTtRTTz2loUOHtusN0JS38VE/fzBMQhkAAAA5LxAMJ4sqAAAAkH5lZWUaM2aMfvjDH8rj8STPX3vtta26v8WEclFRkbZt26Y+ffq0P0ok+Rp3t2ZjPgAAAOQDfyiinr7CdIcBAACARocffrgOP/zwdt/fYkK5trZWJ554ovr06SO32508v2LFina/aT5LVGf4SSgDAAAgD/iDYX23rzfdYQAAAKDRZZdd1qH7W0woX3PNNR16AzTlS7a8iKQ5EgAAAMBacdNUIBRJtn0DAABA+lVUVDR7vrUFxC0mlJcvX66bb765ybkZM2boqKOOatUboKlCl10Ou40KZQAAAOS8UF1UcdNMFlUAAAAg/X71q18l/xyJRPT3v/9d++23X6vv32tCee7cuaqsrNSbb76pXbt2Jc9Ho1F99tln7QwXhmGom8epQJCEMgAAAHJbdeOal035AAAAMsc3C4XLy8s1adIkXXrppa26f68J5YkTJ+r999/Xli1bNGrUqOR5u92uww47rH3RQpLkdbtUTYUyAAAAclyiiMLndqY5EgAAAOzN7t27tX379lZfv9eE8qBBgzRo0CCVl5erT58+nRIcGvg8LlXXkFAGAABAbku0efNSoQwAAJAxvtlDeevWrTr77LNbfX+LPZS//PJLzZo1S9XV1TJNM3m+tU2akcrndumz7TXpDgMAAACwVCDUsBE1LS8AAAAyx9d7KBuGoR49eujAAw9s9f0tJpR//etfa/z48frBD34gwzDaFyWa8HqcCoTCMk2TOQUAAEDOqg6GZRhScSEtLwAAADLFd77zHf3xj3/Uddddpw8//FC33Xab5s2bp169erXq/hYTyg6HQxdeeGGHA8VXfG6XojFTtfVRuVlcAwAAIEcFQmF5i5yy2SiiAAAAyBSzZ8/Wj370I0lSv379dNRRR2nOnDlatGhRq+63tXTBQQcdpC1btnQsSjSReOTP3/gIIAAAAJCL/MEw/ZMBAAAyzO7duzV58mRJUkFBgaZMmaKqqqpW399ihfJnn32mCRMmaJ999lFBQUHyPD2U28/nbkwoB8Pq08Od5mgAAAAAa/hD4eTaFwAAAJkhFoupsrJSvXv3liTt2LGjyd55LWkxoTxz5sz2R4dmed0NbS78wXCaIwEAAACsEwhG9N19itIdBgAAAL5mypQpOv3003XsscfKMAytXbtWV155ZavvbzGhfNRRR+mtt97S5s2bNX78eL399ts6/PDDOxR0vuvW+NhfIERCGQAAALnLHwoniykAAACQGSZOnKiBAwfq9ddfl91u17Rp03TQQQe1+v4Weyg/+eSTmjNnju6//34FAgH99Kc/1dKlSzsUdL4rblxUV1OhDAAAgBwVjsRUF44liykAAACQGSorK/X4449rypQpGjZsmBYuXNimHsotJpQfeeQRLVmyRMXFxerZs6eefPJJ/fnPf+5Q0PnObrOpuMipAJvyAQAAIEf5G5/G89JDGQAAIKNcddVV+t73vidJ6tevn4466ihdffXVrb6/xYSyzWZTcXFx8rhv376y2+3tCBVf5/O4kotsAAAAINckiifYlA8AACCz7N69W5MnT5YkFRQUaMqUKZ1boVxSUqJ33nlHhmFIkp5++ml169atneEiwed2sikfAAAAclZirev10EMZAAAgk8RiMVVWViaPd+zYIdM0W31/i5vyXX311frFL36hTz/9VMOHD1dBQYF+//vfty9aJHndLn26vSbdYQAAAACWSCSUu1GhDAAAkFGmTJmi008/Xccee6wkad26dbryyitbfX+LCeUDDzxQTz31lD7++GPFYjF997vfldNJlUFH+TwuBahQBgAAQI6ihzIAAEBmmjhxogYOHKjXX39ddrtd3/nOd/Twww+roqKiVfe32PJCkux2uw488EDdfvvtJJM7ic/tVKg+qkg0nu5QAAAAgE4XCEVU4LSrwMX+KwAAAJmmb9++CofDuv/++/XnP/85Wa3cGi1WKH/d9u3b2xTYihUr9Ic//EHRaFQXXHCBzjvvvCbjL7zwgu6++26Zpql9991X8+fPz5v+zF5PQ6VGIBRWD19hmqMBAAAAOpc/FJaP/skAAAAZ5cMPP9Sf//xnPf300+rXr5/q6ur04osvyuv1tvo1WlWhnNCW5syVlZVauHChHnvsMS1fvlxLlizRBx98kByvqanRddddp/vuu09PP/20Dj74YN19991tCSerJXrJJXa/BgAAAHKJPxiWj3YXAAAAGeMnP/mJzj//fDmdTj388MN65pln5PF42pRMltqYUJ4xY0arr127dq2GDh2qkpISud1ujRo1SitXrkyORyIRzZ07V71795YkHXzwwfryyy/bEk5WS1QoV9NHGQAAADnIH4zQPxkAACCDbN68WYceeqgOOugg7b///pIkwzDa/DotJpR37Nih1atXS5LefPNNXXDBBXr33XdbfOHt27ertLQ0eVxWVqbKysrkcffu3XXyySdLkurq6nTffffppJNOavMHyFY+d8Pjf4EQCWUAAADkngAtLwAAADLKSy+9pDPOOEPPPPOMhg8frhkzZqi+vr7Nr9NiD+XZs2dr+PDhWrdundasWaMpU6boxhtv1KOPPvqt98Xj8SYZbtM0m814BwIB/exnP9OAAQN0xhlntCn4nj2L23R9ZyktbVsZeHOKfUWSpLhhdMrr5RLmw1rMr7WYX2sxv9Zifq3F/FqL+c0scdNUIBSRz0OFMgAAQKZwOBwaPXq0Ro8erQ8++ECPP/646uvrNXLkSF144YU655xzWvc6LV2wZ88eTZkyRbfeeqvGjh2r8ePHa/HixS2+cJ8+fbR+/frkcVVVlcrKyppcs337dl100UUaOnSorr766lYF/HU7d9YoHm99X+fOUFrqVVVVoMOvY5qmXA6btm4PdMrr5YrOml80j/m1FvNrLebXWsyvtZhfa7Vlfm02I21FCfkkWBtR3DRpeQEAAJCh+vfvr2uvvVZXXHGFnn76aT3++OOtTii32PIiEokoEolozZo1Ki8vV21trUKhUIsvXF5ernXr1mnXrl2qra3VqlWrNGLEiOR4LBbTJZdcolNPPVXXXHNNu/p1ZDPDMOR1u+QPsikfAAAAcou/ceNpNuUDAADIbEVFRTr77LO1bNmyVt/TYoXyiSeeqGOOOUaHHHKIBg4cqLFjx2rs2LEtvnDv3r01c+ZMTZ48WZFIRBMnTtTgwYM1ffp0zZgxQ9u2bdPmzZsVi8X03HPPSZIGDhyom266qdXBZzufx0UPZQAAAOScQOPG07S8AAAAyD0tJpRnzJihs846S71795Yk3XbbbRowYECrXryiokIVFRVNzi1atEiSNGjQoFZt7pfLfG6ndgfa3vgaAAAAyGT+xqKJxEbUAAAAyB0ttrzYsWOH3n77bRmGod/85jeaP39+3ieCO4vX40outgEAAIBc4W+sUPZSoQwAAJBzWkwoz549W5999pnWrVunNWvWaNy4cbrxxhu7Irac183jUiAUkWl27caCAAAAgJX8oYgMQyoupEIZAAAg17SYUN6zZ4+mTJmiV155RWPHjtX48eNVW1vbFbHlPK/bpVjcVLAumu5QAAAAgE7jD4bldbtks+XXxtsAAAD5oMWEciQSUSQS0Zo1a1ReXq7a2lqFQqGuiC3nJXrKsTEfAAAAckkgFKZ/MgAAQI5qMaF84okn6phjjlH37t01cOBAnXnmmRo7dmxXxJbzErteJ3rMAQAAALnAH2qoUAYAAEDucbR0wYwZM3TWWWepT58+kqTbbrtNAwYMsDywfOBrXGT7Q5E0RwIAAAB0Hn8wrAP36ZbuMAAAAGCBFhPK8XhcK1as0CuvvKJoNKphw4apf//+cjhavBUt8FKhDAAAgBzkD0WoUAYAAMhRLba8uP322/X666/rggsu0IUXXqj//Oc/WrBgQVfElvO8RU4ZoocyAAAAckd9JKb6cEw+Dz2UAQAAclGLZcZr1qzR3/72NzmdDQvC448/Xqeddpquvvpqy4PLdTaboWK3kwplAAAA5IxEsQQVygAAALmpxQpl0zSTyWRJcrlcTY7RMT63ix7KAAAAyBn+YMPaNrEBNQAAAHJLiwnlAQMG6Oabb9ann36qzz77TPPnz9f3v//9rogtL/g8LvlpeQEAAIAckVjb+qhQBgAAyEktJpTnzp0rv9+vSZMm6ayzztKuXbv0q1/9qitiywteWl4AAAAghwSCiYQyTzUCAADkohZ7KN9777265ZZbuiKWvORzu9iUDwAAADkjUaHspeUFAABATmqxQvmll17qgjDyl8/jUm19TJFoLN2hAAAAAB3mD0ZU4LKrwGlPdygAAACwQIsVyvvuu6+mTp2qI444Qh6PJ3n+wgsvtDSwfJHYrMQfjKhnNxbdAAAAyG6BUJh2FwAAADmsxYRySUmJJOmLL76wOpa85G1cbPtDYfXsVpjmaAAAAICO8YfCbMgHAACQw1pMKM+fPz/553A4LJeLxWFnSlQo00cZAAAAucAfDKu0pCjdYQAAAMAie+2hHA6HddVVV+n5559Pnvv5z3+uOXPmKBqNdklw+SBRveEPRtIcCQAAANBx/lBEXiqUAQAActZeE8p33XWXampqdMQRRyTPzZs3T9XV1br77ru7JLh8kEwoU6EMAACALBc3zYYeyh56KAMAAOSqvSaUX3rpJd1+++3q2bNn8lzv3r21YMECvfDCC10SXD5I7IDtD5JQBgAAQHarqY3INEUPZQAAgBy214Sy0+lUYWHqJnHFxcX0Ue5kXreTHsoAAADIeoHGIonEPiEAAADIPXtNKNtsNtXU1KScr6mpoYdyJ/N5XFQoAwAAIOv5Qw37gtBDGQAAIHftNaE8duxYXXvttQqFQslzoVBI1157rUaOHNklweULn9uVXHwDAAAA2Srx1B0VygAAALlrrwnlCy64QF6vV8OGDdNZZ52liRMnatiwYfL5fPrZz37WlTHmPJ/HyaZ8AAAAyHrViZYXbjblAwAAyFWOvQ3YbDbdcMMNuuSSS/T222/LZrNp8ODBKisr68r48oLX7VIgGFHcNGUzjHSHAwAAALRLIBSWYUieIhLKAAAAuWqvCeWEfv36qV+/fl0RS97yeVyKm6ZCdVEVs/gGAABAlvIHI/K6XRRJAAAA5LC9trxA1/E1blrCxnwAAADIZv5gOLm2BQAAQG4ioZwBEj3mSCgDAAAgmwVCYfk8PHEHAACQy0goZ4DELthszAcAAJD5VqxYodGjR2vkyJFavHhxyvjbb7+tCRMm6LTTTtPFF18sv98vSVq2bJmGDx+ucePGady4cVq4cGFXh245f4gKZQAAgFzXYg9lWM/bmFAOhCJpjgQAAADfprKyUgsXLtSTTz4pl8ulSZMm6eijj1b//v2T19x0002aMWOGjjvuON1yyy164IEHNHPmTG3atEmzZ8/W2LFj0/gJrOUPRZLFEgAAAMhNVChngOJCpwxDqqblBQAAQEZbu3athg4dqpKSErndbo0aNUorV65sck08HlcwGJQk1dbWqrCwUJK0ceNGLVu2TBUVFfrlL3+p6urqLo/fSvWRmOrDMXndtLwAAADIZVQoZwCbzZC3yKkALS8AAAAy2vbt21VaWpo8Lisr01tvvdXkmtmzZ2vq1Km6+eabVVRUpKVLl0qSSktLNXXqVB1xxBH67W9/q3nz5un2229v9Xv37FncOR+ijUpLva26rnJXSJLUr7ev1feg9fOL9mF+rcX8Wov5tRbzay3m11rpnl8SyhnC53GxKR8AAECGi8fjMgwjeWyaZpPjuro6XXPNNXrooYc0ePBgPfjgg7rqqqt033336Z577kleN23aNJ188slteu+dO2sUj5sd/xBtUFrqVVVVoFXXfry1oVe04vFW35Pv2jK/aDvm11rMr7WYX2sxv9Zifq3Vlvm12QxLihJoeZEhvG4Xm/IBAABkuD59+qiqqip5XFVVpbKysuTxe++9p4KCAg0ePFiSdPbZZ+vf//63AoGAHnrooeR1pmnKbrd3WdxdIVEc0Y0eygAAADmNhHKG8HlcCgTZlA8AACCTlZeXa926ddq1a5dqa2u1atUqjRgxIjm+//77a9u2bfrwww8lSatXr9agQYPkdrt1//33a8OGDZKkRx99tM0VypkuURxBD2UAAIDcRsuLDOGjQhkAACDj9e7dWzNnztTkyZMViUQ0ceJEDR48WNOnT9eMGTM0aNAgzZ8/X5dffrlM01TPnj118803y26364477tB1112nuro6HXDAAVqwYEG6P06nSuwH4nNToQwAAJDLSChnCJ/HqbpwTOFITC5nbj3+CAAAkEsqKipUUVHR5NyiRYuSfz7uuON03HHHpdw3ZMgQLVu2zPL40sUfjKjQZWctCwAAkONoeZEhvI2VHFQpAwAAIBv5Q2GqkwEAAPIACeUM4WvcvCQQoo8yAAAAso8/GJbXQ/9kAACAXEdCOUMkqjmqg1QoAwAAIPsEqFAGAADICySUM4SvcTfsAAllAAAAZCF/MJx86g4AAAC5i4RyhvB66KEMAACA7BSPmwrURpL7ggAAACB3kVDOEAVOuwpcdvmD9FAGAABAdqmpi8g0v3rqDgAAALmLhHIG8bmdClChDAAAgCyTaNtGywsAAIDcR0I5g/g8LlpeAAAAIOv4EwllWl4AAADkPBLKGcTndiUX4wAAAEC28Ica2rZ5qVAGAADIeSSUM4jX7UouxgEAAIBskXjKjh7KAAAAuY+EcgbxeVwKhMKKm2a6QwEAAABazR8My2YY8hSRUAYAAMh1JJQziM/tlGlKNbVUKQMAACB7BEJhed1O2Qwj3aEAAADAYiSUM0hiV+wAfZQBAACQRfzBiLxsyAcAAJAXSChnkMSu2PRRBgAAQDYJhMLq5qHdBQAAQD4goZxBErti+6lQBgAAQBapDoaTa1kAAADkNhLKGSSxK3Zil2wAAAAgGwRCkeTTdgAAAMhtJJQziKeoYSOTAAllAAAAZIn6cEz1kZi8blpeAAAA5AMSyhnEZhjyup20vAAAAEDWSDxd56PlBQAAQF4goZxhvG6X/EE25QMAAEB2SCaUaXkBAACQF0goZ5huHictLwAAAJA1Ao3FEFQoAwAA5AcSyhnG63GpmpYXAAAAyBJUKAMAAOQXEsoZxud2KRCi5QUAAACyQ2L/DzblAwAAyA8klDOMz+NSfSSm+nAs3aEAAAAALfKHwip02eVy2tMdCgAAALoACeUMk6js8NNHGQAAAFkgEIrQ7gIAACCPkFDOMInFOAllAAAAZAN/MMyGfAAAAHmEhHKGSSzGE7tlAwAAAJnMHwrTPxkAACCPkFDOMFQoAwAAIJsEqFAGAADIKySUM4zP09hDOUhCGQAAAJktHjcVqKWHMgAAQD4hoZxhnA67igrsVCgDAAAg49XURmSaokIZAAAgj5BQzkBet4sKZQAAAGS8RBEEPZQBAADyBwnlDORzuxQIsSkfAAAAMlugsQiClhcAAAD5g4RyBvJ5XLS8AAAAQMarblyz0vICAAAgf5BQzkA+t5OWFwAAAMh4gWDDU3UklAEAAPIHCeUM5HW7VBOKKB430x0KAAAAsFf+UFg2w5C70JHuUAAAANBFSChnIJ/HJVMNu2YDAAAAmcofDMvrccpmGOkOBQAAAF2EhHIGSjwySNsLAAAAZLJAKMKGfAAAAHmGhHIG8rmdksTGfAAAAMho/lA4uXYFAABAfiChnIGSFcoklAEAAJDBGlpeUKEMAACQT0goZyCvO9Hygh7KAAAAyFwNFcoklAEAAPIJCeUM5C50yG4zFKBCGQAAABmqPhxTOBJPPl0HAACA/EBCOQPZDENet5NN+QAAAJCxEu3ZvPRQBgAAyCsklDOUz+0ioQwAAICMlVirdqNCGQAAIK+QUM5QXo9L/hA9lAEAAJCZvqpQJqEMAACQT0goZyif20UPZQAAAGSsQGPxA5vyAQAA5BdLE8orVqzQ6NGjNXLkSC1evHiv11155ZV68sknrQwl6/g8DT2UTdNMdygAAABAikTLC5+HHsoAAAD5xLKEcmVlpRYuXKjHHntMy5cv15IlS/TBBx+kXHPJJZfoueeesyqMrOVzuxSOxlUfiaU7FAAAACCFPxhWUYFdToc93aEAAACgC1mWUF67dq2GDh2qkpISud1ujRo1SitXrmxyzYoVK3TiiSfq1FNPtSqMrOVr3NyEPsoAAADIRP5QmP7JAAAAeciyhPL27dtVWlqaPC4rK1NlZWWTa6ZNm6YzzzzTqhCyWmJxnniUEAAAAMgkgVCE/skAAAB5yGHVC8fjcRmGkTw2TbPJcWfo2bO4U1+vtUpLvZa/x/51Da0uDIe9S94vk+Tb5+1qzK+1mF9rMb/WYn6txfxai/ntev5gWL17uNMdBgAAALqYZQnlPn36aP369cnjqqoqlZWVdep77NxZo3i8azetKy31qqoqYPn7xMINrS4+/7JaVb3TkzhPh66a33zF/FqL+bUW82st5tdazK+12jK/NpuRtqKEXOMPhXXQvt3SHQYAAAC6mGUtL8rLy7Vu3Trt2rVLtbW1WrVqlUaMGGHV2+UcWl4AAAAgU8XjpmpCEXooAwAA5CHLEsq9e/fWzJkzNXnyZJ1++ukaO3asBg8erOnTp2vjxo1WvW3OcDpsKipwsCkfAAAAMk5NbUSmvtpIGgAAAPnDspYXklRRUaGKioom5xYtWpRy3S233GJlGFnL53EpEKJCGQAAAJkl8RQdCWUAAID8Y1mFMjrO53bS8gIAAAAZx99Y9OBzO9McCQAAALoaCeUM5nO7aHkBAACAjJNIKNNDGQAAIP+QUM5gPo+LCmUAAABkHH+woeiBlhcAAAD5h4RyBvO6nQrWRhSLx9MdCgAAAJAUCIVltxlyF1q6JQsAAAAyEAnlDObzuGRKqqHtBQAAADKIPxhWsdspm2GkOxQAAAB0MRLKGczX2JOOPsoAAADIJIFQJLlWBQAAQH4hoZzBEj3p6KMMAACATFIdDNM/GQAAIE+RUM5gXrdT0le7aAMAAACZIBAKy9e4VgUAAEB+IaGcwbo1Vn0EqFAGAABABvGHwvLS8gIAACAvkVDOYEUFDtlthqqpUAYAAECGqAtHFY7Ek8UPAAAAyC8klDOYYRjyeVwKBNmUDwAAAJkhsWE0FcoAAAD5iYRyhvO5XfRQBgAAQMZItGPzeeihDAAAkI9IKGc4r8cpPz2UAQAAkCESxQ5UKAMAAOQnEsoZzud2KUCFMgAAADJEotiBHsoAAAD5iYRyhvN5XPKHIjJNM92hAAAAAF/roUzLCwAAgHxEQjnD+dwuRaJx1YVj6Q4FAAAAUCAYVlGBXU6HPd2hAAAAIA1IKGe4ROUHG/MBAAAgE/hDYfnonwwAAJC3SChnuERvukAwkuZIAAAAgIYeyl76JwMAAOQtEsoZLrF7dnWQCmUAAACkXyAUoUIZAAAgj5FQznC+RIUyLS8AAACQARpaXrAhHwAAQL4ioZzh6KEMAACATBGLx1UTiiSLHgAAAJB/SChnOIfdJk+hQ35aXgAAACDNamqjMvVVWzYAAADkHxLKWcDrdskfYlM+AAAApFegsciBCmUAAID8RUI5C/g8ruTiHQAAAEiX6sY2bPRQBgAAyF8klLOAz+2khzIAAADSjgplAAAAkFDOAl6Pix7KAAAAGWLFihUaPXq0Ro4cqcWLF6eMv/3225owYYJOO+00XXzxxfL7/ZKkrVu36rzzztMpp5yiSy+9VMFgsKtD77BEGzZ6KAMAAOQvEspZoJvbpWBdVNFYPN2hAAAA5LXKykotXLhQjz32mJYvX64lS5bogw8+aHLNTTfdpBkzZujpp5/Wd7/7XT3wwAOSpOuvv17nnnuuVq5cqYEDB+r3v/99Oj5ChwRCYdlthtyFjnSHAgAAgDQhoZwFvI2PFAbYmA8AACCt1q5dq6FDh6qkpERut1ujRo3SypUrm1wTj8eT1ce1tbUqLCxUJBLRG2+8oVGjRkmSxo8fn3JfNqgOhuV1O2UzjHSHAgAAgDQhoZwFEpueBOijDAAAkFbbt29XaWlp8risrEyVlZVNrpk9e7auvfZaDR8+XGvXrtWkSZO0e/duFRcXy+FoqOwtLS1NuS8bBIJh+Wh3AQAAkNd4Vi0LJDY9YWM+AACA9IrH4zK+Vp1rmmaT47q6Ol1zzTV66KGHNHjwYD344IO66qqrdMMNNzS5TlLKcUt69izuWPDtVFrqTf65NhJTz5KiJufQMcyltZhfazG/1mJ+rcX8Wov5tVa655eEchZIVIGwMR8AAEB69enTR+vXr08eV1VVqaysLHn83nvvqaCgQIMHD5YknX322brzzjvVo0cPBQIBxWIx2e32lPtaY+fOGsXjZud8kFYqLfWqqirwVQx76tRzv8Im59B+35xfdC7m11rMr7WYX2sxv9Zifq3Vlvm12QxLihJoeZEFvMmEMj2UAQAA0qm8vFzr1q3Trl27VFtbq1WrVmnEiBHJ8f3331/btm3Thx9+KElavXq1Bg0aJKfTqSFDhujZZ5+VJC1fvrzJfdnANE0FQmH5PM50hwIAAIA0okI5CxQV2OWw2+ihDAAAkGa9e/fWzJkzNXnyZEUiEU2cOFGDBw/W9OnTNWPGDA0aNEjz58/X5ZdfLtM01bNnT918882SpLlz52r27Nn6wx/+oL59++q3v/1tmj9N29RHYgpH4/RQBgAAyHMklLOAYRjyeZy0vAAAAMgAFRUVqqioaHJu0aJFyT8fd9xxOu6441Lu69evnx555BHL47OKP9TwtJyXhDIAAEBeo+VFlvC6XclFPAAAANDVEsUNiQ2jAQAAkJ9IKGeJbh6X/LS8AAAAQJoEkglleigDAADkMxLKWcLrpuUFAAAA0idR3EAPZQAAgPxGQjlL+NwuBUJhmaaZ7lAAAACQhxLFDfRQBgAAyG8klLOEz+NSNGaqtj6W7lAAAACQh/yhiIoKHHI6+BUCAAAgn7EazBKJRwsD9FEGAABAGgRCYfnc9E8GAADIdySUs4S3cfOTavooAwAAIA38wbC8HtpdAAAA5DsSylmCCmUAAACkkz8UUTf6JwMAAOQ9EspZwtdYDeIPRdIcCQAAAPIRFcoAAACQSChnjeKihpYXflpeAAAAoIvF4nEFayP0UAYAAAAJ5WzhsNtUXOSUn5YXAAAA6GI1oYhMffXUHAAAAPIXCeUs4nU7FaBCGQAAAF0s0XbNRw9lAACAvEdCOYv43C5aXgAAAKDLJZ6S89LyAgAAIO+RUM4iPo+LTfkAAADQ5RJFDbS8AAAAAAnlLOJzuxSghzIAAAC6WICEMgAAABqRUM4iXo9TwbqoorF4ukMBAABAHvGHIrLbDLkLHOkOBQAAAGlGQjmLJCpCArS9AAAAQBfyh8Lyup0yDCPdoQAAACDNSChnkcSu2mzMBwAAgK7kD4ZpdwEAAABJJJSzSjKhTB9lAAAAdKFAKJxciwIAACC/kVDOIj6PUxIVygAAAOha/mBEXhLKAAAAEAnlrJJYxNNDGQAAAF3FNE35Q+FkcQMAAADyGwnlLFLossvpsFGhDAAAgC5TF44pEo3TQxkAAACSSChnFcMw5HO76KEMAACALhNoXHvSQxkAAAASCeWs4/M4SSgDAACgy/gb263RQxkAAAASCeWs43W7aHkBAACALpNYe3aj5QUAAABEQjnr+DwuNuUDAABAl0k8Hed1sykfAAAASChnHV9jhbJpmukOBQAAAHkgEEwklKlQBgAAAAnlrONzOxWLmwrVR9MdCgAAAPKAPxhRUYFDTge/OgAAAICEctbxNfauo48yAAAAuoI/FE6uQQEAAAASylnG27iYp48yAAAAukIgFJaP/skAAABoREI5y/jcVCgDAACg6/hDkeQaFAAAAHCkOwC0TbLlRYiEMgAAAKznD4Z18H4l6Q4DAACgTWKxqHbvrlI0mls5tO3bbYrH4ynnHQ6Xuncvld1ufbqXhHKWKS5yyBAVygAAALBeLBZXTW1EXlpeAACALLN7d5UKC93yePrIMIx0h9NpHA6botGmCWXTNBUM+rV7d5V69epreQy0vMgydptNniKn/PRQBgAAgMUSRQxsygcAALJNNBqWx+PLqWTy3hiGIY/H12XV2CSUs1A3j0sBKpQBAABgsT019ZJED2UAAJCV8iGZnNCVn5WEchbyup30UAYAAIDl9gQaE8pUKAMAALRbTU2N5sz5Zauvf/fdzbrllhssjKhj6KGchXwelz7ZFkh3GAAAAMhx1Y0VyvRQBgAAaL9AwK/339/S6usHDPiBZs/+gYURdQwJ5Szkc7vooQwAAADL7amhhzIAAEBH3XHHb7RjR5XmzPmlPvnkI3XrVqKCggLddNMCzZ9/g6qqtmvHjioNGXKUZs/+lf7znzf1pz/dp9/97j5ddtlP9IMfHKoNG/5Pe/bs1hVXXKWjjjomrZ+HhHIW8npcqq2PKhKNy+mgawkAAACssSdQJ7vNkLuAXxsAAED2em3jl3r1rS8tee3hg/tq2KC+33rN5ZfP0s9/frFmzPgfnXnmafrrX+9W37776PnnV+qgg76vG2+8VZFIROeff6a2bHk35f5IJKp7731Qr776iu699x4Symg7X+Mjh4FQWD18hWmOBgAAALmquiYsn8eVVxvaAAAAWKl79x7q23cfSdLJJ5+izZs3aenSx/Txxx+purpatbWhlHuOProhgfy97x0ov9/fpfE2h4RyFko8cugnoQwAAAAL7ampp38yAADIesMGtVxF3FUKCgqSf37iicf10ksv6rTTztDEiUfpo4/+K9M0U+5xuRpygYZhNDve1eiXkIV87saEcpA+ygAAALDOnpr65NoTAAAA7WO32xWLxVLOv/HGv3TaaeM1cuSpCofDev/99xSPx9MQYdtQoZyFvIkK5WA4zZEAAAAgl1XX1KusX7d0hwEAAJDVevToqd69++jmm69vcv6ss87VbbfN16OPPiiPp1gDBw7Wl19uVb9++6Yp0tYhoZyFujVWiQRCJJQBAABgDdM0VR2gQhkAAKCjHA6H/vjHP6WcP/LI/6e//OXJZu854oghkqTf/e6+5Lm+fffR8uV/VzSa3ipmWl5koQKXXS6nTX4SygAAALBIXTimcDQur4ceygAAAPgKCeUs5XO7aHkBAAAAyySKF6hQBgAAwNeRUG6jaM1umZG6tO+o6PO45A+xKR8AAACsEWjcANrnIaEMAACAr1jaQ3nFihX6wx/+oGg0qgsuuEDnnXdek/F33nlH11xzjYLBoIYMGaLrr79eDkdmt3X+7J6fyoyGJcMmuYpkOAtluNxyn/4rGQ6Xwhv+oXigSoarSHIWyXA1/M/e7weyuUsUrwtIkToZLnfDuK19OX2f26Vd/rpO/nQAAABAAyqUAQAA0BzLsreVlZVauHChnnzySblcLk2aNElHH320+vfvn7xm1qxZuvHGG3XYYYfp6quv1tKlS3XuuedaFVKHmaapnidfqMCu3TLDtcn/KVIr2Rt6y8WqPlLsi80N581Y8t6isVfJ5i5R5O3VCr+5/KsXdRTIcBXJ9cPRcg0aqdiuLxT+3+VfS0i7ZbiKZOvWW47v/LDxPT5WX2dAX/oDWv3q27LZbLLZbIq7PLLZDDniYdkMNZy3G7IZDeOGwyGbzS67YTaOG43X2GS3GbIZRsM5w5DdZsiwGbInztmMxmuUvCZx3mYYXfljAAAAQBdItFfzuumhDAAAgK9YllBeu3athg4dqpKSEknSqFGjtHLlSl122WWSpC+++EJ1dXU67LDDJEnjx4/XXXfdldEJZcMw5DtipOqrAnu9puikn0pqSD4rFpEZDknhOhme7pIkxwFHylbcU2Y49FVCOhyS4e3VcF84pPjOzxraaoRDUrRhIW/fd6Ac3/mhzFhEoWXX6RRJp7glbW5436hp0xW7z5ckzfQ9qwMcO1Ji+231qfokVqqKojd1UtHbTcbipqFnag/X6rqBOtixVdO9L8qUIVOGog2fXlsiffWnmuNlV0zzSp5oHJdMGY0x2HVzzQRJhi50r1Y/+67k6yeuebT+BG2Nl2qEc6OOdrybMv5YfLD+HRugA4xtOs25JjHzSjQY+czso7/HR8hhxHSRbdnXfzoNMRh2PazxMgxpjPmiStU0BkPSs8YJ2mHrqcPjmzTQ3PK18QYbbAP1tm2A9jG36fjYa4mXTr7Hl0ZvvewYLrsZ08ToUynzHDfsetJ1ugxJx0deUk9zV8o1LzmP1y5bTx0a3aTvx95LGd/sOFTvOQ5WWWybyiPrUsa323trnWuYbGZMY+uebjJmGFJcNv29aJwkaVj9y+oeb4jBZtgUb2zXsrZghHbbe+rgyNvqH0mN4V3nofrQ9X31ilXqqLrUGHbYy/RGYblsZkwjQyu+PkWSJFN2Pec5TZJ0TO3L6hbfnfIarxeNULW9hw6qf1vfi7yfMv6+61B95Pq+ekYrdeReYviPuyGGE4MrUsbjsmt1cYUk6ajQK+oWT/1Z/PtrMRwQ+SBl/APXIfq4MYbD6l5PGd9lL9N/io5piKH2WZnxpu1wYrLpJW9DDENCr8gXS52H9e5j5bf30IH1m7V/OHUe/ltwiD5pjOGHtakx7HSUaUNjDMfXPJM6D4ZdL3vHSpKODDYfw5uehhi+V79Z+4dT5+G/rkP0acFB6hHd3mwMu+yl2uBuiOG4mr+nxiCbXvE1zMMRwVfki+1JueZ/PcMbYqjbrO80E8NnxYfqQ9uB6hGt1KDQv1JjcJRpo3uobGZMxwaaj2GNr2EeDg+uaXYe/tczXAF7D313LzF8WHCIPis46Ntj8DTEMNz/bMq4adi0xjemIYaaNfI2Mw//8QxTwNFD3617R/vVp8bwUeGAhhgilRoY+rekJv/paZejVJu+JYa4YdOrjTEcVrMm+bOw2Q3FY2ZKDPs2Mw8fFzTE0D26XQObmYfdjrJkDMP8qT8LU3a92u2rGLzN/Cz+zzO8MYbN2reZefi4sOFn0T2yXQNDqd/JzozhgL38LD5u/Fk0xNDcPHz1sxhR8w/FvvH3gymbXmuM4Yd7+T5s8AxXwNFdB9S9s5d5GKDPG2M4dC8xvN0YQ3lz38k0x7Cr/1gdN2xQyj3IDMkKZVpeAAAA4GssSyhv375dpaWlyeOysjK99dZbex0vLS1VZWVlm96jZ8/ijgfaDqWl3jZc3fMbN/9A0g++5cWPkAYdkTw0Y1HFw7VSPC67xyszFpXnzNmK1wcVqa1V3DQVj5syTenhQScqHjdVt6VY8ZrdMhNj8bhM09QvvjtU8cJuMrf2VHj7gTLNuMy4mfz/4aUD9P+6HyjD/6VqP4s3JB7jZsP/m3GVFpbqoj4DFY9GFfroA8k0ZZpmYwLNlCmbxh1xoCTJs+1T1YV3SzIbM7UNv0QP6XWAQgU9VbanWuFAXePZxl+wTWkfbz8dU9xX3jpDkV39vnZ/wwVuV2/9sHupFI8qtr2Xvro98Uo29e9VIkly7SlRPPJVlXjiqt4+n9xOn3zBYpm1xV8baeAt8mifomL1CHukQFHKeIGjUKVet2xmTLbdzVXs2NStuECS5KyxyxazNw1AUlGhS8UOlwrq7LLXG00HJbmcdhUVOFUYdcgRM795uxw2qcDlkGGactY3/YySFDdM2R0N7+sMx+Rs/GcBmVIiGsMmGTZDDsXkVOoGj3bFZMqQzYzLpfqUz2A3I4qZDf94UmDWffMjKG7YFI03/Pwc8XoVxGu/8Q6mYtGowmZctlhYBfFQSgxmtF51RkyxWESF8WAzMdYqFI7JZkZVGKtJGY/JrlB9w2d3RIMqjKdeEw6HFbRFZUbqVBhN/ceimFGnGjMqb6xe7qg/Zbza9KimPipbPKaC8J6U8bhs8tc29KB0RAJyx6tTrqmrq5ffFpEZDcodTR2PmbXyRyPyxOvkjqa+R3W8SH4zIrsZa3Y8Jrv2NFaZOcJ+uc3Ua0KhOu2xhWVGa+RuJrEWjQe1OxJWUTwkdzR1fE+0ULvj4YYYIqnjcdm0K9DwPXJEquUxd6ZcU1NTq122eu0fDcgTTx0PVVdrh71OrnhQnljqeHXUqR3ROtnNmDzR1PGYbNrR2CrIGd3dbAyBQEg7bG59J+ZvNoZILKAd9XuPYU/UqarGGIqjVc3Mg11V1V/FUGym/uNfIBBSlc2t78SqVRxPfY1IrJ+q6hpiKI5VNfnvTpL2RByqjCTmIfX+mOyq3NMQgyO6W55mYqiOh1RluLVvrFreZmKoj+6jyto6OeI18sZSx6vDDlWGQ7KbMXmbjcGmyt2hxnnYKW8zP4vqWI2qjELtG9uz9xhCITnifstj2C+2W9546hqlPtr3azGkjvvDNlWGQ7LFY3LHtjUTg11f7mqI4cjYTnmb+VnsiQa03ShQv/heYoj01ZfBkGxm8zFUh236sr5xHpoZT3cMn4dq27iu2rvOeh185Xv7+DRq6P5y2Nl2BQAAAF8xTIt2l/vDH/6g+vp6XX755ZKkpUuXatOmTZo3b54k6c0339Ttt9+uxx57TJL08ccf65JLLtHKlStb/R47d9YoHrck/L0qLfWq6lsqlNExzK+1mF9rMb/WYn6txfxai/m1Vlvm12Yz0laU0FGsfXMP82st5tdazK+1mF9rMb/WypT53bbtE/Xps3+6w+g0DzxwryTp4osvVTQab/aab35mq9a+lpUb9OnTR1VVX1UEVVVVqaysbK/jO3bsaDIOAAAAAAAAAMgslrW8KC8v1913361du3apqKhIq1at0g033JAc79evnwoKCvTmm2/qyCOP1FNPPaURI0ZYFQ4AAAAAAAAApMUjjzykf/7zecVicR199FBFo1GVlvbWOec07Il2zTWzNHLkaO23335auPA3qq2t1e7du/TjH0/R6adPTHP0TVmWUO7du7dmzpypyZMnKxKJaOLEiRo8eLCmT5+uGTNmaNCgQbrtttt07bXXqqamRoceeqgmT55sVTgAAAAAAAAA8lRoxfxmz7sr5kiS6tYuVnznpynjBcecK3uv/RXZskaR917d6/3f5vXX12rLlne0aNHDMgxDN9zwa+2//wF64YXndM455ysUCmrTpo267rqb9fvf36ULLrhIQ4YcpS+++FxTppybPwllSaqoqFBFRUWTc4sWLUr+ecCAAXriiSesDAEAAAAAAAAA0mb9+n9r8+ZNuuiiH0uS6uvr1Lt3H4XD9fr888+0ceMGDRt2rJxOpy677HL961/r9MgjD+q///1AtbWhNEefytKEMgAAAAAAAACkW0uVxIXl533ruPPgY+U8+Nh2vXc8HtNZZ52jSZMa2lsEAgHZ7XZ5PMVavXqVNm16S+efP0WS9Otfz5bX69OwYcfqxBNH6oUXnmvXe1rJsk35AAAAAAAAACDfHXHE/9Nzzz2rUCikaDSqOXOu0EsvrdbIkafoxRef1+eff6bBgw+TJL3xxr81bdolOvbY4/X662slSbFYLI3Rp6JCGQAAAAAAAAAsMnz4CH3wwXv6yU+mKB6P6eijy3XqqWNlGIa6dSvRoYcOkmEYkqSpU6fr0kunqaDApQMPPEh9++6jL7/cmuZP0BQJZQAAAAAAAACw0JQp0zRlyrSU83fd9ccmx5MmnZ9sjfF1F110sWWxtRUtLwAAAAAAAAAArUJCGQAAAAAAAADQKiSUAQAAAAAAAACtQkIZAAAAAAAAQM4xTTPdIXSZrvysJJQBAAAAAAAA5BSHw6Vg0J8XSWXTNBUM+uVwuLrk/Rxd8i4AAAAAAAAA0EW6dy/V7t1VqqnZk+5QOpXNZlM8Hk8573C41L17aZfEQEIZAAAAAAAAQE6x2x3q1atvusPodKWlXlVVBdIaAy0vAAAAAAAAAACtQkIZAAAAAAAAANAqWd3ywmYz8up98wXzay3m11rMr7WYX2sxv9Zifq3V2vnN5p8Da9/cxPxai/m1FvNrLebXWsyvtZhfa6V77WuY+bDVIQAAAAAAAACgw2h5AQAAAAAAAABoFRLKAAAAAAAAAIBWIaEMAAAAAAAAAGgVEsoAAAAAAAAAgFYhoQwAAAAAAAAAaBUSygAAAAAAAACAViGhDAAAAAAAAABoFRLKAAAAAAAAAIBWIaEMAAAAAAAAAGgVEsp7sWLFCo0ePVojR47U4sWLU8bfeecdjR8/XqNGjdI111yjaDSahiiz1+9+9zuNGTNGY8aM0YIFC5odP+GEEzRu3DiNGzeu2Z8B9u7HP/6xxowZk5y/DRs2NBnn+9t+f/3rX5PzOm7cOB155JGaN29ek2v4/rZdTU2Nxo4dq88//1yStHbtWlVUVGjkyJFauHBhs/ds3bpV5513nk455RRdeumlCgaDXRlyVvnm/C5ZskRjx45VRUWF5syZo3A4nHLPsmXLNHz48OT3eG8/B6TO75w5czRy5Mjk3D3//PMp9/D9bb2vz+/LL7/c5O/goUOH6uKLL065h+9v27H2tRZrX2ux9rUOa1/rsP61Dmtfa7H2tVbWrH1NpNi2bZt5wgknmLt37zaDwaBZUVFhvv/++02uGTNmjPmf//zHNE3TnDNnjrl48eI0RJqdXnvtNfPss8826+vrzXA4bE6ePNlctWpVk2suvvhi83//93/TFGF2i8fj5vDhw81IJLLXa/j+do733nvPPPnkk82dO3c2Oc/3t23+7//+zxw7dqx56KGHmp999plZW1trHnfcceann35qRiIRc+rUqeZLL72Uct9PfvIT85lnnjFN0zR/97vfmQsWLOjq0LPCN+f3ww8/NE8++WQzEAiY8XjcvPLKK80HH3ww5b558+aZK1as6PqAs8w359c0TXPs2LFmZWXlt97H97d1mpvfhO3bt5snnnii+dFHH6Xcx/e3bVj7Wou1r7VY+3Yd1r6dh/WvdVj7Wou1r7Wyae1LhXIz1q5dq6FDh6qkpERut1ujRo3SypUrk+NffPGF6urqdNhhh0mSxo8f32Qc3660tFSzZ8+Wy+WS0+nUgQceqK1btza5ZtOmTbr33ntVUVGhefPmqb6+Pk3RZp8PP/xQkjR16lSddtppevTRR5uM8/3tPNddd51mzpypHj16NDnP97dtli5dqrlz56qsrEyS9NZbb2n//ffXfvvtJ4fDoYqKipTvaCQS0RtvvKFRo0ZJ4nv8bb45vy6XS3PnzlVxcbEMw9D3v//9lL+DJWnjxo1atmyZKioq9Mtf/lLV1dVdHXpW+Ob81tbWauvWrbr66qtVUVGhu+66S/F4vMk9fH9b75vz+3ULFizQpEmTdMABB6SM8f1tG9a+1mLtay3Wvl2HtW/nYf1rHda+1mLta61sWvuSUG7G9u3bVVpamjwuKytTZWXlXsdLS0ubjOPbHXTQQckF3ccff6x//OMfOu6445LjwWBQhxxyiGbNmqVly5bJ7/fr97//fZqizT5+v1/HHHOM7rnnHj300EN6/PHH9dprryXH+f52jrVr16qurk6nnnpqk/N8f9vupptu0pAhQ5LHLf0dLEm7d+9WcXGxHA6HJL7H3+ab89uvXz8NGzZMkrRr1y4tXrxYJ554Ysp9paWl+ulPf6qnn35affv2TXm8FQ2+Ob87duzQ0KFDdfPNN2vp0qVav369nnjiiSb38P1tvW/Ob8LHH3+sf//735o8eXKz9/H9bRvWvtZi7Wst1r5dg7Vv52L9ax3WvtZi7WutbFr7klBuRjwel2EYyWPTNJsctzSO1nn//fc1depUXXnllU3+hcXj8WjRokU68MAD5XA4NHXqVL388svpCzTLHH744VqwYIG8Xq969OihiRMnNpk/vr+d4/HHH9eFF16Ycp7vb8e15jva3Dm+x21TWVmpCy64QBMmTNDRRx+dMn7PPffoyCOPlGEYmjZtmtasWZOGKLPPfvvtp3vuuUdlZWUqKirSj3/845S/A/j+dtySJUt07rnnyuVyNTvO97dtWPt2Dda+1mDt2zVY+1qL9a/1WPtag7Vv18jEtS8J5Wb06dNHVVVVyeOqqqom5ebfHN+xY0ez5ejYuzfffFNTpkzRFVdcoTPOOKPJ2NatW5v8i5Zpmsl/yULL1q9fr3Xr1iWPvzl/fH87LhwO64033tCPfvSjlDG+vx3X0t/BktSjRw8FAgHFYrG9XoO9++9//6tJkybpjDPO0M9+9rOU8UAgoIceeih5bJqm7HZ7F0aYvbZs2aLnnnsuedzc3wF8fztu9erVGj16dLNjfH/bjrWv9Vj7Woe1r/VY+1qP9a+1WPtah7Vv18jEtS8J5WaUl5dr3bp12rVrl2pra7Vq1SqNGDEiOd6vXz8VFBTozTfflCQ99dRTTcbx7b788kv97Gc/02233aYxY8akjBcWFuo3v/mNPvvsM5mmqcWLF+vkk09OQ6TZKRAIaMGCBaqvr1dNTY2WLVvWZP74/nbcli1bdMABB8jtdqeM8f3tuB/+8If66KOP9MknnygWi+mZZ55J+Y46nU4NGTJEzz77rCRp+fLlfI9bqaamRhdddJF+8YtfaOrUqc1e43a7df/992vDhg2SpEcffZTvcSuZpqmbb75Z1dXVikQiWrJkScrc8f3tmF27dqmurk777bdfs+N8f9uOta+1WPtai7Wv9Vj7Wo/1r3VY+1qLta/1MnXtS0K5Gb1799bMmTM1efJknX766Ro7dqwGDx6s6dOna+PGjZKk2267TfPnz9cpp5yiUCi01z4mSPXAAw+ovr5et9xyi8aNG6dx48bpL3/5S3J+e/TooXnz5unSSy/VKaecItM0m328Cs074YQTdNxxx+n000/XhAkTNGHCBB1++OF8fzvRZ599pj59+jQ5x/e38xQUFOiWW27Rz3/+c40ePVrf+973dMopp0iSrrnmGq1evVqSNHfuXC1dulSjR4/W+vXrdfnll6cx6uzxxBNPaMeOHXrwwQeTfwffeeedkr6aX7vdrjvuuEPXXXedTj31VL399tuaNWtWmiPPDgMGDNBPfvITnXPOORozZowOOeQQjR07VhLf387y+eefp/wdLPH97QjWvtZi7Wst1r7WY+1rPda/1mHtay3WvtbL1LWvYZqmafm7AAAAAAAAAACyHhXKAAAAAAAAAIBWIaEMAAAAAAAAAGgVEsoAAAAAAAAAgFYhoQwAAAAAAAAAaBUSygAAAAAAAACAVnGkOwAAQKqDDz5Y3//+92WzNf13v3vuuUf77rtvp7/XunXr1KNHj059XQAAAKA1WPsCQHYhoQwAGerPf/4zC10AAADkBda+AJA9SCgDQJb517/+pdtuu0377LOPPvzwQxUWFuqWW27RgQceqEAgoOuvv17vvvuuDMPQscceq//5n/+Rw+HQhg0bdOONN6q2tlZOp1NXXnmljjnmGEnS3XffrQ0bNmjPnj266KKLdN5556X5UwIAAACsfQEgE5FQBoAMdcEFFzR57G/ffffVPffcI0natGmTrrrqKg0ZMkR/+ctfNGvWLD355JO68cYbVVJSohUrVigSiejSSy/Vn/70J1144YX62c9+phtvvFHHH3+8Nm3apDlz5uipp56SJO23336aO3euNm/erLPPPltnnXWWnE5nWj43AAAA8g9rXwDIHiSUASBDfdtjfwMGDNCQIUMkSRMmTNC8efO0e/duvfLKK/rLX/4iwzDkcrk0adIk/fnPf9awYcNks9l0/PHHS5IGDhyoFStWJF9v7NixkqRDDjlE4XBYNTU16t69u7UfEAAAAGjE2hcAsoet5UsAAJnGbrc3ey4ej8swjOS5eDyuaDQqu93e5Lwkvffee4pGo5Ikh6Ph3xcT15imaVXoAAAAQJuw9gWAzEJCGQCy0Lvvvqt3331XkrRkyRIdfvjh8vl8Gj58uB599FGZpqlwOKylS5eqvLxc3/ve92QYhl577TVJ0ttvv60LLrhA8Xg8nR8DAAAAaBFrXwDILLS8AIAM9c0+cpL0P//zPyosLFSvXr10xx136IsvvlCPHj20YMECSdK1116rG2+8URUVFYpEIjr22GN1ySWXyOVy6e6779bNN9+sBQsWyOl06u6775bL5UrHRwMAAACaYO0LANnDMHm2AwCyyr/+9S/dcMMNeuaZZ9IdCgAAAGAp1r4AkHloeQEAAAAAAAAAaBUqlAEAAAAAAAAArUKFMgAAAAAAAACgVUgoAwAAAAAAAABahYQyAAAAAAAAAKBVSCgDAAAAAAAAAFqFhDIAAAAAAAAAoFVIKAMAAAAAAAAAWuX/A3Bju0IEWJjlAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance(loss=losses, accuracy=accuracies, log_file=f'{log_dir}/hopfield_lookup.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Adapt Hopfield-based Lookup

\n", + "

We can now again explore the functionality of our Hopfield-based lookup layer HopfieldLayer.

\n", + "\n", + "This lookup setting is especially pronounced, if the state patterns are initialized with a subset of the training set (and optionally provide the corresponding training targets as pattern projection inputs).\n", + "\n", + "Again, additional arguments are set to increase the training as well as the validation performance of the Hopfield-based lookup.\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ArgumentValue (used in this demo)Description
lookup_weights_as_separatedTrueSeparate lookup weights from lookup target weights (e.g. to set lookup target weights separately).
lookup_targets_as_trainableFalseEmploy trainable lookup target weights (used as pattern projection input).
" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "set_seed()\n", + "hopfield_lookup = HopfieldLayer(\n", + " input_size=latch_sequence_set.num_characters,\n", + " quantity=len(latch_samples_unique),\n", + " lookup_weights_as_separated=True,\n", + " lookup_targets_as_trainable=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Initialize the trainable but fixed stored patterns with all unique samples from the training set. In this way, the Hopfield-based lookup already starts with meaningful stored patterns (instead of random noise). This may enhance the performance of the network, especially at the beginning of the training." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "with torch.no_grad():\n", + " hopfield_lookup.lookup_weights[:] = latch_samples_unique.unsqueeze(dim=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "output_projection = Linear(in_features=hopfield_lookup.output_size * latch_sequence_set.num_instances, out_features=1)\n", + "network = Sequential(hopfield_lookup, Flatten(start_dim=1), output_projection, Flatten(start_dim=0)).to(device=device)\n", + "optimiser = AdamW(params=network.parameters(), lr=1e-3)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "losses, accuracies = operate(\n", + " network=network,\n", + " optimiser=optimiser,\n", + " data_loader_train=data_loader_train,\n", + " data_loader_eval=data_loader_eval,\n", + " num_epochs=18)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABZQAAAHsCAYAAABFbSiOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAB0+UlEQVR4nO3deXxU9fX/8fedLclMZhKWBBCpVlFwAZdSQUTUqqBARAEV0SIiuLSWys9isdqCuFMtVqtWsdWqaEUFFGsRl7pUUMFvq4DiUjcUDYFAZjKTZLb7+yOZ0Zhg1pvZXs/Hw4eZuffOnDmZB48Ph3PPxzBN0xQAAAAAAAAAAC2wpToAAAAAAAAAAEBmoKAMAAAAAAAAAGgVCsoAAAAAAAAAgFahoAwAAAAAAAAAaBUKygAAAAAAAACAVqGgDAAAAAAAAABoFQrKAAAAAAAAAIBWcaQ6gI7YuTOoeNzs0vfs0aNQO3ZUd+l75hLyay3yay3yay3yay3yay3ya6225NdmM9Stm8fiiKzB2jf7kF9rkV9rkV9rkV9rkV9rkV9rpcPaN6MLyvG42eWL6sT7wjrk11rk11rk11rk11rk11rk11q5kF/WvtmJ/FqL/FqL/FqL/FqL/FqL/For1fll5AUAAAAAAAAAoFUoKAMAAAAAAAAAWiWjR14AAACgdUzTVHV1lWpqqhWPx1IdTqfats2meDze6Dmbza6CgkIVFhbJMIwURQYAAABkHwrKAAAAOWDnzgoZhqHu3XvJbndkVZHV4bApGv2moGyapmKxqAKBXdq5s0Ldu5emMDoAAAAguzDyAgAAIAeEw7UqLu4hh8OZVcXk5hiGIYfDqeLiHgqHa1MdDgAAAJBVKCgDAADkBFOGkVtLv/rPyw7jAAAAQGfKrb9VAAAAAAAAAADajYIyAAAAulx1dbWuuOJXrT5/8+Z3deON11gYEQAAAIDWYFM+AAAAdLlAwK8PP3y/1ecPHHig5s490MKIAAAAALQGBWUAAAB0uVtv/b22b6/QFVf8Sp999omKioqVl5en665bqBtuuEYVFdu0fXuFhgw5QnPn/lb/+c9b+utf79Gf/nSPLrnkAh144EF6++3/ateunbrssl/riCOOTPVHAgAAAHICBWUAAIAc9NqGr/Tvd76y5LVHDO6jowb1+d5zLr10jn7xiws1a9b/0+mnn6LHHrtdffrsoeeeW6X99ttf1157kyKRiM4553S9//7mJtdHIlHdffd9+ve/X9Hdd99BQRkAAADoIhSUAQAAkFLdunVXnz57SJJOPPEkvfvuRi1d+rA+/fQTVVVVqaYm1OSaoUPrC8j77LOv/H5/l8YLAAAA5DIKygAAADnoqEEtdxF3lby8vOTPjz/+d7300os65ZTTNGnSEfrkk//JNM0m17hcLkmSYRjNHgcAAABgDVuqAwAAAEDusdvtisViTZ5ft+4NnXLKBI0adbLC4bA+/PADxePxFES4e9XV1Ro3bpy++OKLJsfee+89TZgwQaNHj9aVV16paDQqSdq6davOPvtsnXTSSbr44osVDAa7OmwAAACgU1BQBgAAQJfr3r2HevXqreuvv7rR82ecMUX33XePpk49U3/84y06+ODB+uqrrSmKsqm3335bZ511lj799NNmj8+ZM0e/+93v9Oyzz8o0TS1dulSSdPXVV2vKlClatWqVDj74YN15551dGDUAAADQeRh5AQAAgC7ncDj05z//tcnzP/rRj/XII8uavebww4dIkv70p3uSz/Xps4dWrPiHotGu6WJeunSp5s2bp8svv7zJsS+//FK1tbU69NBDJUkTJkzQbbfdptNPP13r1q3THXfckXz+nHPO0Zw5c7okZgAAAKAzUVBug5f/+6XsTodGHNQr1aEAAAAgBa677rrdHtu2bZtKSkqSj0tKSlReXq6dO3eqsLBQDoej0fOZYOuDv1MkEm3yvLvsCklS7Zoliu/4vMnxvCOnyN5zL0Xef1WRD/7d5Lhz/xFyDjhase2fqW7tw02O23r8QPnDz5YkhVbeoLpIXF/tCOrb47IftY+XJB0X/7dKzR1NXuNftqO0zeipg+KbdbD5fpPjG40B2mQbqFJzu46Lv9bk+Dajh/5lGyFJOjP2ZJPjnRHDe44D9I65f0pjSIc8WBWDYSj5ncnlPFgVw+T4k2puhH2u5YE/HzIzBv584M+HVMSwuvhM/XLSYNlsRrOxZRIKym2w8eNKbauqpaAMAACAJuLxuAzjm78gmKaZ3DTw289LavK4NXr0KOxwjG21VZLT2fSvDCUlXknS9gKXws0c79bNo7wSrwJb8xVo5rjXmy9viVd1MY92NHPcVeBSz4b32Op0KFBTq9pwTF63S4m/g/Ur8dW/1i6X8iP2Jq/Rq8ijPJdPPYIFyg81Pd7DXaB+Hp+KwzXKr2p63Ot0qV9x/XvkVzQ93hkxFLvzUh5DOuSBGDIzhrw0iCEd8sCfD8RADE1j4M+H5mPYu2+RSkq8nVJQTqzFUsUwM3hb7B07qhWPd134Dzz7vv7vgwrd+osRXfaeuaakxKuKikCqw8ha5Nda5Nda5Nda5Nda6ZDfr7/+TL1775XSGKzicNh2O/Liu5/bZjM6pTD7k5/8RA888ID23HPP5HNffvmlpk2bpueee06StH79et122236y1/+oqFDh2rdunWy2+366quvdM455+iFF15o03t29dpXSo/vriQ99donWvHqJ7pnzrFy2LNnG5h0yW+2Ir/WIr/WIr/WIr/WIr/Wakt+O2vt2+R1O/0Vs5jP7VQgFFYszXYaBwAAQOr17dtXeXl5euuttyRJTz75pEaOHCmn06khQ4bomWeekSStWLFCI0eOTGWoGScQjMiT78iqYjIAAECmYkXWBj6PS6YpVYciqQ4FAAAAaWLmzJnasGGDJOnmm2/WDTfcoJNOOkmhUEhTp06VJM2bN09Lly7VmDFjtH79el166aUpjDjzVIXC8rpdqQ4DAAAAYoZym/gaFrFVwbCKCvNSHA0AAABS5cUXX0z+vHjx4uTPAwcO1OOPP97k/L59++rBBx/sktiyUSAYls/tTHUYAAAAEB3KbeLz1BeUA3QoAwAAAF3GHwon1+IAAABILQrKbeBt6Irwh8IpjgQAAAB/+cvd+stf7k51GOgC/mBYXgrKAAAAaYGCchsUNSxi/UEKygAAAEBXiMbiCtZGk+PnAAAAkFrMUG6DgjyHHHaDDmUAAJAVQitvaPZ5d9kVkqTaNUsU3/F5k+N5R06Rvedeirz/qiIf/Hu317fkwQfv17/+9ZxisbiGDh2maDSqkpJeOuuscyRJV145R6NGjVG/fv20aNHvVVNTo507K/XTn07TqadOau3HRIarrqkfN8fICwAAgPRAh3IbGIahosI8OpQBAAA66PXX1+j999/T4sUP6L77lqiiokI+X5Gef/5ZSVIoFNTGjRs0fPgIrVz5pM4993zde+8Duu22P+uOO25LcfToSom1N5vyAQAApAc6lNuo2JvHpnwAACArtNRJnD/87O897hxwtJwDjm7Xe69f/6befXejzj//p5Kkurpa9erVW+Fwnb74Yos2bHhbRx11tJxOpy655FK98cZaPfjgffrf/z5STU2oXe+JzJS4O9DLyAsAAIC0QEG5jYoK81S5qybVYQAAAGS0eDymM844S5Mn14+3CAQCstvt8ngK9cILq7Vx4zs655xpkqTf/W6uvF6fjjrqaB1//KhkFzNyQyBY38xRxMgLAACAtMDIizYqLsxjhjIAAEAHHX74j/Xss88oFAopGo3qiisu00svvaBRo07Siy8+py++2KLBgw+VJK1b96ZmzLhIRx99rF5/fY0kKRaLpTB6dCU6lAEAANILHcptVFyYJ38wItM0ZRhGqsMBAADISCNGjNRHH32gCy6Ypng8pqFDh+vkk8fV71lRVKyDDhqUXGtNnz5TF188Q3l5Lu27737q02cPffXV1hR/AnQVfzAsh91QQZ491aEAAABAFJTbrKgwT9FYXDV1MbnzSR8AAEB7TZs2Q9OmzWjy/G23/bnR48mTz0mOxvi288+/0LLYkD78obC8bhfNHAAAAGmCkRdtVOzNkyQFGHsBAAAAWC4QisjH/GQAAIC0QUG5jYoL6wvKzFEGAAAArOcPhuVjfjIAAEDaoKDcRokOZX+QgjIAAMgspmmmOoQulWufN1v5Q2H53M5UhwEAAIAGFJTbqKiwvjvCH4qkOBIAAIDWs9sdikRy6x/EI5Gw7Hb2vMhkpmnKH2TkBQAAQDqhoNxGRYV0KAMAgMxTWFisXbsqFA7XZX3nrmmaCofrtGtXhQoLi1MdDjqgNhxTNBaXl5EXAAAAaYOWjTZy2G3y5DuYoQwAADJKQYFHklRVtV2xWDTF0XQum82meDze6Dm73SGvt1vycyMzJZo4fB5GXgAAAKQLCsrt4PO4FKBDGQAAZJiCAk9WFlhLSryqqAikOgxYINHEwaZ8AAAA6YORF+3gc7sYeQEAAABYzB+s37eEGcoAAADpg4JyO3g9LjblAwAAACwWaOhQZoYyAABA+qCg3A4+t5MOZQAAAMBiiTW3180MZQAAgHRBQbkdfB6XQnVRRWPxlk8GAAAA0C7+UFiefIccdv7aAgAAkC5YmbVDYlOQAGMvAAAAAMv4QxHmJwMAAKQZCsrtkFjUMvYCAAAAsI4/GGZ+MgAAQJqhoNwOiQ5lf4iCMgAAAGCVQCgsH/OTAQAA0goF5XbweuoXtXQoAwAAANbxB8OMvAAAAEgzFJTbgQ5lAAAAwFrRWFzB2mhy7Q0AAID0QEG5HfJddjkdNgWCbMoHAAAAWCGxAbaXDmUAAIC0QkG5HQzDkM/tUhUjLwAAAABLBBruBqRDGQAAIL1QUG4nn8eZXOQCAAAA6FyJ8XI+D5vyAQAApBMKyu3kdbvYlA8AAACwSGKtTYcyAABAeqGg3E4+j4tN+QAAAACL+Bv2K/FSUAYAAEgrFJTbyed2KRCKyDTNVIcCAAAAZJ1AKCyH3aaCPHuqQwEAAMC3UFBuJ5/HpVjcVLA2mupQAAAAgKzjD4Xl8zhlGEaqQwEAAMC3WFpQXrlypcaMGaNRo0ZpyZIlTY7/6U9/0nHHHafx48dr/PjxzZ6Trnzu+s1B2JgPAAAA6Hz+YIRxFwAAAGnIYdULl5eXa9GiRVq2bJlcLpcmT56soUOHqn///slzNm7cqD/84Q867LDDrArDMl5P/eLWHwyrTw9PiqMBAAAAsos/FFaRh4IyAABAurGsQ3nNmjUaNmyYiouL5Xa7NXr0aK1atarRORs3btTdd9+tsrIyLViwQHV1dVaF0+mKGrol/KFIiiMBAAAAsk8gFJa34a5AAAAApA/LCsrbtm1TSUlJ8nFpaanKy8uTj4PBoA444ADNmTNHy5cvl9/v15133mlVOJ3u2x3KAAAAADqPaZryB8PyMfICAAAg7Vg28iIejzfaQMM0zUaPPR6PFi9enHw8ffp0/eY3v9Hs2bNb/R49ehR2TrBtVFLiVfcepgxDijY8Ruchn9Yiv9Yiv9Yiv9Yiv9Yiv9Yiv9mlpi6maMxkhjIAAEAasqyg3Lt3b61fvz75uKKiQqWlpcnHW7du1Zo1azRp0iRJ9QVnh6Nt4ezYUa143OycgFuppMSrioqAJKmwwKnyiurkY3Tct/OLzkd+rUV+rUV+rUV+rUV+rdWW/NpsRsqaEtB6iY2vmaEMAACQfiwbeTF8+HCtXbtWlZWVqqmp0erVqzVy5Mjk8fz8fP3+97/Xli1bZJqmlixZohNPPNGqcCzhc7tUxcgLAAAAoFMl1theDzOUAQAA0o1lBeVevXpp9uzZmjp1qk499VSNGzdOgwcP1syZM7VhwwZ1795dCxYs0MUXX6yTTjpJpmnqvPPOsyocS/g8LgXYlA8AAADoVIkOZWYoAwAApB/LRl5IUllZmcrKyho99+25yaNHj9bo0aOtDMFSXrdTn37N7asAAABAZ/I3NG34GHkBAACQdizrUM4FPo9LfkZeAAAAAJ0q0LDGLixg5AUAAEC6oaDcAT63S7XhmMKRWKpDAQAAALJGVSgsT75DDjt/XQEAAEg3rNA6IHELnj9ElzIAAADQWQLBMOMuAAAA0hQF5Q5IbBLCxnwAAABA5/GHImzIBwAAkKYoKHeA11M/062KOcoAAABAp/EHw/LSoQwAAJCWKCh3QFGiQ5mCMgAAANBpAqGwfG425AMAAEhHFJQ7wOtmhjIAAADQmaKxuIK1UWYoAwAApCkKyh2Q57Irz2mXP8gMZQAAAKAzJPYnYYYyAABAeqKg3EE+j1MBOpQBAACATuFvGCfnpaAMAACQligod5DP7WJTPgAAAKCTJJo1fB5mKAMAAKQjCsod5PO46FAGAAAAOok/WVCmQxkAACAdUVDuIK/bJX+IGcoAAABAZ0jsT8IMZQAAgPREQbmDEh3K8biZ6lAAAACAjOcPheWw25Tvsqc6FAAAADSDgnIH+dxOmaZUXUuXMgAAANBRgWBYRR6nDMNIdSgAAABoBgXlDkrMdvOzMR8AAADQYf5QRF7GXQAAAKQtCsodlJjtFqCgDAAAkBNWrlypMWPGaNSoUVqyZEmT4y+//LLKyspUVlamyy67TMFgUJK0fPlyjRgxQuPHj9f48eO1aNGirg49I/iDYTbkAwAASGOOVAeQ6byJDmU25gMAAMh65eXlWrRokZYtWyaXy6XJkydr6NCh6t+/vyTJ7/dr7ty5evDBB9W/f38tXrxYixYt0lVXXaWNGzdq7ty5GjduXIo/RXrzh8Las9ST6jAAAACwG3Qod1ARIy8AAAByxpo1azRs2DAVFxfL7XZr9OjRWrVqVfL4p59+qj322CNZYD7uuOP0/PPPS5I2bNig5cuXq6ysTL/61a9UVVWVks+QzkzTVCBEhzIAAEA6o6DcQe58h2yGIX+IgjIAAEC227Ztm0pKSpKPS0tLVV5enny899576+uvv9bmzZslSf/85z+1fft2SVJJSYl+9rOf6amnnlKfPn20YMGCrg0+A9TURRWNmcmxcgAAAEg/jLzoIJthyOt20qEMAACQA+LxuAzDSD42TbPRY5/Pp5tuukm//e1vFY/HdcYZZ8jpdEqS7rjjjuR5M2bM0Iknntim9+7Ro7CD0bdPSYm3y97ry4pqSVLf3r4ufd9UypXPmSrk11rk11rk11rk11rk11qpzi8F5U7g87gUYIYyAABA1uvdu7fWr1+ffFxRUaHS0tLk41gspt69e+uxxx6TJL3zzjvq16+fAoGAnnjiCU2bNk1SfSHabre36b137KhWPG52/EO0QUmJVxUVgS57v0+37JIkGbF4l75vqnR1fnMN+bUW+bUW+bUW+bUW+bVWW/JrsxmWNCUw8qIT+NxORl4AAADkgOHDh2vt2rWqrKxUTU2NVq9erZEjRyaPG4ah6dOnq7y8XKZp6v7779eYMWPkdrt177336u2335YkPfTQQ23uUM4FgYY1tdftTHEkAAAA2B06lDuBz+NS+U42VQEAAMh2vXr10uzZszV16lRFIhFNmjRJgwcP1syZMzVr1iwNGjRICxYs0IwZMxQOh3XkkUfq/PPPl91u16233qr58+ertrZWe++9txYuXJjqj5N2EmPk2JQPAAAgfVFQ7gRet4sOZQAAgBxRVlamsrKyRs8tXrw4+fOxxx6rY489tsl1Q4YM0fLly60OL6P5G8bIFRbQoQwAAJCuGHnRCXwel8KRuGrD0VSHAgAAAGQsfyiswgKnHHb+mgIAAJCuWKl1Ap+7/pY8PxvzAQAAAO3mD4aZnwwAAJDmKCh3Ap+nftEbCDL2AgAAAGivQDCcbNYAAABAeqKg3AkSm4b4KSgDAAAA7eYPRdiQDwAAIM1RUO4E34y8oKAMAAAAtFcgRIcyAABAuqOg3AkSc97oUAYAAADaJxqLK1gbldfDDGUAAIB0RkG5EzgddhXkOdiUDwAAAGinQMNamg5lAACA9EZBuZP43E4FGHkBAAAAtEvibj9mKAMAAKQ3CsqdxOdxMfICAAAAaKfEfiR0KAMAAKQ3CsqdxOd2MfICAAAAaKdEcwYzlAEAANIbBeVO4qVDGQAAAGg3ZigDAABkBgrKncTndqq6JqJYPJ7qUAAAAICM4w+F5XTYlO+ypzoUAAAAfA8Kyp0ksXlINWMvAAAAgDbzB8PyuZ0yDCPVoQAAAOB7UFDuJIlb86oYewEAAAC0mT8UlpdxFwAAAGmPgnInSXQoB+hQBgAAANosEIwk19QAAABIXxSUO4nXXb8bNRvzAQAAAG3nD4XZkA8AACADUFDuJEUN3RT+EAVlAAAAoC1M05Q/GJbX40x1KAAAAGgBBeVOUpDnkMNuUFAGAAAA2qimLqpY3FQRHcoAAABpj4JyJzEMQ163i5EXAAAAQBv5G/Yh8TJDGQAAIO1RUO5EPreLTfkAAACANko0ZTBDGQAAIP1RUO5EXo9TVXQoAwAAAG2SKCgnNroGAABA+qKg3ImK3C4FmKEMAAAAtEliDV3EyAsAAIC0R0G5E3k9LvmDEZmmmepQAAAAgIyRuMuvkA5lAACAtEdBuRP53C5FY3HV1MVSHQoAAACQMQKhiAoLnLLb+OsJAABAumPF1ol8nvqOCsZeAAAAAK3nD4XlY9wFAABARqCg3IkSu1KzMR8AAADQeoFgWD7GXQAAAGQECsqdKNFVQYcyAAAA0HpVoYi8bjqUAQAAMgEF5U6UWAT7Q5EURwIAAABkjvoOZQrKAAAAmYCCcifyNtym52fkBQAAANAq0Vhcobpocj8SAAAApDcKyp3IYbfJk++Qn5EXAAAAQKskmjG8bMoHAACQESgodzKfx0WHMgAAANBKgYZxcYy8AAAAyAwUlDuZz+1SgIIyAAAA0CqJu/t8dCgDAABkBArKnczrcbEpHwAAANBKibv7fG5mKAMAAGQCCsqdrMjNyAsAAACgtRIdyl5GXgAAAGQECsqdzOtxKlQXVTQWT3UoAAAAQNoLBCNyOmzKd9lTHQoAAABagYJyJ0tsJkKXMgAAANAyfygsn9slwzBSHQoAAABagYJyJ0tsJhJgjjIAAADQIn8wLJ+H+ckAAACZgoJyJ0t2KIfoUAYAAABa4g+FmZ8MAACQQSgod7JEdwUjLwAAAICWBUKR5F1+AAAASH8UlDuZlw5lAAAAoFVM06wfeUGHMgAAQMawtKC8cuVKjRkzRqNGjdKSJUt2e95LL72kn/zkJ1aG0mXyXXY5HTY6lAEAAIAWhOqiisVN+dzMUAYAAMgUDqteuLy8XIsWLdKyZcvkcrk0efJkDR06VP3792903vbt23XTTTdZFUaXMwxDPrdL/iCb8gEAAADfJ9GE4WXkBQAAQMawrEN5zZo1GjZsmIqLi+V2uzV69GitWrWqyXlXXXWVLrnkEqvCSAmfx6kAIy8AAACA7xUI1TdhMEMZAAAgc1jWobxt2zaVlJQkH5eWluqdd95pdM4DDzygAw88UIcccki73qNHj8IOxdheJSXe7z3es5tbO3bVtngemkferEV+rUV+rUV+rUV+rUV+rUV+M1OiQ5kZygAAAJnDsoJyPB6XYRjJx6ZpNnr8wQcfaPXq1br//vv19ddft+s9duyoVjxudjjWtigp8aqiIvC95+Q5bKr017R4HppqTX7RfuTXWuTXWuTXWuTXWuTXWm3Jr81mpKwpAU0lNrJmhjIAAEDmsGzkRe/evVVRUZF8XFFRodLS0uTjVatWqaKiQhMnTtQFF1ygbdu2acqUKVaF06WKPC4FQhHFza4tdgMAAACZxB8My5BUSEEZAAAgY1hWUB4+fLjWrl2ryspK1dTUaPXq1Ro5cmTy+KxZs/Tss8/qySef1D333KPS0lI9/PDDVoXTpbxul2JxU6HaaKpDAQAAANKWPxSRp8Apu82yv5YAAACgk1m2cuvVq5dmz56tqVOn6tRTT9W4ceM0ePBgzZw5Uxs2bLDqbdNC4pa9xEw4AAAAAE0FgmE25AMAAMgwls1QlqSysjKVlZU1em7x4sVNzttzzz314osvWhlKl0osigOhsCRPaoMBAAAA0pQ/FGZ+MgAAQIbh3jILJHap9ociKY4EAAAASF/+UIQOZQAAgAxDQdkCiUUxIy8AAACA3fMHw/K6KSgDAABkEgrKFigscMoQBWUAAABgdyLRuGrqooy8AAAAyDAUlC1gsxkqdDvlD1FQBgAAAJoTaFgrM/ICAAAgs1BQtojP46JDGQAAANiNRPOFj5EXAAAAGYWCskV8bpcCbMoHAAAANMsfrF8re+lQBgAAyCgUlC1ChzIAAACwe8mRF8xQBgAAyCgUlC3iZYYyAAAAsFt+ZigDAABkJArKFvG5XaoNxxSOxFIdCgAAADrRypUrNWbMGI0aNUpLlixpcvzll19WWVmZysrKdNlllykYDEqStm7dqrPPPlsnnXSSLr744uTzucofDMvlsCnPaU91KAAAAGgDCsoWSXRa0KUMAACQPcrLy7Vo0SI9/PDDWrFihR599FF99NFHyeN+v19z587VokWLtHLlSg0cOFCLFi2SJF199dWaMmWKVq1apYMPPlh33nlnqj5GWvAHI/K6XTIMI9WhAAAAoA0oKFsksVs1G/MBAABkjzVr1mjYsGEqLi6W2+3W6NGjtWrVquTxTz/9VHvssYf69+8vSTruuOP0/PPPKxKJaN26dRo9erQkacKECY2uy0WBUJhxFwAAABmIgrJFEovjKjbmAwAAyBrbtm1TSUlJ8nFpaanKy8uTj/fee299/fXX2rx5syTpn//8p7Zv366dO3eqsLBQDodDklRSUtLoulzkD4bZkA8AACADOVIdQLZKLI4DFJQBAACyRjwebzSiwTTNRo99Pp9uuukm/fa3v1U8HtcZZ5whp9PZ5DxJbR710KNHYceCb6eSEq8lr1tdG9WAvbtb9vqZItc/v9XIr7XIr7XIr7XIr7XIr7VSnV8KyhbxMkMZAAAg6/Tu3Vvr169PPq6oqFBpaWnycSwWU+/evfXYY49Jkt555x3169dP3bt3VyAQUCwWk91ub3Jda+zYUa143OycD9JKJSVeVVQEOv11TdNUVXWdnDbDktfPFFblF/XIr7XIr7XIr7XIr7XIr7Xakl+bzbCkKYGRFxbJc9qV57LLH2SGMgAAQLYYPny41q5dq8rKStXU1Gj16tUaOXJk8rhhGJo+fbrKy8tlmqbuv/9+jRkzRk6nU0OGDNEzzzwjSVqxYkWj63JNqC6qWNxkhjIAAEAGoqBsIZ/bqQAdygAAAFmjV69emj17tqZOnapTTz1V48aN0+DBgzVz5kxt2LBBNptNCxYs0IwZM3TSSSfJ5/Pp/PPPlyTNmzdPS5cu1ZgxY7R+/Xpdeumlqf0wKeRvGAvHDGUAAIDMw8gLC/k8LjblAwAAyDJlZWUqKytr9NzixYuTPx977LE69thjm1zXt29fPfjgg1aHlxESBWUvHcoAAAAZhw5lC/ncLjqUAQAAgO8IhOrHwhW5KSgDAABkGgrKFvK6XcnuCwAAAAD1quhQBgAAyFgUlC3k87gUqIl0+W7cAAAAQDoLhMIyJBUWMIEPAAAg01BQtpDP7ZRpStW1kVSHAgAAAKQNfygiT4FTdht/HQEAAMg0rOAs5Gu4hY+xFwAAAMA3AsGwihh3AQAAkJEoKFvI17DJSICCMgAAAJBUFQrL63amOgwAAAC0AwVlCyU2GakKUVAGAAAAEgLBcPJuPgAAAGQWCsoWStzGFwgyQxkAAABI8Iciybv5AAAAkFkoKFvIne+QzTDkp0MZAAAAkCRFojHV1EWTd/MBAAAgs1BQtpDNMOT1ONmUDwAAAGgQCNXfvedjhjIAAEBGoqBsMZ/blVw0AwAAALkucfceIy8AAAAyEwVli/ncTlXRoQwAAABIkvwN+4uwKR8AAEBmoqBsMZ/HpQAzlAEAAABJSo6DY4YyAABAZqKgbDGv28WmfAAAAECDQHLkBTOUAQAAMlGrCsrV1dWSpHfffVcrVqxQJMJM4NYq8rgUjsRVG46mOhQAAAAg5fyhsFxOm/JdjlSHAgAAgHZosaD8xz/+UfPmzdPWrVs1Y8YMLVu2TPPnz++C0LKDt2GzET8b8wEAAADyB8NsyAcAAJDBWiwov/zyy7r22mu1evVqjR07Vg888IA2b97cFbFlBZ+n/lY+PxvzAQAAAPKHIsmmCwAAAGSeVo28KCgo0Jo1azRs2DBJUjhMcbS1ErtXBygoAwAAAAoEw8xPBgAAyGAtFpS7deum+fPna+PGjRo+fLhuvvlmlZaWdkVsWcGXHHlBQRkAAADwh8LJpgsAAABknhYLyjfddJNKS0t19913q6CgQIZh6KabbuqK2LJCcoYyHcoAAADIcXHTVCAUoaAMAACQwVrcWrlnz56aOnWqCgsL9e6772rfffdVUVFRV8SWFZwOmwryHGzKBwAAgJwXqo0qFjeZoQwAAJDBWiwo//GPf9Tnn3+uyy67TDNmzFD//v21bt06XXfddV0RX1bwuZ10KAMAACDnBRrGwCU2rgYAAEDmaXHkxcsvv6xrr71Wq1ev1tixY/XAAw9o8+bNXRFb1vB5XMnFMwAAAJCrEk0WPjqUAQAAMlaLBWVJKigo0Jo1azRs2DBJUjhMcbQtfG4XIy8AAACQ8xJrYgrKAAAAmavFgnK3bt00f/58bdy4UcOHD9fNN9+s0tLSrogta/g8LkZeAAAAIOcl1sReNuUDAADIWC0WlG+66SaVlpbqnnvuUUFBgQzD0E033dQVsWUNr9up6pqIYvF4qkMBAAAAUiYQCsuQ5C1ghjIAAECmanFTvp49e2r8+PF688039d5772nSpEnq2bNnV8SWNXwNHRiBUETFhXkpjgYAAABIDX8wrEK3UzabkepQAAAA0E4tdii/+uqrmjhxop5//nm98MILmjRpkp5//vmuiC1rJGbEMfYCAAAAucwfijA/GQAAIMO12KH8xz/+UQ899JD69+8vSfrwww81Z84cnXDCCZYHly2+3aEMAAAA5Cp/KJxcGwMAACAztdihHIlEksVkSdpvv/0Ui8UsDSrbJBbNdCgDAAAgl/mDYXndzE8GAADIZC0WlPPz87Vhw4bk4w0bNqigoMDSoLKNr2HR7A9RUAYAAEDuCoTCjLwAAADIcC2OvJgzZ44uuugi7bXXXjIMQx9//LH++Mc/dkVsWaMgzyGH3aBDGQAAADkrEo2ppi4mLyMvAAAAMlqLBeUhQ4boH//4h95++23F43Edeuih6tatW1fEljUMw5DX7aJDGQAAADnLH6zfT6SIgjIAAEBGa3HkhSQVFxfrmGOO0XHHHadu3brprLPOsjqurONzu9iUDwAAADkr0VzBDGUAAIDM1qqC8ne9//77nR1H1vN5XKpi5AUAAAByVKChoMwMZQAAgMzWroIy2s7ndiYX0QAAAECuSYy88DHyAgAAIKNRUO4iPo9L/mBYpmmmOhQAAACgy/npUAYAAMgKu92U79prr232edM0FYkwC7itvG6XojFTNXUxufNb3AsRAAAAyCr+YFgup015LnuqQwEAAEAH7LayWVxcvNuLLrzwQitiyWo+T/3mI4FQmIIyAAAAck4gFKY7GQAAIAvstrJ5ySWXdGUcWS8xK64qGFav7u4URwMAAAB0LX8wzPxkAACALMAM5S6S6MZgYz4AAADkIn8oQocyAABAFqCg3EUS3Rj+IAVlAAAA5B5/KCyv25nqMAAAAHLezp07O3R9iwXlaDTaoTdAvcKC+sWzP8SGhgAAAMgtcdNUdSjCyAsAAIA0MHbsWF122WVav359u65vsaB83HHHadGiRfryyy/b9Qao57Db5Ml3yM/ICwAAAOSYUG1UsbjJyAsAAIA08OKLL2r48OFauHChysrKtGTJElVXV7f6+hYLykuXLpXdbtc555yjCy+8UC+99JJM0+xQ0LnK53Ex8gIAAAA5J7EG9noYeQEAAJBq+fn5mjhxopYuXaqrrrpKf/3rX3X00Ufr6quvbtU4jBYLyn369NGsWbP0wgsv6PTTT9c111yj448/Xvfee6/CYYqjbeFzuxSgoAwAAIAck9iYmg5lAACA9PDKK6/oF7/4hWbPnq0TTjhBf//739WnTx/97Gc/a/FaR2ve4H//+58ee+wxPf300zr00EM1YcIEvfrqq/rlL3+pu+66a7fXrVy5UnfddZei0ajOPfdcnX322Y2OP/fcc7rtttsUj8c1aNAgLViwQC5X9i4yfR6XPt/W+vZxAAAAIBtUNTRVMEMZAAAg9Y477jgVFxdrypQp+v3vf6/8/HxJ0oABA/Too4+2eH2LBeWzzjpLW7Zs0cSJE/X444+rd+/ekqRjjz1Ww4YN2+115eXlWrRokZYtWyaXy6XJkydr6NCh6t+/vyQpFAppwYIFWr58uXr27KnZs2dr+fLlOvPMM1v1wTMRHcoAAADIRYGGjanpUAYAAEi9W265RQMGDJDH41E4HNaOHTvUo0cPSdILL7zQ4vUtjryYMmWK/vWvf2n27NnJYrIk2Ww2/etf/9rtdWvWrNGwYcNUXFwst9ut0aNHa9WqVcnjbrdbL774onr27Kmamhrt2LFDPp+vxYAzmdfjVKguqmgsnupQAAAAgC7jD4ZlGFJhATOUAQAAUu3rr7/WaaedJkn68ssvNXbsWL344outvr7FgvLJJ5+spUuX6uKLL9Yll1yiJ554InnM4/Hs9rpt27appKQk+bi0tFTl5eWNznE6nXr55Zd17LHHaufOnRoxYkSrA89EiVv82JgPAAAAuSQQCstb4JTNZqQ6FAAAgJz35z//WQ888IAk6Yc//KGWL1+u22+/vdXXtzjy4rrrrtNHH32k8ePHyzRNPfHEE/r88881e/bs770uHo/LML5ZMJqm2ehxwjHHHKM33nhDf/jDHzR//nzdcsstrQ6+R4/CVp/bmUpKvO26bs/eRZIke56z3a+RC8iNtcivtcivtcivtcivtcivtchveqsKhuVlfjIAAEBaiMfjjSZR9OnTR/F46ycqtFhQfu211/SPf/xDTmf97WmnnHKKTjnllBYLyr1799b69euTjysqKlRaWpp8vGvXLm3cuDHZlVxWVtbia37Xjh3VisfNNl3TUSUlXlVUBNp3cSwmSfrsi10qyrN3YlTZo0P5RYvIr7XIr7XIr7XIr7XIr7Xakl+bzUhZU0IuC4QizE8GAABIE927d9ff//53TZo0SYZhJPe4a60WR150795dsYZCqCQZhtGqWcfDhw/X2rVrVVlZqZqaGq1evVojR45MHjdNU3PmzNHWrVslSatWrdLhhx/e6sAzkc9dX5QPhBh5AQAAgNzhD4XldTM/GQAAIB0sWLBAS5cu1eDBgzV48GAtXbpU8+bNa/X1LXYoDxw4UFOmTNGECRNkt9v1zDPPqFu3brrvvvskSeedd16z1/Xq1UuzZ8/W1KlTFYlENGnSJA0ePFgzZ87UrFmzNGjQIF1zzTW68MILZRiG+vfvr6uvvrrVgWcir5sZygAAAMg9/mA4uZ8IAAAAUmvvvffWsmXLVFVVJbvdrsLCtt3B12JBua6uTgMGDNCmTZskSXvuuack6YMPPmjxxcvKylRWVtboucWLFyd/PuGEE3TCCSe0KeBMlu+yy+WwyU+HMgAAAHJEOBJTbTjGyAsAAIA0UVlZqaeeekrBYFCmaSoej+uzzz5r9d52LRaUb7jhBknSl19+qWg0qr322qtjEecwwzDkdbvkD0ZSHQoAAADQJQKh+rUvHcoAAADp4dJLL1V+fr4++ugjDR8+XGvWrNGPfvSjVl/f4gzlzz77TGPHjtWpp56qCRMm6IQTTtD//ve/DgWdy3weFx3KAAAAyBmJtS8dygAAAOlh69atuueeezRy5Eidc845euSRR/Txxx+3+voWC8oLFizQjBkztG7dOr311lu6+OKLs37WsZV8bqcCzFAGAABAjkjsH+L1sCkfAABAOujZs6ek+lnKH3zwgXr16qVoNNrq61ssKO/YsUOnnXZa8vHEiRO1c+fOdoQKSfJ6XKqiQxkAACBjrVy5UmPGjNGoUaO0ZMmSJsc3bdqkiRMn6pRTTtGFF14ov98vSVq+fLlGjBih8ePHa/z48Vq0aFFXh54SdCgDAACklx49eujee+/VwQcfrCeeeEIvvviiamtrW319iwXlWCymXbt2JR9XVla2K1DUK/K4VB2KKG6aqQ4FAAAAbVReXq5Fixbp4Ycf1ooVK/Too4/qo48+anTOddddp1mzZumpp57SD3/4Q/3lL3+RJG3cuFFz587Vk08+qSeffFKzZ89OxUfocskZyhSUAQAA0sKCBQvkcrk0ZMgQHXzwwbrtttv0q1/9qtXXt7gp3znnnKMzzzxTJ598sgzD0DPPPKNzzz23Q0HnMq/bpVjcVKg2qsICbvsDAADIJGvWrNGwYcNUXFwsSRo9erRWrVqlSy65JHlOPB5XMBiUJNXU1KioqEiStGHDBn366ae6++67NWDAAP32t79NHstm/mBYeU678lz2VIcCAAAASTfddJMWLlwoSZozZ47mzJnTputbLChPmDBBe+21l1599VXF43HNmzdPw4cPb1+0kK9hdpw/GKagDAAAkGG2bdumkpKS5OPS0lK98847jc6ZO3eupk+fruuvv14FBQVaunSpJKmkpETTp0/X4Ycfrj/84Q9asGCBbrnllla/d48ehZ3zIdqopMTboevDMVPF3rwOv062Ii/WIr/WIr/WIr/WIr/WIr/W6mh+33vvPZmmKcMw2nV9iwXlSZMm6cknn9SwYcPa9QZoLHGrXyAUluRJbTAAAABok3g83mjh/d2FeG1tra688krdf//9Gjx4sO677z79+te/1j333KM77rgjed6MGTN04okntum9d+yoVjzetWPTSkq8qqgIdOg1KiqD8uQ7Ovw62agz8ovdI7/WIr/WIr/WIr/WIr/Wakt+bTaj2aaE0tJSjR07Vocccog8nm/qk1dddVXrXrelEwoKCvT111+36sXQskRBuSrIxnwAAACZpnfv3qqoqEg+rqioUGlpafLxBx98oLy8PA0ePFiSdOaZZ+rNN99UIBDQ/fffnzzPNE3Z7bkxAsIfijA/GQAAII0cdthhGjNmjPr27avi4uLkf63VYodyTU2Njj/+ePXu3Vtutzv5/MqVK9sVcK7zeRIdypEURwIAAIC2Gj58uG6//XZVVlaqoKBAq1ev1jXXXJM8vtdee+nrr7/Wxx9/rH322UcvvPCCBg0aJLfbrXvvvVeHHXaYDjnkED300ENt7lDOVP5gWD/sw22vAAAA6eLb+3+0R4sF5SuvvLJDb4DGCgucMoz6hTUAAAAyS69evTR79mxNnTpVkUhEkyZN0uDBgzVz5kzNmjVLgwYN0g033KBLL71UpmmqR48euv7662W323Xrrbdq/vz5qq2t1d57753cCCWbxU1TgVBEXjqUAQAA0kZZWVmzz7e2gbjFgvKKFSt0/fXXN3pu1qxZOuKII1r1BmjMZjPkLXDKH6KgDAAAkInKysqaLMIXL16c/PmYY47RMccc0+S6IUOGaPny5ZbHl05CtVHFTZORFwAAAGnkt7/9bfLnSCSif/zjH+rXr1+rr99tQXnevHkqLy/XW2+9pcrKyuTz0WhUW7ZsaWe4kCSvx0WHMgAAALJeYt+QxNg3AAAApN53G4WHDx+uyZMn6+KLL27V9bstKE+aNEkffvih3n//fY0ePTr5vN1u16GHHtq+aCGpfmM+OpQBAACQ7QKJgrLbmeJIAAAAsDs7d+7Utm3bWn3+bgvKgwYN0qBBgzR8+HD17t27U4JDPZ/HpU+2+lMdBgAAAGCpRBOFlw5lAACAtPHd8W1bt27VmWee2errW5yh/NVXX2nOnDmqqqqSaZrJ51s7pBlNed3MUAYAAED2C4Qikhh5AQAAkE6+PUPZMAx1795d++67b6uvb7Gg/Lvf/U4TJkzQgQceKMMw2hclGinyuFQbjikcicnltKc6HAAAAMASVcGwDEMqzGfkBQAAQLr4wQ9+oD//+c+aP3++Pv74Y918881asGCBevbs2arrWywoOxwOnXfeeR0OFN/wNuxy7Q+F1bOoIMXRAAAAANYIhMLyFjhls9GYAgAAkC7mzp2rn/zkJ5Kkvn376ogjjtAVV1yhxYsXt+p6W0sn7Lfffnr//fc7FiUa8SUKysFIiiMBAAAArOMPhpmfDAAAkGZ27typqVOnSpLy8vI0bdo0VVRUtPr6FjuUt2zZookTJ2qPPfZQXl5e8nlmKLdfYoYcc5QBAACQzfyhcLKZAgAAAOkhFoupvLxcvXr1kiRt37690d55LWmxoDx79uz2R4dm+dz1M+QCQQrKAAAAyF6BYEQ/3IMRbwAAAOlk2rRpOvXUU3X00UfLMAytWbNGl19+eauvb7GgfMQRR+idd97Ru+++qwkTJmjTpk067LDDOhR0rvPSoQwAAIAc4A+F5XWzIR8AAEA6mTRpkg4++GC9/vrrstvtmjFjhvbbb79WX9/iDOVly5bpiiuu0L333qtAIKCf/exnWrp0aYeCznV5TrvyXHZmKAMAACBrhSMx1YZjKmKGMgAAQFopLy/X3//+d02bNk1HHXWUFi1a1KYZyi0WlB988EE9+uijKiwsVI8ePbRs2TL97W9/61DQqB97QYcyAAAAslViretlhjIAAEBa+fWvf6199tlHktS3b18dccQR+s1vftPq61ssKNtsNhUWFiYf9+nTR3a7vR2h4tt8Hpf8zFAGAABAlgqE6u/GY1M+AACA9LJz505NnTpVkpSXl6dp06Z1bodycXGx3nvvPRmGIUl66qmnVFRU1M5wkeBzuxSgQxkAAABZKtE84fUwQxkAACCdxGIxlZeXJx9v375dpmm2+voWN+X7zW9+o1/+8pf6/PPPNWLECOXl5enOO+9sX7RI8nlc+t+XVakOAwAAALBEoqBcRIcyAABAWpk2bZpOPfVUHX300ZKktWvX6vLLL2/19S0WlPfdd189+eST+vTTTxWLxfTDH/5QTiddBh3ldbsUqIkoHjdlsxmpDgcAAADoVMxQBgAASE+TJk3SwQcfrNdff112u10/+MEP9MADD6isrKxV17c48kKS7Ha79t13X91yyy0UkztJkccl05SqayKpDgUAAADodIFQRHlOu/Jc7L8CAACQbvr06aNwOKx7771Xf/vb35Ldyq3RYofyt23btq3NwaF5Xnd9Yd4fCsvnoWsDAAAA2aV+nUszCgAAQDr5+OOP9be//U1PPfWU+vbtq9raWr344ovyer2tfo1WdSgntGU4M75fYrfrQJCN+QAAAJB9/MFwcs0LAACA1Lvgggt0zjnnyOl06oEHHtDTTz8tj8fTpmKy1MaC8qxZs9r04ti9RFdyVYiCMgAAALKPPxhhfjIAAEAaeffdd3XQQQdpv/3201577SVJMoy27+3WYkF5+/bteuGFFyRJb731ls4991xt3ry5zW+ExhIF5UCQGcoAAADIPgFGXgAAAKSVl156SaeddpqefvppjRgxQrNmzVJdXV2bX6fFgvLcuXO1ZcsWrV27Vq+++qrGjx+va6+9tl1B4xvufIfsNiO5+zUAAACQLeKmqUAowl4hAAAAacThcGjMmDF68MEHtWzZMpWWlqqurk6jRo3SI4880urXabGgvGvXLk2bNk2vvPKKxo0bpwkTJqimpqZDwUOyGYYK3U75maEMAACALBOsiShumoy8AAAASFP9+/fXVVddpVdeeUXnn3++li5d2uprWywoRyIRRSIRvfrqqxo+fLhqamoUCoU6FDDq+dwuBUKMvAAAAEB28TescdmUDwAAIL0VFBTozDPP1PLly1t9TYsF5eOPP15HHnmkunXrpoMPPlinn366xo0b16FAUc/ncamKDmUAAABkmUDDGpeRFwAAANnH0dIJs2bN0hlnnKFevXpJkm6++WYNHDjQ8sBygc/tVHkl3d4AAADILol9QnxuNuUDAADINi12KG/fvl2bNm2SYRj6/e9/rxtuuEGbN2/uitiyns/jkj8YlmmaqQ4FAAAA6DSJfUK8dCgDAABknRYLynPnztWWLVu0du1avfrqqxo/fryuvfbarogt6/ncLoWjcdVFYqkOBQAAAOg0/lBEhiEV5tOhDAAAkG1aLCjv2rVL06ZN0yuvvKJx48ZpwoQJqqmp6YrYsl5i12s/G/MBAAAgi/iDYXndLtlsRqpDAQAAQCdrsaAciUQUiUT06quvavjw4aqpqVEoxNzfzpDYpMTPxnwAAADIIoFQmPnJAAAAWarFgvLxxx+vI488Ut26ddPBBx+s008/XePGjeuK2LKez1O/yA5QUAYAAEAW8YfCybvxAAAAkF0cLZ0wa9YsnXHGGerdu7ck6eabb9bAgQMtDywX+BoW2VUhCsoAAADIHv5gWPvuUZTqMAAAAGCBFgvK8XhcK1eu1CuvvKJoNKqjjjpK/fv3l8PR4qVoQaJrgw5lAAAAZBN/KEKHMgAAQJZqceTFLbfcotdff13nnnuuzjvvPP3nP//RwoULuyK2rOd02FSQ52BTPgAAAGSNukhMdeFYcrwbAAAAskuLbcavvvqqnnjiCTmd9QvCY489Vqeccop+85vfWB5cLvB5XGzKBwAAgKwRaBjnRocyAABAdmqxQ9k0zWQxWZJcLlejx+gYn9uZXHQDAAAAmc4frL/7zuehoAwAAJCNWiwoDxw4UNdff70+//xzbdmyRTfccIP233//rogtJ/g8LlXRoQwAAIAs4W9olvDRoQwAAJCVWiwoz5s3T36/X5MnT9YZZ5yhyspK/fa3v+2K2HKCz+1SgBnKAAAAyBKJDad9bu5qBAAAyEYtzlC+++67deONN3ZFLDnJ63aquiaiWDwuu63F+j4AAACQ1hIdyl5GXgAAAGSlFiuYL730UheEkbuKGhbadCkDAAAgG/iDEeW57Mpz2lMdCgAAACzQYofynnvuqenTp+vwww+Xx+NJPn/eeedZGliuSOx+7Q+GVVyYl+JoAAAAgI4JhMKMuwAAAMhiLRaUi4uLJUlffvml1bHkpMTu14lbAwEAAIBM5g+F2ZAPAAAgi7VYUL7hhhuSP4fDYblcLA47U6KgHAgy8gIAAACZzx8Mq6S4INVhAAAAwCK7naEcDof161//Ws8991zyuV/84he64oorFI1GuyS4XJC4HZAOZQAAAGQDfyiSHOsGAACA7LPbgvJtt92m6upqHX744cnnFixYoKqqKt1+++1dElwuKMhzyGE35A9SUAYAAEBmi5tm/QxlDzOUAQAAstVuC8ovvfSSbrnlFvXo0SP5XK9evbRw4UI9//zzXRJcLjAMQ163iw5lAAAAZLzqmohMU8xQBgAAyGK7LSg7nU7l5+c3eb6wsJA5yp3M53HJzwxlAAAAZLhAw113iX1CAAAAkH12W1C22Wyqrq5u8nx1dTUzlDuZjw5lAAAAZAF/qL5JghnKAAAA2Wu3BeVx48bpqquuUigUSj4XCoV01VVXadSoUV0SXK7wuZ0KUFAGAABAhkusaelQBgAAyF67LSife+658nq9Ouqoo3TGGWdo0qRJOuqoo+Tz+fTzn/+8K2PMevUjL8IyTTPVoQAAAADtVpUYeeFmUz4AAIBs5djdAZvNpmuuuUYXXXSRNm3aJJvNpsGDB6u0tLQr48sJXrdL0ZipmrqY3Pm7/ZUAAAAAaS0QCsswJE8BBWUAAIBs1WL1sm/fvurbt29XxJKzihpuCfSHwhSUAQAAkLH8wYi8bpdshpHqUAAAAGCR3Y686AwrV67UmDFjNGrUKC1ZsqTJ8eeff17jx4/XKaecop/97GeqqqqyMpy05fXUd3D4g8xRBgAAQObyB8PysSEfAABAVrOsoFxeXq5Fixbp4Ycf1ooVK/Too4/qo48+Sh6vrq7W/Pnzdc899+ipp57SgAEDdPvtt1sVTlpLLLopKAMAACCTBUJh+TyMuwAAAMhmlhWU16xZo2HDhqm4uFhut1ujR4/WqlWrkscjkYjmzZunXr16SZIGDBigr776yqpw0lpiF+zErtgAAABAJvKH6FAGAADIdpYN7N22bZtKSkqSj0tLS/XOO+8kH3fr1k0nnniiJKm2tlb33HOPfvrTn7bpPXr0KOycYNuopMTbqa/XrbtHkhST0emvnYnIgbXIr7XIr7XIr7XIr7XIr7XIb3rwhyLJZgkAAABkJ8sKyvF4XMa3NuMwTbPR44RAIKCf//znGjhwoE477bQ2vceOHdWKx80Ox9oWJSVeVVQEOv11Cwuc+qqi2pLXziRW5Rf1yK+1yK+1yK+1yK+1yK+12pJfm81IWVNCtquLxFQXjsnrZuQFAABANrNs5EXv3r1VUVGRfFxRUaHS0tJG52zbtk1TpkzRgAEDdN1111kVSkbwup3yM/ICAAAg7bW08fSmTZs0ceJEnXLKKbrwwgvl9/slSVu3btXZZ5+tk046SRdffLGCwWBXh26pQMN+IIy8AAAAyG6WFZSHDx+utWvXqrKyUjU1NVq9erVGjhyZPB6LxXTRRRfp5JNP1pVXXtls93Iu8bldbMoHAACQ5lraeFqSrrvuOs2aNUtPPfWUfvjDH+ovf/mLJOnqq6/WlClTtGrVKh188MG68847U/ERLOMPRSRJXkZeAAAAZDXLCsq9evXS7NmzNXXqVJ166qkaN26cBg8erJkzZ2rDhg168cUX9e677+rZZ5/V+PHjNX78eF155ZVWhZP2fB5XchEOAACA9NTSxtNS/ei3RPdxTU2N8vPzFYlEtG7dOo0ePVqSNGHChCbXZbpEc0QRBWUAAICsZtkMZUkqKytTWVlZo+cWL14sSRo0aJA2b95s5dtnFJ/blbxNEAAAAOmppY2nJWnu3LmaPn26rr/+ehUUFGjp0qXauXOnCgsL5XDUL79LSkpUXl7epvdO9w2pzY8rJUl779lNJd3dVoaUVdhQ0lrk11rk11rk11rk11rk11qpzq+lBWW0ns/jVKguqkg0LqfDssZxAAAAdEBLG0/X1tbqyiuv1P3336/Bgwfrvvvu069//Wtdc801TUa8tXXkW7pvSL21vH5WdKQ2rIqKmJVhZQ027LQW+bUW+bUW+bUW+bUW+bVWOmxITeUyTSRmzQXYmA8AACBttbTx9AcffKC8vDwNHjxYknTmmWfqzTffVPfu3RUIBBSLxZq9Lhv4gxHlu+xyOe2pDgUAAAAWoqCcJhK7YfspKAMAAKStljae3muvvfT111/r448/liS98MILGjRokJxOp4YMGaJnnnlGkrRixYpG12UDfyicXNMCAAAgezHyIk34GjqU/UE25gMAAEhX3954OhKJaNKkScmNp2fNmqVBgwbphhtu0KWXXirTNNWjRw9df/31kqR58+Zp7ty5uuuuu9SnTx/94Q9/SPGn6Vz+YFhejzPVYQAAAMBiFJTThM9dv/hm5AUAAEB6+76NpyXpmGOO0THHHNPkur59++rBBx+0PL5UCYTCKikuSHUYAAAAsBgjL9LENx3KFJQBAACQefzBcHJNCwAAgOxFQTlN5DntcjlszFAGAABAxonHTQVqIvIyQxkAACDrUVBOE4ZhyOdx0aEMAACAjFNdG5FpfjPGDQAAANmLgnIa8bpd8ofYlA8AAACZJdDQFMHICwAAgOxHQTmN+NzO5GIcAAAAyBSJu+x8jLwAAADIehSU04jP41IVM5QBAACQYRJ32XnpUAYAAMh6FJTTiM/jUnUoorhppjoUAAAAoNUSG0szQxkAACD7UVBOIz63S7G4qVBtNNWhAAAAAK3mD4ZlMwx5CigoAwAAZDsKymnE66lfgPuZowwAAIAMEgiF5XU7ZTOMVIcCAAAAi1FQTiOJTUwCzFEGAABABvEHI/KyIR8AAEBOoKCcRnwNm5hU0aEMAACADBIIhVXkYdwFAABALqCgnEa+6VCOpDgSAAAAoPWqgmF5PXQoAwAA5AIKymmksMApw6BDGQAAAJklEIokmyMAAACQ3SgopxGbzZC3wMkMZQAAAGSMunBMdZGYvG5GXgAAAOQCCsppxutxyU+HMgAAADKEv6EZwsfICwAAgJxAQTnN+Nyu5KIcAAAASHfJgjIjLwAAAHICBeU04/O4FAiyKR8AAAAyQ2LtSocyAABAbqCgnGZ8bpeq6FAGAABAhqBDGQAAILdQUE4zPo8zubEJAAAAkO4S+3+wKR8AAEBuoKCcZrwNnR0BupQBAACQAfyhsPJddrmc9lSHAgAAgC5AQTnNJGbP+ZmjDAAAgAwQCEUYdwEAAJBDKCinmcRi3E+HMgAAADKAPxhmQz4AAIAcQkE5zfg89bPnErPoAAAAgHTmD4WZnwwAAJBDKCinGWYoAwAAIJME6FAGAADIKRSU00ye0648l50ZygAAAEh78bipQA0zlAEAAHIJBeU0VOR2MUMZAAAAaa+6JiLTFB3KAAAAOYSCchryepzMUAYAAEDaSzRBMEMZAAAgd1BQTkM+OpQBAACQAQINTRCMvAAAAMgdFJTTkM/jSi7OAQAAgHRV1dAEwcgLAACA3EFBOQ153S4FaiKKx81UhwIAAADsVqBhI2kKygAAALmDgnIaKvK4ZJr1m5wAAAAA6cofCstmGHLnO1IdCgAAALoIBeU0lNjUhDnKAAAASGf+YFhej1M2w0h1KAAAAOgiFJTTUFHDLYN+5igDAAAgjQVCETbkAwAAyDEUlNOQt2FRTocyAAAA0pk/FJav4e46AAAA5AYKymkosalJYpMTAAAAIB3Vj7ygQxkAACCXUFBOQ+58h+w2gw5lAAAApLX6DmUKygAAALmEgnIashmGCt1OZigDAAAgbdWFYwpH4sm76wAAAJAbKCinqSK3i4IyAAAA0lbibjovM5QBAAByCgXlNOX1uOQPMUMZAAAA6SnR/FBEhzIAAEBOoaCcpnxupwLMUAYAAECa+qZDmYIyAABALqGgnKZ8nvqRF6ZppjoUAAAAoIlAw910bMoHAACQWygopymf26VwNK66SCzVoQAAAABNJEZe+DzMUAYAAMglFJTTVGK3bDbmAwAAQDryB8MqyLPL6bCnOhQAAAB0IQrKaSoxi46N+QAAAJCO/KEw85MBAAByEAXlNJW4dTBAhzIAAADSUCAUYX4yAABADqKgnKYSi/OqEAVlAAAApB9/MJwc0wYAAIDcQUE5TSVuH6RDGQAAAOnIHwrL52ZDPgAAgFxDQTlNOR02ufMc8geZoQwAAID0Eo+bqg5FmKEMAACQgygopzGvxyU/Iy8AAACQZqprIjIlRl4AAADkIArKaczndipAQRkAAABpxt8wlo2CMgAAQO6hoJzGfB6XqpihDAAAgDSTuIuOGcoAAAC5h4JyGvO5XQqEmKEMAACA9JIoKDNDGQAAIPdQUE5jPo9L1TURRWPxVIcCAAAAJCU2jmbkBQAAQO6hoJzGErcQVtfQpQwAAID0EQiFZbcZcuc7Uh0KAAAAuhgF5TSW6PjwM0cZAAAAacQfDKvQ7ZTNMFIdCgAAALoYBeU0lphJl5hRBwAAAKSDQCgiH/OTAQAAchIF5TSW6FAOBBl5AQAAgPRRFQwzPxkAACBHMfQsjSW6PqoYeQEAAJA2Vq5cqbvuukvRaFTnnnuuzj777OSx9957T3Pnzk0+rqysVFFRkZ5++mktX75ct9xyi3r06CFJOvbYYzV79uwuj78zBEJh9e5ekOowAAAAkAKWFpS/b7H9bZdffrmGDRumCRMmWBlOxinIs8thNxRg5AUAAEBaKC8v16JFi7Rs2TK5XC5NnjxZQ4cOVf/+/SVJBxxwgJ588klJUk1NjU4//XTNnz9fkrRx40bNnTtX48aNS1X4ncYfCifHswEAACC3WDbyIrHYfvjhh7VixQo9+uij+uijj5qcc9FFF+nZZ5+1KoyMZhiGfB4Xm/IBAACkiTVr1mjYsGEqLi6W2+3W6NGjtWrVqmbPvfvuu/XjH/9YQ4YMkSRt2LBBy5cvV1lZmX71q1+pqqqqK0PvNLXhqMKRuIoYeQEAAJCTLOtQ/vZiW1JysX3JJZckz1m5cqWOP/745Dloyut2yR9ihjIAAEA62LZtm0pKSpKPS0tL9c477zQ5LxAIaOnSpVq5cmXyuZKSEk2fPl2HH364/vCHP2jBggW65ZZbWv3ePXoUdiz4diop8TZ6/PWOoCRpj16+JsfQduTQWuTXWuTXWuTXWuTXWuTXWqnOr2UF5dYstmfMmCFJeuutt6wKI+P53C75GXkBAACQFuLxuAzDSD42TbPR44SnnnpKJ5xwQnJesiTdcccdyZ9nzJihE088sU3vvWNHteJxsx1Rt19JiVcVFYFGz336ZX1ntRGPNTmGtmkuv+g85Nda5Nda5Nda5Nda5NdabcmvzWZY0pRgWUG5tYvtjkiXLg0rlfZw66sdwZT/y0NXyqXPmgrk11rk11rk11rk11rk11pdld/evXtr/fr1yccVFRUqLS1tct7zzz+vCy+8MPk4EAjoiSee0LRp0yTVr43tdrvl8Voh0ezADGUAAIDcZFlBubWL7Y5Ily4NK7lshnZV12nbNn+nF+TTEf+KZS3yay3yay3yay3yay3ya62u7NIYPny4br/9dlVWVqqgoECrV6/WNddc0+gc0zS1adMmHXbYYcnn3G637r33Xh122GE65JBD9NBDD7W5QzldJPb3YIYyAABAbrJsU77hw4dr7dq1qqysVE1NjVavXq2RI0da9XZZy+dxKRozVVMXTXUoAAAAOa9Xr16aPXu2pk6dqlNPPVXjxo3T4MGDNXPmTG3YsEGSVFlZKafTqby8vOR1drtdt956q+bPn6+TTz5ZmzZt0pw5c1L1MToksb+H1+1McSQAAABIBcs6lL+92I5EIpo0aVJysT1r1iwNGjTIqrfOKr6GWwn9oYjc+SzaAQAAUq2srExlZWWNnlu8eHHy5x49eui1115rct2QIUO0fPlyy+OzWiAYVkGeXU5HZo7sAAAAQMdYVlCWWl5sJ9x4441WhpHRvJ76IrI/GFbv7u4URwMAAIBc5w+Fk00PAAAAyD2WjbxA50h2KDfMqgMAAABSyR8My8v8ZAAAgJxFQTnN+RoW64EQBWUAAACkXiAUoUMZAAAgh1FQTnOJzU6q6FAGAABAGqgfecHeHgAAALmKgnKas9tsKixwKtCwmzYAAACQKrF4XNWhSPIuOgAAAOQeCsoZwOt2ys/ICwAAAKRYdU1UpiQvIy8AAAByFgXlDFDkcbEpHwAAAFIu0LAmpUMZAAAgd1FQzgBet0t+Rl4AAAAgxaoa7ppjhjIAAEDuoqCcAXx0KAMAACAN0KEMAAAACsoZwOd2qqYuqkg0nupQAAAAkMMSd80xQxkAACB3UVDOAN6GDpAAG/MBAAAghQKhsOw2Q+58R6pDAQAAQIpQUM4ARQ0dIH4KygAAAEihqmBYXrdTNsNIdSgAAABIEQrKGSDRoewPsjEfAAAAUicQDMvHuAsAAICcRkE5A/iSBWU6lAEAAJA6/lAk2ewAAACA3ERBOQP43E5JzFAGAABAavnpUAYAAMh5FJQzQJ7TLpfDxgxlAAAApIxpmgqEwvJ5nKkOBQAAAClEQTkDGIYhn8fFyAsAAACkTF0kpnA0TocyAABAjqOgnCG8bpf8ITblAwAAQGok1qJeCsoAAAA5jYJyhiiiQxkAAAAplFiL+tiUDwAAIKdRUM4QXreTGcoAAABImUCyoMwMZQAAgFxGQTlD+DwuVYciiptmqkMBAABADko0NzBDGQAAILdRUM4QPrdLsbipUG001aEAAAAgByVGXjBDGQAAILdRUM4Q3oZbC5mjDAAAgFTwhyIqyHPI6eCvEAAAALmM1WCGKGroBKGgDAAAgFQIhMLyuZmfDAAAkOsoKGcIb8Nu2mzMBwAAgFTwB8PJNSkAAAByFwXlDJHY/CQQiqQ4EgAAAOQifyiSvGsOAAAAuYuCcoYoLHDKMKQqRl4AAAAgBehQBgAAgERBOWPYbIa8BU4FGHkBAACALhaLxxWsiTBDGQAAABSUM4nP42JTPgAAAHS56lBEpurXowAAAMhtFJQziNftYlM+AAAAdDl/wz4ePmYoAwAA5DwKyhnE53EpEGRTPgAAAHStRFODl5EXAAAAOY+CcgbxuV2qokMZAAAAXSwxdo2RFwAAAKCgnEF8HqfqwjHVRWKpDgUAAAA5JEBBGQAAAA0oKGeQxMy6ABvzAQAAoAv5QxHZbYbceY5UhwIAAIAUo6CcQbwNHSGJTVEAAACAruAPheV1O2UYRqpDAQAAQIpRUM4giQ5lP3OUAQAA0IX8wTDjLgAAACCJgnJG8Xnqd9X2M/ICAAAAXSgQCiebGwAAAJDbKChnkOQMZTqUAQAA0IX8wYi8FJQBAAAgCsoZxeW0K99lVxUdygAAAOgipmnKHwon75YDAABAbqOgnGF8bpcCbMoHAACALlIbjikSjTNDGQAAAJIoKGccn8fFDGUAAAB0mcS4NWYoAwAAQKKgnHG8bqf8zFAGAABAF/E33B3HDGUAAABIFJQzjs/jUoAOZQAAAHSRxN1xRYy8AAAAgCgoZxyf26VATUTxuJnqUAAAAJADEnfHed1sygcAAAAKyhnH53HJNKXqGjbmAwAAgPUSd8cx8gIAAAASBeWMk9hdmznKAAAA6Ar+YEQFeQ45HfzVAQAAABSUM46v4VZDP3OUAQAA0AX8oXCyqQEAAACgoNwGpmlq15plige2pyyGxK2GdCgDAACgKwRC4WRTAwAAAEBBuQ3MQIV2vvqYgkvnqu7Nx2SGa7o8huTIiyAzlAEAAGA9fygiH/OTAQAA0MCR6gAyic1Xqn4X366tq/6m8H//ocjmV+QacpqcA4+RYbN3SQzufIfsNkMBOpQBAADQBfzBsAb0K051GAAAAG0Si0W1c2eFotHsqqFt22ZTPB5v8rzD4VK3biWy260v91JQbiOHr6cKjrtAsYNHqe71R1T37wckMy7XQSd0yfvbDENet5MZygAAALBcLBZXdU1EXkZeAACADLNzZ4Xy893yeHrLMIxUh9NpHA6botHGBWXTNBUM+rVzZ4V69uxjfQyWv0OWspfsrYJxcxX7/L+y9z1IkhT5cI1s3fvJ3qOfpe/tc7soKAMAAMByiTUnm/IBAIBME42Gs66YvDuGYcjj8am6eleXvB8F5Q4wDEOOvQ6TJJmxqOrefFxmaKecA46Wa8gE2dzFlryv1+OSP8QMZQAAAFhrV3WdJDFDGQAAZKRcKCYndOVnZVO+TmLYHfJMXCDnwaMU+eA1Bf/+a9X935Myo3Wd/l50KAMAAKAr7Ao0FJTpUAYAAGi36upqXXHFr1p9/ubN7+rGG6+xMKKOoUO5Exn5hco/8iy5DvyJ6t5YqvD65Yr7t6vg2PM79X18HqcCobBM08ypf2kBAABA16pq6FBmhjIAAED7BQJ+ffjh+60+f+DAAzV37oEWRtQxFJQtYCvqpYJRv1D0q/eTYy+iX70vmaYcewzs8Ov7PC6Fo3HVRWLKd/ErBAAAgDV2VTNDGQAAoKNuvfX32r69Qldc8St99tknKioqVl5enq67bqFuuOEaVVRs0/btFRoy5AjNnftb/ec/b+mvf71Hf/rTPbrkkgt04IEH6e23/6tdu3bqsst+rSOOODKln4dqpIUcfQYkfw7/Z6ViX2yUY+/DlTf0DNmKerf7dRMz7PzBMAVlAAAAWGZXoFZ2myF3HmtOAACQuV7b8JX+/c5Xlrz2iMF9dNSgPt97zqWXztEvfnGhZs36fzr99FP02GO3q0+fPfTcc6u0337769prb1IkEtE555yu99/f3OT6SCSqu+++T//+9yu6++47KCjnioJRsxTe8KzC//2HokuvlPOgnyjv8PEy8gvb/FreREE5FFFpt86OFAAAAN9n5cqVuuuuuxSNRnXuuefq7LPPTh577733NHfu3OTjyspKFRUV6emnn9bWrVs1Z84c7dixQz/84Q918803y+PxpOIjtFpVdVg+j4sxawAAAJ2kW7fu6tNnD0nSiSeepHff3ailSx/Wp59+oqqqKtXUhJpcM3RofQF5n332ld/v79J4m0NBuYsYDpfyDiuTc8BIhdcvV2TT84p99b7cE65u8wK9yPNNhzIAAAC6Tnl5uRYtWqRly5bJ5XJp8uTJGjp0qPr37y9JOuCAA/Tkk09KkmpqanT66adr/vz5kqSrr75aU6ZM0dixY3XHHXfozjvv1Jw5c1L1UVplV3Ud85MBAEDGO2pQy13EXSUvLy/58+OP/10vvfSiTjnlNE2adIQ++eR/Mk2zyTUuV30t0DCMZo93NVuqA8g1NneR8kdOk3viNco78iwZhqF49Q5FPl7X6i9EYlHvD1FQBgAA6Epr1qzRsGHDVFxcLLfbrdGjR2vVqlXNnnv33Xfrxz/+sYYMGaJIJKJ169Zp9OjRkqQJEybs9rp0squ6LjluDQAAAO1jt9sVi8WaPL9u3Rs65ZQJGjXqZIXDYX344QeKx+MpiLBt6FBOEXv3PZM/Rza9oPDbz8jee3/lDZsse+k+33utjw5lAACAlNi2bZtKSkqSj0tLS/XOO+80OS8QCGjp0qVauXKlJGnnzp0qLCyUw1G//C4pKVF5eXmb3rtHj7aPSuuoquo6/WDfniop8Xb5e+cKcmst8mst8mst8mst8mutdMjvtm02ORzp0UtbWtpTvXv31g03LJCkZFxnnXW2Fi68QUuW3C+Pp1CDBh2i8vKvtOee/WQYhhwOmwzDkN1e/1nsdluj67/LZrN1Se4pKKcB148nyvCVKrx+mUIrFsjRf5jyjjhdtsIezZ7vsNvkznMoEIx0caQAAAC5LR6PNxpXZppms+PLnnrqKZ1wwgnq0aPHbs9r69izHTuqFY933S2OpmmqKlAnl81QRUWgy943l5SUeMmthcivtcivtcivtcivtdIlv/F4XNFounT72nXXXX9NPkrEdeihQ/Tww080e8Xtt9+taDSu22+/O3lNaWlvrVjxj91+rng83ij3NpthSVNCepTpc5xhs8t1wLHynHmTXIeOU/STtxR87CqZ4aZDuBO8HhcjLwAAALpY7969VVFRkXxcUVGh0tLSJuc9//zzGjNmTPJx9+7dFQgEkrc67u66dFIbjikcjcvrYYYyAAAAvkFBOY0YrgLlHTFJnjNvVP6In8pwuWXGo4p8uEZmvPGclSK3k5EXAAAAXWz48OFau3atKisrVVNTo9WrV2vkyJGNzjFNU5s2bdJhhx2WfM7pdGrIkCF65plnJEkrVqxocl26STQvMEMZAAAA30ZBOQ3ZCnvIud9wSVL0k7dU+697FHrid4pu2ZA8hw5lAACArterVy/Nnj1bU6dO1amnnqpx48Zp8ODBmjlzpjZsqF+rVVZWyul0NtrBW5LmzZunpUuXasyYMVq/fr0uvfTSFHyC1kuMV0vs3wEAAABIFs9QXrlype666y5Fo1Gde+65Ovvssxsdf++993TllVcqGAxqyJAhuvrqq5MblaCeY58jlG/YVPfmY6r55y2y73mw8oZNls/j0tsfbdftT7yjfJdd+S5H/f/zGv7vsqugmecS5zns/FsCAABAe5SVlamsrKzRc4sXL07+3KNHD7322mtNruvbt68efPBBy+PrLHQoAwAAoDmWVW/Ly8u1aNEiLVu2TC6XS5MnT9bQoUPVv3//5Dlz5szRtddeq0MPPVS/+c1vtHTpUk2ZMsWqkDKSYRhy7vNjOfY6VJFNL6ju/55S6Inf6sihl+qLbT75d+5SRSSq2nBcteGYIjHJlBSRQ6YM2VQ/pNuUZMqQVL/5i9Nha1Jkznc5VJDX9Ln8bz1X0Ezx2tWw4yQAAACyR2K8mtfNDGUAAAB8w7KC8po1azRs2DAVFxdLkkaPHq1Vq1bpkksukSR9+eWXqq2t1aGHHipJmjBhgm677TYKyrth2J1yDT5Jzv1HKPLBq9p30GBdMdhQ9SO/khnYLhWo/r8GdWOuUY2rm1zrHpD7yzcbvZYpaUPpOP2vYJB673pbP656VmbUkBmqLzqbpvTf6D56JDBURUZQc4r+kSxIm5JM01C56dat/vqNZi7xPqtu9lBDwToZse4Ln6Qqs1AnOtfrQNtn33r/+vP+Ff+RNps/1ADbZzrOtl6S9JFR//6S9KH20iv6sQoV1BnGs43ilwwF5dZy+8kyJI2PPatCBeuPG98Uzp92jFbQ8OjHsbe0T/yzJq+x3n64PrXvrb3jn2lI9K3kJzDrD+tz2w/0lvPHKjBDGh3+JobEeSGjQM/lnSQZhk6ofVZu81sbKTac9GLeKIVsHh0S/j/1i332nVeQ3nYdri8ce2nP6Gc6JPx/+q4vHT/Q23k/Un48pONqVjc5Xmtz6yX3aEnSMaHVKjCbbub4SsGJqrF5dGjsv+pV+2mT4xvzDtNW597aI/K5Dq5rGsNWRz9tKqiP4ehQMzEYbr3qGSVJGhF8TvnfiiHxSV9zn6Aam0cH1v5HfaKfNxz7Jg/v5h+qr5x7qU/kcx1Y+58m7/GVs5/ezT9cefGQjgo+1+R4na1ArzXEMDz4nPLjTfOwxnOCam0eHVD7H/WJfN7k+OaCw/SV8wfqHflcB9Q0jeFrZz+9V3C48uMhHRl8vsnxiMOjfxccL0k6svr5RnlIWOs5XrU2jwbW/Ed9oluaHH8v/1CVu/ZS7/DnGlj732Zi2FObC+rzcGR10xhqbQV6vfBESdKw6uebzcMbhfUxDKj5j3pHmsbwfv6h+tr1A/UKb9HAZn4X5a5vYhgWaD6GN7z1MQwN7CYG7zcx9Ap/0TSGgkNU3hDDgJr6PNjthmIxMxnD+wWHKS8e0tDAC02ur7MV6A3vCZKkIwLPKz9e0+ScN70/aXMM37btWzEcUd1MDEaB3vxWDHlm0xjWFR6vWptb+9f8V72a+V18kP9NDPs3830od+6pDwoOU55ZoyOa+V3U2Qr0ZsPv4ojA88pr5nexruF3cWD4HfWo+bRpDAWHNsTwufZvJg/lzn76wN2Qhw7GsH9oN3lo+F2U7uZ3Ue7c81sxNP99WNfwu/hx4HnlNfN9WOf9iepsHu23mxg+/FYMzeVh27di+HEzMUSdHr3u/klKY0iHPHw3huA+x+uYowY1OQ/pIdmhzMgLAAAAfItlBeVt27appKQk+bi0tFTvvPPObo+XlJSovLy8Te/Ro0dhxwNth5ISb0ret55X6ndG8lH+sZMVrwtJpinTNCXTlMy4fAfsJVu+R0HnTxTetm/D86ZMMy7J1Mn7D1Ven31U91U3Vb/nksx4QxtzXKZpqmyP/pp84NEKVe3Urld2KRqNKRqNKxqLKRaLq7stXxftPVg1dVF5PvpQ0XAgUaWVZMqU9OPSPVXn8KikcqtiyXnPZvK8vYp6yVPQS91rQjJ39fzWlfWnFeV310Bfd+VF86QdvuT1hiSZphw2t37Q3SfTNOXcWSAjFtc3Ze96PXwFctvdcgddsoWdDe/9zfFCt0vdXPnyhF2yh+ySJMNMRqE8p0OFbpfy42E5o99cl+A0pLy8+q4dZzguZzzW6PUlye6wyW6zyxmNyxmLNnkNuxGXDEM2mXKq6Vxsu6IyG0qveWZtk+OxuE3ReP17Os3aZgsEsVhcYTMuM1zTbDEnHo2oVjHFo2Hlx4NNjttitQqFY1I8qvxYdeODphQ34grV1X82V7RaBWbT1wjVRRS0RWVEgnLH/PpuNiN1tfJHI+oRq1V+tKrJ9TK7y29G5DHr5G7muGlE5A/Vz3rMi/jlbiaGYE1YQcMlI1Itd3xXk+PhmpB2hcPqHquRO9r0uOLdtCselseslTuys+nrR+q0M1b/O3SFd8mtpjEEgnWqNpxSNCB3vOlrhOMhVdbVqTgWlCe2o2kMMZ8qo3XymDXyRJo5Lo8qzTqZpqm8yE55VN3kjF2BGlUbdu0frZLHbPoatfFqba+tlS8eaDYGM+pVRbi2PoZoczG4VRGv/67mRSrlaSYPO/3fxFBoVjQbQ0VNrYriARXGGo5HvjleHi1MxlAYbXq9IU8yhvxIpQqbyUO7YkgmQfo6WqjyuvoYvM3FYLhVHmvIQ3SHvM18J3fEQqo2bNovtkveeNPXqIkGVG6rlTcekPe7MUgqjxSqvK5GHjO4+xiioYYYtu8mhqCqDUP7xbbvJoYqldtC8sb9u4nBo/K6UCfFUClvvOla4JsYquSNNT1eHnGrvC6kQrNa3mjT44bh0VeR+hjyY9tVaDb9PmyP1sfQP1Ypr9n0NYKRKn1lC8kTr2o2xvKwW1/VNsTQTIzVYY++qk1tDOmQh+/GUBGq6bR1VWrXZ9lpnz18Gj1sL0alAQAAoBHDNM2mVbJOcNddd6muri652cjSpUu1ceNGLViwQJL01ltv6ZZbbtHDDz8sSfr000910UUXadWqVa1+jx07qhWPWxL+bpWUeFVREejS98wl5Nda5Nda5Nda5Nda5Nda5NdabcmvzWakrCmho1j7Zh/yay3yay3yay3yay3ya610ye/XX3+m3r33SnUYneYvf7lbknThhRcrGo03e853P7NVa1/L2g169+6tiopvOpUqKipUWlq62+Pbt29vdBwAAAAAAAAAkF4sG3kxfPhw3X777aqsrFRBQYFWr16ta665Jnm8b9++ysvL01tvvaUf/ehHevLJJzVy5EirwgEAAAAAAACAlHjwwfv1r389p1gsrqFDhykajaqkpJfOOuscSdKVV87RqFFj1K9fPy1a9HvV1NRo585K/fSn03TqqZNSHH1jlhWUe/XqpdmzZ2vq1KmKRCKaNGmSBg8erJkzZ2rWrFkaNGiQbr75Zl111VWqrq7WQQcdpKlTp1oVDgAAAAAAAIAcFVp5Q7PPu8uukCTVrlmi+I7PmxzPO3KK7D33UuT9VxX54N+7vf77vP76Gr3//ntavPgBGYaha675nfbaa289//yzOuuscxQKBbVx4wbNn3+97rzzNp177vkaMuQIffnlF5o2bUruFJQlqaysTGVlZY2eW7x4cfLngQMH6vHHH7cyBAAAAAAAAABImfXr39S7727U+ef/VJJUV1erXr16Kxyu0xdfbNGGDW/rqKOOltPp1CWXXKo33lirBx+8T//730eqqQmlOPqmLC0oAwAAAAAAAECqtdRJnD/87O897hxwtJwDjm7Xe8fjMZ1xxlmaPLl+vEUgEJDdbpfHU6gXXlitjRvf0TnnTJMk/e53c+X1+nTUUUfr+ONH6fnnn23Xe1rJsk35AAAAAAAAACDXHX74j/Xss88oFAopGo3qiisu00svvaBRo07Siy8+py++2KLBgw+VJK1b96ZmzLhIRx99rF5/fY0kKRaLpTD6puhQBgAAAAAAAACLjBgxUh999IEuuGCa4vGYhg4drpNPHifDMFRUVKyDDhokwzAkSdOnz9TFF89QXp5L++67n/r02UNffbU1xZ+gMQrKAAAAAAAAAGChadNmaNq0GU2ev+22Pzd6PHnyOcnRGN92/vkXWhZbWzHyAgAAAAAAAADQKhSUAQAAAAAAAACtQkEZAAAAAAAAANAqFJQBAAAAAAAAZB3TNFMdQpfpys9KQRkAAAAAAABAVnE4XAoG/TlRVDZNU8GgXw6Hq0vez9El7wIAAAAAAAAAXaRbtxLt3Fmh6updqQ6lU9lsNsXj8SbPOxwudetW0iUxUFAGAAAAAAAAkFXsdod69uyT6jA6XUmJVxUVgZTGwMgLAAAAAAAAAECrUFAGAAAAAAAAALRKRo+8sNmMnHrfXEF+rUV+rUV+rUV+rUV+rUV+rdXa/Gby74G1b3Yiv9Yiv9Yiv9Yiv9Yiv9Yiv9ZK9drXMHNhq0MAAAAAAAAAQIcx8gIAAAAAAAAA0CoUlAEAAAAAAAAArUJBGQAAAAAAAADQKhSUAQAAAAAAAACtQkEZAAAAAAAAANAqFJQBAAAAAAAAAK1CQRkAAAAAAAAA0CoUlAEAAAAAAAAArUJBGQAAAAAAAADQKhSUd2PlypUaM2aMRo0apSVLljQ5/t5772nChAkaPXq0rrzySkWj0RREmbn+9Kc/aezYsRo7dqwWLlzY7PHjjjtO48eP1/jx45v9HWD3fvrTn2rs2LHJ/L399tuNjvP9bb/HHnssmdfx48frRz/6kRYsWNDoHL6/bVddXa1x48bpiy++kCStWbNGZWVlGjVqlBYtWtTsNVu3btXZZ5+tk046SRdffLGCwWBXhpxRvpvfRx99VOPGjVNZWZmuuOIKhcPhJtcsX75cI0aMSH6Pd/d7QNP8XnHFFRo1alQyd88991yTa/j+tt638/vyyy83+jN42LBhuvDCC5tcw/e37Vj7Wou1r7VY+1qHta91WP9ah7WvtVj7Witj1r4mmvj666/N4447zty5c6cZDAbNsrIy88MPP2x0ztixY83//Oc/pmma5hVXXGEuWbIkBZFmptdee80888wzzbq6OjMcDptTp041V69e3eicCy+80Py///u/FEWY2eLxuDlixAgzEons9hy+v53jgw8+ME888URzx44djZ7n+9s2//3vf81x48aZBx10kLllyxazpqbGPOaYY8zPP//cjEQi5vTp082XXnqpyXUXXHCB+fTTT5umaZp/+tOfzIULF3Z16Bnhu/n9+OOPzRNPPNEMBAJmPB43L7/8cvO+++5rct2CBQvMlStXdn3AGea7+TVN0xw3bpxZXl7+vdfx/W2d5vKbsG3bNvP44483P/nkkybX8f1tG9a+1mLtay3Wvl2HtW/nYf1rHda+1mLta61MWvvSodyMNWvWaNiwYSouLpbb7dbo0aO1atWq5PEvv/xStbW1OvTQQyVJEyZMaHQc36+kpERz586Vy+WS0+nUvvvuq61btzY6Z+PGjbr77rtVVlamBQsWqK6uLkXRZp6PP/5YkjR9+nSdcsopeuihhxod5/vbeebPn6/Zs2ere/fujZ7n+9s2S5cu1bx581RaWipJeuedd7TXXnupX79+cjgcKisra/IdjUQiWrdunUaPHi2J7/H3+W5+XS6X5s2bp8LCQhmGof3337/Jn8GStGHDBi1fvlxlZWX61a9+paqqqq4OPSN8N781NTXaunWrfvOb36isrEy33Xab4vF4o2v4/rbed/P7bQsXLtTkyZO19957NznG97dtWPtai7WvtVj7dh3Wvp2H9a91WPtai7WvtTJp7UtBuRnbtm1TSUlJ8nFpaanKy8t3e7ykpKTRcXy//fbbL7mg+/TTT/XPf/5TxxxzTPJ4MBjUAQccoDlz5mj58uXy+/268847UxRt5vH7/TryyCN1xx136P7779ff//53vfbaa8njfH87x5o1a1RbW6uTTz650fN8f9vuuuuu05AhQ5KPW/ozWJJ27typwsJCORwOSXyPv89389u3b18dddRRkqTKykotWbJExx9/fJPrSkpK9LOf/UxPPfWU+vTp0+T2VtT7bn63b9+uYcOG6frrr9fSpUu1fv16Pf74442u4fvbet/Nb8Knn36qN998U1OnTm32Or6/bcPa11qsfa3F2rdrsPbtXKx/rcPa11qsfa2VSWtfCsrNiMfjMgwj+dg0zUaPWzqO1vnwww81ffp0XX755Y3+hcXj8Wjx4sXad9995XA4NH36dL388supCzTDHHbYYVq4cKG8Xq+6d++uSZMmNcof39/O8fe//13nnXdek+f5/nZca76jzT3H97htysvLde6552rixIkaOnRok+N33HGHfvSjH8kwDM2YMUOvvvpqCqLMPP369dMdd9yh0tJSFRQU6Kc//WmTPwP4/nbco48+qilTpsjlcjV7nO9v27D27Rqsfa3B2rdrsPa1Futf67H2tQZr366RjmtfCsrN6N27tyoqKpKPKyoqGrWbf/f49u3bm21Hx+699dZbmjZtmi677DKddtppjY5t3bq10b9omaaZ/JcstGz9+vVau3Zt8vF388f3t+PC4bDWrVunn/zkJ02O8f3tuJb+DJak7t27KxAIKBaL7fYc7N7//vc/TZ48Waeddpp+/vOfNzkeCAR0//33Jx+bpim73d6FEWau999/X88++2zycXN/BvD97bgXXnhBY8aMafYY39+2Y+1rPda+1mHtaz3WvtZj/Wst1r7WYe3bNdJx7UtBuRnDhw/X2rVrVVlZqZqaGq1evVojR45MHu/bt6/y8vL01ltvSZKefPLJRsfx/b766iv9/Oc/180336yxY8c2OZ6fn6/f//732rJli0zT1JIlS3TiiSemINLMFAgEtHDhQtXV1am6ulrLly9vlD++vx33/vvva++995bb7W5yjO9vxx1yyCH65JNP9NlnnykWi+npp59u8h11Op0aMmSInnnmGUnSihUr+B63UnV1tc4//3z98pe/1PTp05s9x+12695779Xbb78tSXrooYf4HreSaZq6/vrrVVVVpUgkokcffbRJ7vj+dkxlZaVqa2vVr1+/Zo/z/W071r7WYu1rLda+1mPtaz3Wv9Zh7Wst1r7WS9e1LwXlZvTq1UuzZ8/W1KlTdeqpp2rcuHEaPHiwZs6cqQ0bNkiSbr75Zt1www066aSTFAqFdjvHBE395S9/UV1dnW688UaNHz9e48eP1yOPPJLMb/fu3bVgwQJdfPHFOumkk2SaZrO3V6F5xx13nI455hideuqpmjhxoiZOnKjDDjuM728n2rJli3r37t3oOb6/nScvL0833nijfvGLX2jMmDHaZ599dNJJJ0mSrrzySr3wwguSpHnz5mnp0qUaM2aM1q9fr0svvTSFUWeOxx9/XNu3b9d9992X/DP4j3/8o6Rv8mu323Xrrbdq/vz5Ovnkk7Vp0ybNmTMnxZFnhoEDB+qCCy7QWWedpbFjx+qAAw7QuHHjJPH97SxffPFFkz+DJb6/HcHa11qsfa3F2td6rH2tx/rXOqx9rcXa13rpuvY1TNM0LX8XAAAAAAAAAEDGo0MZAAAAAAAAANAqFJQBAAAAAAAAAK1CQRkAAAAAAAAA0CoUlAEAAAAAAAAArUJBGQAAAAAAAADQKo5UBwAAaGrAgAHaf//9ZbM1/ne/O+64Q3vuuWenv9fatWvVvXv3Tn1dAAAAoDVY+wJAZqGgDABp6m9/+xsLXQAAAOQE1r4AkDkoKANAhnnjjTd08803a4899tDHH3+s/Px83Xjjjdp3330VCAR09dVXa/PmzTIMQ0cffbT+3//7f3I4HHr77bd17bXXqqamRk6nU5dffrmOPPJISdLtt9+ut99+W7t27dL555+vs88+O8WfEgAAAGDtCwDpiIIyAKSpc889t9Ftf3vuuafuuOMOSdLGjRv161//WkOGDNEjjzyiOXPmaNmyZbr22mtVXFyslStXKhKJ6OKLL9Zf//pXnXfeefr5z3+ua6+9Vscee6w2btyoK664Qk8++aQkqV+/fpo3b57effddnXnmmTrjjDPkdDpT8rkBAACQe1j7AkDmoKAMAGnq+277GzhwoIYMGSJJmjhxohYsWKCdO3fqlVde0SOPPCLDMORyuTR58mT97W9/01FHHSWbzaZjjz1WknTwwQdr5cqVydcbN26cJOmAAw5QOBxWdXW1unXrZu0HBAAAABqw9gWAzGFr+RQAQLqx2+3NPhePx2UYRvK5eDyuaDQqu93e6HlJ+uCDDxSNRiVJDkf9vy8mzjFN06rQAQAAgDZh7QsA6YWCMgBkoM2bN2vz5s2SpEcffVSHHXaYfD6fRowYoYceekimaSocDmvp0qUaPny49tlnHxmGoddee02StGnTJp177rmKx+Op/BgAAABAi1j7AkB6YeQFAKSp786Rk6T/9//+n/Lz89WzZ0/deuut+vLLL9W9e3ctXLhQknTVVVfp2muvVVlZmSKRiI4++mhddNFFcrlcuv3223X99ddr4cKFcjqduv322+VyuVLx0QAAAIBGWPsCQOYwTO7tAICM8sYbb+iaa67R008/nepQAAAAAEux9gWA9MPICwAAAAAAAABAq9ChDAAAAAAAAABoFTqUAQAAAAAAAACtQkEZAAAAAAAAANAqFJQBAAAAAAAAAK1CQRkAAAAAAAAA0CoUlAEAAAAAAAAArUJBGQAAAAAAAADQKv8f+rM05G6SDs8AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance(loss=losses, accuracy=accuracies, log_file=f'{log_dir}/hopfield_lookup_adapted.pdf')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/src/mhnfs/hopfield/examples/latch_sequence/modules/__init__.py b/src/mhnfs/hopfield/examples/latch_sequence/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c11713739acb1aca3b32cca53acf0c3faf1fa9f6 --- /dev/null +++ b/src/mhnfs/hopfield/examples/latch_sequence/modules/__init__.py @@ -0,0 +1,898 @@ +import torch +import torch.nn as nn + +from math import sqrt +from torch import Tensor +from torch.nn import Module, Parameter +from typing import Optional, Tuple, Union + +from .activation import HopfieldCore + + +class Hopfield(Module): + """ + Module with underlying Hopfield association. + """ + + def __init__(self, + input_size: Optional[int] = None, + hidden_size: Optional[int] = None, + output_size: Optional[int] = None, + pattern_size: Optional[int] = None, + num_heads: int = 1, + scaling: Optional[Union[float, Tensor]] = None, + update_steps_max: Optional[Union[int, Tensor]] = 0, + update_steps_eps: Union[float, Tensor] = 1e-4, + + normalize_stored_pattern: bool = True, + normalize_stored_pattern_affine: bool = True, + normalize_state_pattern: bool = True, + normalize_state_pattern_affine: bool = True, + normalize_pattern_projection: bool = True, + normalize_pattern_projection_affine: bool = True, + normalize_hopfield_space: bool = False, + normalize_hopfield_space_affine: bool = False, + stored_pattern_as_static: bool = False, + state_pattern_as_static: bool = False, + pattern_projection_as_static: bool = False, + pattern_projection_as_connected: bool = False, + stored_pattern_size: Optional[int] = None, + pattern_projection_size: Optional[int] = None, + + batch_first: bool = True, + association_activation: Optional[str] = None, + dropout: float = 0.0, + input_bias: bool = True, + concat_bias_pattern: bool = False, + add_zero_association: bool = False, + disable_out_projection: bool = False + ): + """ + Initialise new instance of a Hopfield module. + + :param input_size: depth of the input (state pattern) + :param hidden_size: depth of the association space + :param output_size: depth of the output projection + :param pattern_size: depth of patterns to be selected + :param num_heads: amount of parallel association heads + :param scaling: scaling of association heads, often represented as beta (one entry per head) + :param update_steps_max: maximum count of association update steps (None equals to infinity) + :param update_steps_eps: minimum difference threshold between two consecutive association update steps + :param normalize_stored_pattern: apply normalization on stored patterns + :param normalize_stored_pattern_affine: additionally enable affine normalization of stored patterns + :param normalize_state_pattern: apply normalization on state patterns + :param normalize_state_pattern_affine: additionally enable affine normalization of state patterns + :param normalize_pattern_projection: apply normalization on the pattern projection + :param normalize_pattern_projection_affine: additionally enable affine normalization of pattern projection + :param normalize_hopfield_space: enable normalization of patterns in the Hopfield space + :param normalize_hopfield_space_affine: additionally enable affine normalization of patterns in Hopfield space + :param stored_pattern_as_static: interpret specified stored patterns as being static + :param state_pattern_as_static: interpret specified state patterns as being static + :param pattern_projection_as_static: interpret specified pattern projections as being static + :param pattern_projection_as_connected: connect pattern projection with stored pattern + :param stored_pattern_size: depth of input (stored pattern) + :param pattern_projection_size: depth of input (pattern projection) + :param batch_first: flag for specifying if the first dimension of data fed to "forward" reflects the batch size + :param association_activation: additional activation to be applied on the result of the Hopfield association + :param dropout: dropout probability applied on the association matrix + :param input_bias: bias to be added to input (state and stored pattern as well as pattern projection) + :param concat_bias_pattern: bias to be concatenated to stored pattern as well as pattern projection + :param add_zero_association: add a new batch of zeros to stored pattern as well as pattern projection + :param disable_out_projection: disable output projection + """ + super(Hopfield, self).__init__() + assert type(batch_first) == bool, f'"batch_first" needs to be a boolean, not {type(batch_first)}.' + assert (association_activation is None) or (type(association_activation) == str) + + # Initialise Hopfield association module. + self.association_core = HopfieldCore( + embed_dim=input_size, num_heads=num_heads, dropout=dropout, bias=input_bias, + add_bias_kv=concat_bias_pattern, add_zero_attn=add_zero_association, kdim=stored_pattern_size, + vdim=pattern_projection_size, head_dim=hidden_size, pattern_dim=pattern_size, out_dim=output_size, + disable_out_projection=disable_out_projection, key_as_static=stored_pattern_as_static, + query_as_static=state_pattern_as_static, value_as_static=pattern_projection_as_static, + value_as_connected=pattern_projection_as_connected, normalize_pattern=normalize_hopfield_space, + normalize_pattern_affine=normalize_hopfield_space_affine) + self.association_activation = None + if association_activation is not None: + self.association_activation = getattr(torch, association_activation, None) + + # Initialise stored pattern normalization. + self.norm_stored_pattern = None + if normalize_stored_pattern_affine: + assert normalize_stored_pattern, "affine normalization without normalization has no effect." + if normalize_stored_pattern: + normalized_shape = input_size if stored_pattern_size is None else stored_pattern_size + assert normalized_shape is not None, "stored pattern size required for setting up normalisation" + self.norm_stored_pattern = nn.LayerNorm( + normalized_shape=normalized_shape, elementwise_affine=normalize_stored_pattern_affine) + + # Initialise state pattern normalization. + self.norm_state_pattern = None + if normalize_state_pattern_affine: + assert normalize_state_pattern, "affine normalization without normalization has no effect." + if normalize_state_pattern: + assert input_size is not None, "input size required for setting up normalisation" + self.norm_state_pattern = nn.LayerNorm( + normalized_shape=input_size, elementwise_affine=normalize_state_pattern_affine) + + # Initialise pattern projection normalization. + self.norm_pattern_projection = None + if normalize_pattern_projection_affine: + assert normalize_pattern_projection, "affine normalization without normalization has no effect." + if normalize_pattern_projection: + normalized_shape = input_size if pattern_projection_size is None else pattern_projection_size + assert normalized_shape is not None, "pattern projection size required for setting up normalisation" + self.norm_pattern_projection = nn.LayerNorm( + normalized_shape=normalized_shape, elementwise_affine=normalize_pattern_projection_affine) + + # Initialise remaining auxiliary properties. + if self.association_core.static_execution: + self.__scaling = 1.0 if scaling is None else scaling + else: + assert self.association_core.head_dim > 0, f'invalid hidden dimension encountered.' + self.__scaling = (1.0 / sqrt(self.association_core.head_dim)) if scaling is None else scaling + self.__batch_first = batch_first + self.__update_steps_max = update_steps_max + self.__update_steps_eps = update_steps_eps + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset Hopfield association. + + :return: None + """ + for module in (self.association_core, self.norm_stored_pattern, + self.norm_state_pattern, self.norm_pattern_projection): + if hasattr(module, r'reset_parameters'): + module.reset_parameters() + + def _maybe_transpose(self, *args: Tuple[Tensor, ...]) -> Union[Tensor, Tuple[Tensor, ...]]: + """ + Eventually transpose specified data. + + :param args: tensors to eventually transpose (dependent on the state of "batch_first") + :return: eventually transposed tensors + """ + transposed_result = tuple(_.transpose(0, 1) for _ in args) if self.__batch_first else args + return transposed_result[0] if len(transposed_result) == 1 else transposed_result + + def _associate(self, data: Union[Tensor, Tuple[Tensor, Tensor, Tensor]], + return_raw_associations: bool = False, return_projected_patterns: bool = False, + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tuple[Optional[Tensor], ...]: + """ + Apply Hopfield association module on specified data. + + :param data: data to be processed by Hopfield core module + :param return_raw_associations: return raw association (softmax) values, unmodified + :param return_projected_patterns: return pattern projection values, unmodified + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: Hopfield-processed input data + """ + assert (type(data) == Tensor) or ((type(data) == tuple) and (len(data) == 3)), \ + r'either one tensor to be used as "stored pattern", "state pattern" and' \ + r' "pattern_projection" must be provided, or three separate ones.' + if type(data) == Tensor: + stored_pattern, state_pattern, pattern_projection = data, data, data + else: + stored_pattern, state_pattern, pattern_projection = data + + # Optionally transpose data. + stored_pattern, state_pattern, pattern_projection = self._maybe_transpose( + stored_pattern, state_pattern, pattern_projection) + + # Optionally apply stored pattern normalization. + if self.norm_stored_pattern is not None: + stored_pattern = self.norm_stored_pattern(input=stored_pattern.reshape( + shape=(-1, stored_pattern.shape[2]))).reshape(shape=stored_pattern.shape) + + # Optionally apply state pattern normalization. + if self.norm_state_pattern is not None: + state_pattern = self.norm_state_pattern(input=state_pattern.reshape( + shape=(-1, state_pattern.shape[2]))).reshape(shape=state_pattern.shape) + + # Optionally apply pattern projection normalization. + if self.norm_pattern_projection is not None: + pattern_projection = self.norm_pattern_projection(input=pattern_projection.reshape( + shape=(-1, pattern_projection.shape[2]))).reshape(shape=pattern_projection.shape) + + # Apply Hopfield association and optional activation function. + return self.association_core( + query=state_pattern, key=stored_pattern, value=pattern_projection, + key_padding_mask=stored_pattern_padding_mask, need_weights=False, attn_mask=association_mask, + scaling=self.__scaling, update_steps_max=self.__update_steps_max, update_steps_eps=self.__update_steps_eps, + return_raw_associations=return_raw_associations, return_pattern_projections=return_projected_patterns) + + def forward(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Apply Hopfield association on specified data. + + :param input: data to be processed by Hopfield association module + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: Hopfield-processed input data + """ + association_output = self._maybe_transpose(self._associate( + data=input, return_raw_associations=False, + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask)[0]) + if self.association_activation is not None: + association_output = self.association_activation(association_output) + return association_output + + def get_association_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield association matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: association matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self._associate( + data=input, return_raw_associations=True, + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask)[2] + + def get_projected_pattern_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield projected pattern matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: pattern projection matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self._associate( + data=input, return_projected_patterns=True, + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask)[3] + + @property + def batch_first(self) -> bool: + return self.__batch_first + + @property + def scaling(self) -> Union[float, Tensor]: + return self.__scaling.clone() if type(self.__scaling) == Tensor else self.__scaling + + @property + def stored_pattern_dim(self) -> Optional[int]: + return self.association_core.kdim + + @property + def state_pattern_dim(self) -> Optional[int]: + return self.association_core.embed_dim + + @property + def pattern_projection_dim(self) -> Optional[int]: + return self.association_core.vdim + + @property + def input_size(self) -> Optional[int]: + return self.state_pattern_dim + + @property + def hidden_size(self) -> Optional[int]: + return self.association_core.head_dim + + @property + def output_size(self) -> Optional[int]: + return self.association_core.out_dim + + @property + def pattern_size(self) -> Optional[int]: + return self.association_core.pattern_dim + + @property + def update_steps_max(self) -> Optional[Union[int, Tensor]]: + return self.__update_steps_max.clone() if type(self.__update_steps_max) == Tensor else self.__update_steps_max + + @property + def update_steps_eps(self) -> Optional[Union[float, Tensor]]: + return self.__update_steps_eps.clone() if type(self.__update_steps_eps) == Tensor else self.__update_steps_eps + + @property + def stored_pattern_as_static(self) -> bool: + return self.association_core.key_as_static + + @property + def state_pattern_as_static(self) -> bool: + return self.association_core.query_as_static + + @property + def pattern_projection_as_static(self) -> bool: + return self.association_core.value_as_static + + @property + def normalize_stored_pattern(self) -> bool: + return self.norm_stored_pattern is not None + + @property + def normalize_stored_pattern_affine(self) -> bool: + return self.normalize_stored_pattern and self.norm_stored_pattern.elementwise_affine + + @property + def normalize_state_pattern(self) -> bool: + return self.norm_state_pattern is not None + + @property + def normalize_state_pattern_affine(self) -> bool: + return self.normalize_state_pattern and self.norm_state_pattern.elementwise_affine + + @property + def normalize_pattern_projection(self) -> bool: + return self.norm_pattern_projection is not None + + @property + def normalize_pattern_projection_affine(self) -> bool: + return self.normalize_pattern_projection and self.norm_pattern_projection.elementwise_affine + + @property + def normalize_hopfield_space(self) -> bool: + return self.hopfield.normalize_hopfield_space + + @property + def normalize_hopfield_space_affine(self) -> bool: + return self.hopfield.normalize_hopfield_space_affine + + +class HopfieldPooling(Module): + """ + Wrapper class encapsulating a trainable but fixed state pattern and "Hopfield" in + one combined module to be used as a Hopfield-based pooling layer. + """ + + def __init__(self, + input_size: int, + hidden_size: Optional[int] = None, + output_size: Optional[int] = None, + pattern_size: Optional[int] = None, + num_heads: int = 1, + scaling: Optional[Union[float, Tensor]] = None, + update_steps_max: Optional[Union[int, Tensor]] = 0, + update_steps_eps: Union[float, Tensor] = 1e-4, + + normalize_stored_pattern: bool = True, + normalize_stored_pattern_affine: bool = True, + normalize_state_pattern: bool = True, + normalize_state_pattern_affine: bool = True, + normalize_pattern_projection: bool = True, + normalize_pattern_projection_affine: bool = True, + normalize_hopfield_space: bool = False, + normalize_hopfield_space_affine: bool = False, + stored_pattern_as_static: bool = False, + state_pattern_as_static: bool = False, + pattern_projection_as_static: bool = False, + pattern_projection_as_connected: bool = False, + stored_pattern_size: Optional[int] = None, + pattern_projection_size: Optional[int] = None, + + batch_first: bool = True, + association_activation: Optional[str] = None, + dropout: float = 0.0, + input_bias: bool = True, + concat_bias_pattern: bool = False, + add_zero_association: bool = False, + disable_out_projection: bool = False, + quantity: int = 1, + trainable: bool = True + ): + """ + Initialise a new instance of a Hopfield-based pooling layer. + + :param input_size: depth of the input (state pattern) + :param hidden_size: depth of the association space + :param output_size: depth of the output projection + :param pattern_size: depth of patterns to be selected + :param num_heads: amount of parallel association heads + :param scaling: scaling of association heads, often represented as beta (one entry per head) + :param update_steps_max: maximum count of association update steps (None equals to infinity) + :param update_steps_eps: minimum difference threshold between two consecutive association update steps + :param normalize_stored_pattern: apply normalization on stored patterns + :param normalize_stored_pattern_affine: additionally enable affine normalization of stored patterns + :param normalize_state_pattern: apply normalization on state patterns + :param normalize_state_pattern_affine: additionally enable affine normalization of state patterns + :param normalize_pattern_projection: apply normalization on the pattern projection + :param normalize_pattern_projection_affine: additionally enable affine normalization of pattern projection + :param normalize_hopfield_space: enable normalization of patterns in the Hopfield space + :param normalize_hopfield_space_affine: additionally enable affine normalization of patterns in Hopfield space + :param stored_pattern_as_static: interpret specified stored patterns as being static + :param state_pattern_as_static: interpret specified state patterns as being static + :param pattern_projection_as_static: interpret specified pattern projections as being static + :param pattern_projection_as_connected: connect pattern projection with stored pattern + :param stored_pattern_size: depth of input (stored pattern) + :param pattern_projection_size: depth of input (pattern projection) + :param batch_first: flag for specifying if the first dimension of data fed to "forward" reflects the batch size + :param association_activation: additional activation to be applied on the result of the Hopfield association + :param dropout: dropout probability applied on the association matrix + :param input_bias: bias to be added to input (state and stored pattern as well as pattern projection) + :param concat_bias_pattern: bias to be concatenated to stored pattern as well as pattern projection + :param add_zero_association: add a new batch of zeros to stored pattern as well as pattern projection + :param disable_out_projection: disable output projection + :param quantity: amount of state patterns + :param trainable: state pattern used for pooling is trainable + """ + super(HopfieldPooling, self).__init__() + self.hopfield = Hopfield( + input_size=input_size, hidden_size=hidden_size, output_size=output_size, pattern_size=pattern_size, + num_heads=num_heads, scaling=scaling, update_steps_max=update_steps_max, update_steps_eps=update_steps_eps, + normalize_stored_pattern=normalize_stored_pattern, + normalize_stored_pattern_affine=normalize_stored_pattern_affine, + normalize_state_pattern=normalize_state_pattern, + normalize_state_pattern_affine=normalize_state_pattern_affine, + normalize_pattern_projection=normalize_pattern_projection, + normalize_pattern_projection_affine=normalize_pattern_projection_affine, + normalize_hopfield_space=normalize_hopfield_space, + normalize_hopfield_space_affine=normalize_hopfield_space_affine, + stored_pattern_as_static=stored_pattern_as_static, state_pattern_as_static=state_pattern_as_static, + pattern_projection_as_static=pattern_projection_as_static, + pattern_projection_as_connected=pattern_projection_as_connected, stored_pattern_size=stored_pattern_size, + pattern_projection_size=pattern_projection_size, batch_first=batch_first, + association_activation=association_activation, dropout=dropout, input_bias=input_bias, + concat_bias_pattern=concat_bias_pattern, add_zero_association=add_zero_association, + disable_out_projection=disable_out_projection) + self._quantity = quantity + pooling_weight_size = self.hopfield.hidden_size if state_pattern_as_static else self.hopfield.input_size + self.pooling_weights = nn.Parameter(torch.empty(size=(*( + (1, quantity) if batch_first else (quantity, 1) + ), input_size if pooling_weight_size is None else pooling_weight_size)), requires_grad=trainable) + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset pooling weights and underlying Hopfield association. + + :return: None + """ + if hasattr(self.hopfield, r'reset_parameters'): + self.hopfield.reset_parameters() + + # Explicitly initialise pooling weights. + nn.init.normal_(self.pooling_weights, mean=0.0, std=0.02) + + def _prepare_input(self, input: Union[Tensor, Tuple[Tensor, Tensor]]) -> Tuple[Tensor, Tensor, Tensor]: + """ + Prepare input for Hopfield association. + + :param input: data to be prepared + :return: stored pattern, expanded state pattern as well as pattern projection + """ + assert (type(input) == Tensor) or ((type(input) == tuple) and (len(input) == 2)), \ + r'either one tensor to be used as "stored pattern" and' \ + r' "pattern_projection" must be provided, or two separate ones.' + if type(input) == Tensor: + stored_pattern, pattern_projection = input, input + else: + stored_pattern, pattern_projection = input + + batch_size = stored_pattern.shape[0 if self.batch_first else 1] + return stored_pattern, self.pooling_weights.expand(size=(*( + (batch_size, self.quantity) if self.batch_first else (self.quantity, batch_size) + ), self.pooling_weights.shape[2])), pattern_projection + + def forward(self, input: Union[Tensor, Tuple[Tensor, Tensor]], stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Compute Hopfield-based pooling on specified data. + + :param input: data to be pooled + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: Hopfield-pooled input data + """ + return self.hopfield( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask).flatten(start_dim=1) + + def get_association_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield association matrix used for pooling gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: association matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self.hopfield.get_association_matrix( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + def get_projected_pattern_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield projected pattern matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: pattern projection matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self.hopfield.get_projected_pattern_matrix( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + @property + def batch_first(self) -> bool: + return self.hopfield.batch_first + + @property + def scaling(self) -> Union[float, Tensor]: + return self.hopfield.scaling + + @property + def stored_pattern_dim(self) -> Optional[int]: + return self.hopfield.stored_pattern_dim + + @property + def state_pattern_dim(self) -> Optional[int]: + return self.hopfield.state_pattern_dim + + @property + def pattern_projection_dim(self) -> Optional[int]: + return self.hopfield.pattern_projection_dim + + @property + def input_size(self) -> Optional[int]: + return self.hopfield.input_size + + @property + def hidden_size(self) -> int: + return self.hopfield.hidden_size + + @property + def output_size(self) -> Optional[int]: + return self.hopfield.output_size + + @property + def pattern_size(self) -> Optional[int]: + return self.hopfield.pattern_size + + @property + def quantity(self) -> int: + return self._quantity + + @property + def update_steps_max(self) -> Optional[Union[int, Tensor]]: + return self.hopfield.update_steps_max + + @property + def update_steps_eps(self) -> Optional[Union[float, Tensor]]: + return self.hopfield.update_steps_eps + + @property + def stored_pattern_as_static(self) -> bool: + return self.hopfield.stored_pattern_as_static + + @property + def state_pattern_as_static(self) -> bool: + return self.hopfield.state_pattern_as_static + + @property + def pattern_projection_as_static(self) -> bool: + return self.hopfield.pattern_projection_as_static + + @property + def normalize_stored_pattern(self) -> bool: + return self.hopfield.normalize_stored_pattern + + @property + def normalize_stored_pattern_affine(self) -> bool: + return self.hopfield.normalize_stored_pattern_affine + + @property + def normalize_state_pattern(self) -> bool: + return self.hopfield.normalize_state_pattern + + @property + def normalize_state_pattern_affine(self) -> bool: + return self.hopfield.normalize_state_pattern_affine + + @property + def normalize_pattern_projection(self) -> bool: + return self.hopfield.normalize_pattern_projection + + @property + def normalize_pattern_projection_affine(self) -> bool: + return self.hopfield.normalize_pattern_projection_affine + + +class HopfieldLayer(Module): + """ + Wrapper class encapsulating a trainable but fixed stored pattern, pattern projection and "Hopfield" in + one combined module to be used as a Hopfield-based pooling layer. + """ + + def __init__(self, + input_size: int, + hidden_size: Optional[int] = None, + output_size: Optional[int] = None, + pattern_size: Optional[int] = None, + num_heads: int = 1, + scaling: Optional[Union[float, Tensor]] = None, + update_steps_max: Optional[Union[int, Tensor]] = 0, + update_steps_eps: Union[float, Tensor] = 1e-4, + lookup_weights_as_separated: bool = False, + lookup_targets_as_trainable: bool = True, + + normalize_stored_pattern: bool = True, + normalize_stored_pattern_affine: bool = True, + normalize_state_pattern: bool = True, + normalize_state_pattern_affine: bool = True, + normalize_pattern_projection: bool = True, + normalize_pattern_projection_affine: bool = True, + normalize_hopfield_space: bool = False, + normalize_hopfield_space_affine: bool = False, + stored_pattern_as_static: bool = False, + state_pattern_as_static: bool = False, + pattern_projection_as_static: bool = False, + pattern_projection_as_connected: bool = False, + stored_pattern_size: Optional[int] = None, + pattern_projection_size: Optional[int] = None, + + batch_first: bool = True, + association_activation: Optional[str] = None, + dropout: float = 0.0, + input_bias: bool = True, + concat_bias_pattern: bool = False, + add_zero_association: bool = False, + disable_out_projection: bool = False, + quantity: int = 1, + trainable: bool = True + ): + """ + Initialise a new instance of a Hopfield-based lookup layer. + + :param input_size: depth of the input (state pattern) + :param hidden_size: depth of the association space + :param output_size: depth of the output projection + :param pattern_size: depth of patterns to be selected + :param num_heads: amount of parallel association heads + :param scaling: scaling of association heads, often represented as beta (one entry per head) + :param update_steps_max: maximum count of association update steps (None equals to infinity) + :param update_steps_eps: minimum difference threshold between two consecutive association update steps + :param lookup_weights_as_separated: separate lookup weights from lookup target weights + :param lookup_targets_as_trainable: employ trainable lookup target weights (used as pattern projection input) + :param normalize_stored_pattern: apply normalization on stored patterns + :param normalize_stored_pattern_affine: additionally enable affine normalization of stored patterns + :param normalize_state_pattern: apply normalization on state patterns + :param normalize_state_pattern_affine: additionally enable affine normalization of state patterns + :param normalize_pattern_projection: apply normalization on the pattern projection + :param normalize_pattern_projection_affine: additionally enable affine normalization of pattern projection + :param normalize_hopfield_space: enable normalization of patterns in the Hopfield space + :param normalize_hopfield_space_affine: additionally enable affine normalization of patterns in Hopfield space + :param stored_pattern_as_static: interpret specified stored patterns as being static + :param state_pattern_as_static: interpret specified state patterns as being static + :param pattern_projection_as_static: interpret specified pattern projections as being static + :param pattern_projection_as_connected: connect pattern projection with stored pattern + :param stored_pattern_size: depth of input (stored pattern) + :param pattern_projection_size: depth of input (pattern projection) + :param batch_first: flag for specifying if the first dimension of data fed to "forward" reflects the batch size + :param association_activation: additional activation to be applied on the result of the Hopfield association + :param dropout: dropout probability applied on the association matrix + :param input_bias: bias to be added to input (state and stored pattern as well as pattern projection) + :param concat_bias_pattern: bias to be concatenated to stored pattern as well as pattern projection + :param add_zero_association: add a new batch of zeros to stored pattern as well as pattern projection + :param disable_out_projection: disable output projection + :param quantity: amount of stored patterns + :param trainable: stored pattern used for lookup is trainable + """ + super(HopfieldLayer, self).__init__() + self.hopfield = Hopfield( + input_size=input_size, hidden_size=hidden_size, output_size=output_size, pattern_size=pattern_size, + num_heads=num_heads, scaling=scaling, update_steps_max=update_steps_max, update_steps_eps=update_steps_eps, + normalize_stored_pattern=normalize_stored_pattern, + normalize_stored_pattern_affine=normalize_stored_pattern_affine, + normalize_state_pattern=normalize_state_pattern, + normalize_state_pattern_affine=normalize_state_pattern_affine, + normalize_pattern_projection=normalize_pattern_projection, + normalize_pattern_projection_affine=normalize_pattern_projection_affine, + normalize_hopfield_space=normalize_hopfield_space, + normalize_hopfield_space_affine=normalize_hopfield_space_affine, + stored_pattern_as_static=stored_pattern_as_static, state_pattern_as_static=state_pattern_as_static, + pattern_projection_as_static=pattern_projection_as_static, + pattern_projection_as_connected=pattern_projection_as_connected, stored_pattern_size=stored_pattern_size, + pattern_projection_size=pattern_projection_size, batch_first=batch_first, + association_activation=association_activation, dropout=dropout, input_bias=input_bias, + concat_bias_pattern=concat_bias_pattern, add_zero_association=add_zero_association, + disable_out_projection=disable_out_projection) + self._quantity = quantity + lookup_weight_size = self.hopfield.hidden_size if stored_pattern_as_static else self.hopfield.stored_pattern_dim + self.lookup_weights = nn.Parameter(torch.empty(size=(*( + (1, quantity) if batch_first else (quantity, 1) + ), input_size if lookup_weight_size is None else lookup_weight_size)), requires_grad=trainable) + + if lookup_weights_as_separated: + target_weight_size = self.lookup_weights.shape[ + 2] if pattern_projection_size is None else pattern_projection_size + self.target_weights = nn.Parameter(torch.empty(size=(*( + (1, quantity) if batch_first else (quantity, 1) + ), target_weight_size)), requires_grad=lookup_targets_as_trainable) + else: + self.register_parameter(name=r'target_weights', param=None) + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset lookup and lookup target weights, including underlying Hopfield association. + + :return: None + """ + if hasattr(self.hopfield, r'reset_parameters'): + self.hopfield.reset_parameters() + + # Explicitly initialise lookup and target weights. + nn.init.normal_(self.lookup_weights, mean=0.0, std=0.02) + if self.target_weights is not None: + nn.init.normal_(self.target_weights, mean=0.0, std=0.02) + + def _prepare_input(self, input: Tensor) -> Tuple[Tensor, Tensor, Tensor]: + """ + Prepare input for Hopfield association. + + :param input: data to be prepared + :return: stored pattern, expanded state pattern as well as pattern projection + """ + batch_size = input.shape[0 if self.batch_first else 1] + stored_pattern = self.lookup_weights.expand(size=(*( + (batch_size, self.quantity) if self.batch_first else (self.quantity, batch_size) + ), self.lookup_weights.shape[2])) + if self.target_weights is None: + pattern_projection = stored_pattern + else: + pattern_projection = self.target_weights.expand(size=(*( + (batch_size, self.quantity) if self.batch_first else (self.quantity, batch_size) + ), self.target_weights.shape[2])) + + return stored_pattern, input, pattern_projection + + def forward(self, input: Tensor, stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Compute Hopfield-based lookup on specified data. + + :param input: data to used in lookup + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: result of Hopfield-based lookup on input data + """ + return self.hopfield( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + def get_association_matrix(self, input: Tensor, stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield association matrix used for lookup gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: association matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self.hopfield.get_association_matrix( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + def get_projected_pattern_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield projected pattern matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: pattern projection matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self.hopfield.get_projected_pattern_matrix( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + @property + def batch_first(self) -> bool: + return self.hopfield.batch_first + + @property + def scaling(self) -> Union[float, Tensor]: + return self.hopfield.scaling + + @property + def stored_pattern_dim(self) -> Optional[int]: + return self.hopfield.stored_pattern_dim + + @property + def state_pattern_dim(self) -> Optional[int]: + return self.hopfield.state_pattern_dim + + @property + def pattern_projection_dim(self) -> Optional[int]: + return self.hopfield.pattern_projection_dim + + @property + def input_size(self) -> Optional[int]: + return self.hopfield.input_size + + @property + def hidden_size(self) -> int: + return self.hopfield.hidden_size + + @property + def output_size(self) -> Optional[int]: + return self.hopfield.output_size + + @property + def pattern_size(self) -> Optional[int]: + return self.hopfield.pattern_size + + @property + def quantity(self) -> int: + return self._quantity + + @property + def update_steps_max(self) -> Optional[Union[int, Tensor]]: + return self.hopfield.update_steps_max + + @property + def update_steps_eps(self) -> Optional[Union[float, Tensor]]: + return self.hopfield.update_steps_eps + + @property + def stored_pattern_as_static(self) -> bool: + return self.hopfield.stored_pattern_as_static + + @property + def state_pattern_as_static(self) -> bool: + return self.hopfield.state_pattern_as_static + + @property + def pattern_projection_as_static(self) -> bool: + return self.hopfield.pattern_projection_as_static + + @property + def normalize_stored_pattern(self) -> bool: + return self.hopfield.normalize_stored_pattern + + @property + def normalize_stored_pattern_affine(self) -> bool: + return self.hopfield.normalize_stored_pattern_affine + + @property + def normalize_state_pattern(self) -> bool: + return self.hopfield.normalize_state_pattern + + @property + def normalize_state_pattern_affine(self) -> bool: + return self.hopfield.normalize_state_pattern_affine + + @property + def normalize_pattern_projection(self) -> bool: + return self.hopfield.normalize_pattern_projection + + @property + def normalize_pattern_projection_affine(self) -> bool: + return self.hopfield.normalize_pattern_projection_affine diff --git a/src/mhnfs/hopfield/examples/latch_sequence/modules/activation.py b/src/mhnfs/hopfield/examples/latch_sequence/modules/activation.py new file mode 100644 index 0000000000000000000000000000000000000000..6dcd6e56cddb954cf6b049687bdf5e7783aa2bc9 --- /dev/null +++ b/src/mhnfs/hopfield/examples/latch_sequence/modules/activation.py @@ -0,0 +1,337 @@ +import torch +import torch.nn as nn + +from torch import Tensor +from torch.nn import Linear, Module, Parameter +from typing import Optional + +from .functional import hopfield_core_forward + +try: + from torch.nn.modules.linear import _LinearWithBias +except ImportError: + _LinearWithBias = None + + +class HopfieldCore(Module): + r"""Allows the model to jointly attend to information + from different representation subspaces. + See references: "Hopfield Networks is All You Need" and + "Attention Is All You Need" (on which this implementation is partly based on). + + .. math:: + \text{HopfieldHead}(Q, K, V) = \text{Concat}(head_1,\dots,head_h)W^O + \text{where} head_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V) + + Args: + embed_dim: total dimension of the model. + num_heads: parallel attention heads. + dropout: a Dropout layer on attn_output_weights. Default: 0.0. + bias: add bias as module parameter. Default: True. + add_bias_kv: add bias to the key and value sequences at dim=0. + add_zero_attn: add a new batch of zeros to the key and + value sequences at dim=1. + kdim: total number of features in key. Default: None. + vdim: total number of features in value. Default: None. + + Note: if kdim and vdim are None, they will be set to embed_dim such that + query, key, and value have the same number of features. + + Examples:: + + >>> hopfield_attn = HopfieldCore(embed_dim, num_heads) + >>> attn_output, attn_output_weights, attn_matrix = hopfield_attn(query, key, value) + """ + __annotations__ = { + 'bias_k': torch._jit_internal.Optional[torch.Tensor], + 'bias_v': torch._jit_internal.Optional[torch.Tensor], + } + + def __init__(self, + embed_dim=None, # type: Optional[int] + num_heads=1, # type: int + dropout=0.0, # type: float + bias=True, # type: bool + add_bias_kv=False, # type: bool + add_zero_attn=False, # type: bool + kdim=None, # type: Optional[int] + vdim=None, # type: Optional[int] + + head_dim=None, # type: Optional[int] + pattern_dim=None, # type: Optional[int] + out_dim=None, # type: Optional[int] + disable_out_projection=False, # type: bool + key_as_static=False, # type: bool + query_as_static=False, # type: bool + value_as_static=False, # type: bool + value_as_connected=False, # type: bool + normalize_pattern=False, # type: bool + normalize_pattern_affine=False # type: bool + ): + super(HopfieldCore, self).__init__() + + assert (type(key_as_static) == bool) and (type(query_as_static) == bool) and (type(value_as_static) == bool) + self.key_as_static, self.query_as_static, self.value_as_static = key_as_static, query_as_static, value_as_static + num_non_static = 3 - (self.key_as_static + self.query_as_static + self.value_as_static) + assert 0 <= num_non_static < 4 + + self.value_as_connected = value_as_connected + self.normalize_pattern, self.normalize_pattern_affine = normalize_pattern, normalize_pattern_affine + self.disable_out_projection = disable_out_projection + + # In case of a static-only executions, check corresponding projections and normalizations. + self.static_execution = self._check_execution_mode() + if self.static_execution: + embed_dim, kdim, vdim = None, None, None + if embed_dim is None: + assert self.static_execution, r'static-only execution requires all projections to be deactivated.' + + # Check and set all other properties, conditioned on . + self.embed_dim = embed_dim + self.kdim = kdim if kdim is not None else embed_dim + self.vdim = vdim if vdim is not None else embed_dim + self._qkv_same_embed_dim = all(( + self.kdim == embed_dim, self.vdim == embed_dim, pattern_dim is None, not self.value_as_connected)) + assert (not self.value_as_connected) or (self.kdim == self.vdim), r'key and value need to be of same dimension.' + + self.num_heads = num_heads + self.dropout = dropout + self.head_dim = None + self.pattern_dim = pattern_dim + self.virtual_hopfield_dim = None + self.virtual_pattern_dim = None + if not self.static_execution: + if head_dim is None: + self.head_dim = embed_dim // num_heads + assert self.head_dim * num_heads == self.embed_dim, "embed_dim must be divisible by num_heads." + else: + assert head_dim > 0, "dimension of the association space has to be positive." + self.head_dim = head_dim + if self.pattern_dim is None: + self.pattern_dim = self.head_dim + self.virtual_hopfield_dim = self.num_heads * self.head_dim + self.virtual_pattern_dim = self.num_heads * self.pattern_dim + + self.out_dim = embed_dim if out_dim is None else out_dim + assert disable_out_projection or (self.out_dim > 0), "output projection dimension has to be positive." + + if normalize_pattern_affine: + assert normalize_pattern, "affine pattern normalization without pattern normalization has no effect." + self.p_norm_weight = Parameter(torch.Tensor(head_dim)) + self.p_norm_bias = Parameter(torch.Tensor(head_dim)) + else: + self.register_parameter('p_norm_weight', None) + self.register_parameter('p_norm_bias', None) + + if self._qkv_same_embed_dim is False: + if query_as_static: + self.register_parameter('q_proj_weight', None) + else: + self.q_proj_weight = Parameter(torch.Tensor(self.virtual_hopfield_dim, embed_dim)) + if key_as_static: + self.register_parameter('k_proj_weight', None) + else: + self.k_proj_weight = Parameter(torch.Tensor(self.virtual_hopfield_dim, self.kdim)) + if value_as_static: + self.register_parameter('v_proj_weight', None) + else: + self.v_proj_weight = Parameter(torch.Tensor( + self.virtual_pattern_dim, + self.virtual_hopfield_dim if (value_as_connected and not key_as_static) else self.vdim)) + self.register_parameter('in_proj_weight', None) + else: + if num_non_static > 0: + self.in_proj_weight = Parameter(torch.empty( + (not query_as_static) * self.virtual_hopfield_dim + + (not key_as_static) * self.virtual_hopfield_dim + + (not value_as_static) * self.virtual_pattern_dim, embed_dim)) + else: + self.register_parameter('in_proj_weight', None) + self.register_parameter('q_proj_weight', None) + self.register_parameter('k_proj_weight', None) + self.register_parameter('v_proj_weight', None) + + if bias and (num_non_static > 0): + self.in_proj_bias = Parameter(torch.empty( + (not query_as_static) * self.virtual_hopfield_dim + + (not key_as_static) * self.virtual_hopfield_dim + self.virtual_pattern_dim)) + else: + self.register_parameter('in_proj_bias', None) + if disable_out_projection: + self.register_parameter('out_proj', None) + else: + if bias and _LinearWithBias is not None: + self.out_proj = _LinearWithBias(self.virtual_pattern_dim, self.out_dim) + else: + self.out_proj = Linear(self.virtual_pattern_dim, self.out_dim, bias=bias) + + self.bias_k, self.bias_v = None, None + if add_bias_kv: + if not key_as_static: + self.bias_k = Parameter(torch.empty(1, 1, self.virtual_hopfield_dim)) + if not value_as_static: + self.bias_v = Parameter(torch.empty(1, 1, self.virtual_hopfield_dim)) + assert not (self.bias_k is None and self.bias_v is None), r'cannot set key/value bias if both are static.' + + self.add_zero_attn = add_zero_attn + self.reset_parameters() + + def _check_execution_mode(self) -> bool: + return all(( + self.key_as_static, self.query_as_static, self.value_as_static, not self.value_as_connected, + not self.normalize_pattern, not self.normalize_pattern_affine, self.disable_out_projection + )) + + def reset_parameters(self): + if self.p_norm_weight is not None: + nn.init.ones_(self.p_norm_weight) + nn.init.zeros_(self.p_norm_bias) + + if self._qkv_same_embed_dim and (self.in_proj_weight is not None): + nn.init.normal_(self.in_proj_weight, mean=0.0, std=0.02) + else: + if self.q_proj_weight is not None: + nn.init.normal_(self.q_proj_weight, mean=0.0, std=0.02) + if self.k_proj_weight is not None: + nn.init.normal_(self.k_proj_weight, mean=0.0, std=0.02) + if self.v_proj_weight is not None: + nn.init.normal_(self.v_proj_weight, mean=0.0, std=0.02) + + if self.in_proj_bias is not None: + nn.init.constant_(self.in_proj_bias, 0.0) + if not self.disable_out_projection: + nn.init.normal_(self.out_proj.weight, mean=0.0, std=0.02) + if self.out_proj.bias is not None: + nn.init.constant_(self.out_proj.bias, 0.0) + if self.bias_k is not None: + nn.init.normal_(self.bias_k, mean=0.0, std=0.02) + if self.bias_v is not None: + nn.init.normal_(self.bias_v, mean=0.0, std=0.02) + + def __setstate__(self, state): + super(HopfieldCore, self).__setstate__(state) + + def forward(self, + query, # type: Tensor + key, # type: Tensor + value, # type: Tensor + key_padding_mask=None, # type: Optional[Tensor] + need_weights=True, # type: bool + attn_mask=None, # type: Optional[Tensor] + + scaling=None, # type: Optional[Tensor] + update_steps_max=0, # type: Optional[int] + update_steps_eps=1e-4, # type: float + return_raw_associations=False, # type: bool + return_pattern_projections=False # type: bool + ): + # type: (...) -> Tuple[Tensor, Optional[Tensor], Optional[Tensor]] + r""" + Args: + query, key, value: map a query and a set of key-value pairs to an output. + See "Attention Is All You Need" for more details. + See "Hopfield Networks is All You Need" for more details in the setting of Hopfield networks. + key_padding_mask: if provided, specified padding elements in the key will + be ignored by the attention. When given a binary mask and a value is True, + the corresponding value on the attention layer will be ignored. When given + a byte mask and a value is non-zero, the corresponding value on the attention + layer will be ignored. + need_weights: output attn_output_weights. + attn_mask: 2D or 3D mask that prevents attention to certain positions. A 2D mask will be broadcasted for all + the batches while a 3D mask allows to specify a different mask for the entries of each batch. + + scaling: scaling of association heads, often represented as beta (one entry per head). + update_steps_max: maximum count of association update steps (None equals to infinity). + update_steps_eps: minimum difference threshold between two consecutive association update steps. + return_raw_associations: return raw association (softmax) values, unmodified. + return_pattern_projections: return pattern projection values, unmodified. + + Shape: + - Inputs: + - query: :math:`(L, N, E)` where L is the target sequence length, N is the batch size, E is + the embedding dimension. + - key: :math:`(S, N, E)`, where S is the source sequence length, N is the batch size, E is + the embedding dimension. + - value: :math:`(S, N, E)` where S is the source sequence length, N is the batch size, E is + the embedding dimension. + - key_padding_mask: :math:`(N, S)` where N is the batch size, S is the source sequence length. + If a ByteTensor is provided, the non-zero positions will be ignored while the position + with the zero positions will be unchanged. If a BoolTensor is provided, the positions with the + value of ``True`` will be ignored while the position with the value of ``False`` will be unchanged. + - attn_mask: 2D mask :math:`(L, S)` where L is the target sequence length, S is the source sequence length. + 3D mask :math:`(N*num_heads, L, S)` where N is the batch size, L is the target sequence length, + S is the source sequence length. attn_mask ensure that position i is allowed to attend the unmasked + positions. If a ByteTensor is provided, the non-zero positions are not allowed to attend + while the zero positions will be unchanged. If a BoolTensor is provided, positions with ``True`` + is not allowed to attend while ``False`` values will be unchanged. If a FloatTensor + is provided, it will be added to the attention weight. + + - scaling: :math:`(num_heads,)`, where num_heads is the amount of heads. + + - Outputs: + - attn_output: :math:`(L, N, E)` where L is the target sequence length, N is the batch size, + E is the embedding dimension. + - attn_output_weights: :math:`(N, L, S)` where N is the batch size, + L is the target sequence length, S is the source sequence length. + - attn_raw: :math:``(N, num_heads, L, S)`, where N is the batch size, + L is the target sequence length, S is the source sequence length. + """ + if self.query_as_static and self.key_as_static: + assert query.shape[2] == key.shape[2], \ + f'query shape[2] of {query.shape[2]} and key shape[2] of {key.shape[2]} need to be equal' + head_dim, embed_dim_to_check = query.shape[2], query.shape[2] + else: + assert self.query_as_static or (query.shape[2] == self.embed_dim), \ + f'query shape[2] of {query.shape[2]} invalid, needs to be {self.embed_dim}.' + assert (not self.query_as_static) or (self.query_as_static and query.shape[2] == self.head_dim), \ + f'query shape[2] of {query.shape[2]} invalid, needs to be {self.head_dim}' + + assert self.key_as_static or (key.shape[2] == self.kdim), \ + f'key shape[2] of {key.shape[2]} invalid, needs to be {self.kdim}.' + assert (not self.key_as_static) or (self.key_as_static and key.shape[2] == self.head_dim), \ + f'key shape[2] of {key.shape[2]} invalid, needs to be {self.head_dim}' + head_dim, embed_dim_to_check = self.head_dim, self.head_dim if self.query_as_static else self.embed_dim + + assert self.value_as_static or (value.shape[2] == self.vdim), \ + f'value shape[2] of {value.shape[2]} invalid, needs to be {self.vdim}.' + assert any(( + not self.value_as_static, self.value_as_static and value.shape[2] == self.pattern_dim, + self.disable_out_projection) + ), f'value shape[2] of {value.shape[2]} invalid, needs to be {self.pattern_dim}' + + out_weights, out_bias = None, None + if not self.disable_out_projection: + out_weights, out_bias = self.out_proj.weight, self.out_proj.bias + + if not self._qkv_same_embed_dim: + return hopfield_core_forward( + query=query, key=key, value=value, embed_dim_to_check=embed_dim_to_check, num_heads=self.num_heads, + in_proj_weight=self.in_proj_weight, in_proj_bias=self.in_proj_bias, bias_k=self.bias_k, + bias_v=self.bias_v, add_zero_attn=self.add_zero_attn, dropout_p=self.dropout, + out_proj_weight=out_weights, out_proj_bias=out_bias, training=self.training, + key_padding_mask=key_padding_mask, need_weights=need_weights, attn_mask=attn_mask, + use_separate_proj_weight=True, q_proj_weight=self.q_proj_weight, k_proj_weight=self.k_proj_weight, + v_proj_weight=self.v_proj_weight, + + key_as_static=self.key_as_static, query_as_static=self.query_as_static, + value_as_static=self.value_as_static, value_as_connected=self.value_as_connected, + normalize_pattern=self.normalize_pattern, + p_norm_weight=self.p_norm_weight, p_norm_bias=self.p_norm_bias, + head_dim=head_dim, pattern_dim=self.pattern_dim, scaling=scaling, + update_steps_max=update_steps_max, update_steps_eps=update_steps_eps, + return_raw_associations=return_raw_associations, return_projected_patterns=return_pattern_projections) + else: + return hopfield_core_forward( + query=query, key=key, value=value, embed_dim_to_check=embed_dim_to_check, num_heads=self.num_heads, + in_proj_weight=self.in_proj_weight, in_proj_bias=self.in_proj_bias, bias_k=self.bias_k, + bias_v=self.bias_v, add_zero_attn=self.add_zero_attn, dropout_p=self.dropout, + out_proj_weight=out_weights, out_proj_bias=out_bias, training=self.training, + key_padding_mask=key_padding_mask, need_weights=need_weights, attn_mask=attn_mask, + + key_as_static=self.key_as_static, query_as_static=self.query_as_static, + value_as_static=self.value_as_static, value_as_connected=self.value_as_connected, + normalize_pattern=self.normalize_pattern, + p_norm_weight=self.p_norm_weight, p_norm_bias=self.p_norm_bias, + head_dim=head_dim, pattern_dim=self.pattern_dim, scaling=scaling, + update_steps_max=update_steps_max, update_steps_eps=update_steps_eps, + return_raw_associations=return_raw_associations, return_projected_patterns=return_pattern_projections) diff --git a/src/mhnfs/hopfield/examples/latch_sequence/modules/functional.py b/src/mhnfs/hopfield/examples/latch_sequence/modules/functional.py new file mode 100644 index 0000000000000000000000000000000000000000..2619c45fd87dc5f0348db393aa9b305611b4dd32 --- /dev/null +++ b/src/mhnfs/hopfield/examples/latch_sequence/modules/functional.py @@ -0,0 +1,450 @@ +import torch +import torch.nn as nn + +from torch.tensor import Tensor +from typing import Optional, Tuple, Union + + +def hopfield_core_forward(query, # type: Tensor + key, # type: Tensor + value, # type: Tensor + embed_dim_to_check, # type: int + num_heads, # type: int + in_proj_weight, # type: Optional[Tensor] + in_proj_bias, # type: Optional[Tensor] + bias_k, # type: Optional[Tensor] + bias_v, # type: Optional[Tensor] + add_zero_attn, # type: bool + dropout_p, # type: float + out_proj_weight, # type: Tensor + out_proj_bias, # type: Tensor + training=True, # type: bool + key_padding_mask=None, # type: Optional[Tensor] + need_weights=True, # type: bool + attn_mask=None, # type: Optional[Tensor] + use_separate_proj_weight=False, # type: bool + q_proj_weight=None, # type: Optional[Tensor] + k_proj_weight=None, # type: Optional[Tensor] + v_proj_weight=None, # type: Optional[Tensor] + static_k=None, # type: Optional[Tensor] + static_v=None, # type: Optional[Tensor] + + key_as_static=False, # type: bool + query_as_static=False, # type: bool + value_as_static=False, # type: bool + value_as_connected=False, # type: bool + normalize_pattern=False, # type: bool + p_norm_weight=None, # type: Optional[Tensor] + p_norm_bias=None, # type: Optional[Tensor] + head_dim=None, # type: Optional[int] + pattern_dim=None, # type: Optional[int] + scaling=None, # type: Optional[Union[float, Tensor]] + update_steps_max=0, # type: Optional[Union[int, Tensor]] + update_steps_eps=1e-4, # type: Union[float, Tensor] + return_raw_associations=False, # type: bool + return_projected_patterns=False # type: bool + ): + # type: (...) -> Tuple[Tensor, Optional[Tensor]] + r""" + Args: + query, key, value: map a query and a set of key-value pairs to an output. + See "Attention Is All You Need" for more details. + See "Hopfield Networks is All You Need" for more details in the setting of Hopfield networks. + embed_dim_to_check: total dimension of the model (in case of default head dimension). + num_heads: parallel attention heads. + in_proj_weight, in_proj_bias: input projection weight and bias. + bias_k, bias_v: bias of the key and value sequences to be added at dim=0. + add_zero_attn: add a new batch of zeros to the key and + value sequences at dim=1. + dropout_p: probability of an element to be zeroed. + out_proj_weight, out_proj_bias: the output projection weight and bias. + training: apply dropout if is ``True``. + key_padding_mask: if provided, specified padding elements in the key will + be ignored by the attention. This is an binary mask. When the value is True, + the corresponding value on the attention layer will be filled with -inf. + need_weights: output attn_output_weights. + attn_mask: 2D or 3D mask that prevents attention to certain positions. A 2D mask will be broadcasted for all + the batches while a 3D mask allows to specify a different mask for the entries of each batch. + use_separate_proj_weight: the function accept the proj. weights for query, key, + and value in different forms. If false, in_proj_weight will be used, which is + a combination of q_proj_weight, k_proj_weight, v_proj_weight. + q_proj_weight, k_proj_weight, v_proj_weight, in_proj_bias: input projection weight and bias. + static_k, static_v: static key and value used for attention operators. + + key_as_static: interpret specified key as being static. + query_as_static: interpret specified key as being static. + value_as_static: interpret specified key as being static. + value_as_connected: connect value projection with key projection. + normalize_pattern: enable normalization of patterns. + p_norm_weight, p_norm_bias: pattern normalization weight and bias. + head_dim: dimensionality of each head. + pattern_dim: dimensionality of each projected value input. + scaling: scaling of association heads, often represented as beta (one entry per head). + update_steps_max: maximum count of association update steps (None equals to infinity). + update_steps_eps: minimum difference threshold between two consecutive association update steps. + return_raw_associations: return raw association (softmax) values, unmodified. + return_projected_patterns: return pattern projection values, unmodified. + + Shape: + Inputs: + - query: :math:`(L, N, E)` where L is the target sequence length, N is the batch size, E is + the embedding dimension. + - key: :math:`(S, N, E)`, where S is the source sequence length, N is the batch size, E is + the embedding dimension. + - value: :math:`(S, N, E)` where S is the source sequence length, N is the batch size, E is + the embedding dimension. + - key_padding_mask: :math:`(N, S)` where N is the batch size, S is the source sequence length. + If a ByteTensor is provided, the non-zero positions will be ignored while the zero positions + will be unchanged. If a BoolTensor is provided, the positions with the + value of ``True`` will be ignored while the position with the value of ``False`` will be unchanged. + - attn_mask: 2D mask :math:`(L, S)` where L is the target sequence length, S is the source sequence length. + 3D mask :math:`(N*num_heads, L, S)` where N is the batch size, L is the target sequence length, + S is the source sequence length. attn_mask ensures that position i is allowed to attend the unmasked + positions. If a ByteTensor is provided, the non-zero positions are not allowed to attend + while the zero positions will be unchanged. If a BoolTensor is provided, positions with ``True`` + are not allowed to attend while ``False`` values will be unchanged. If a FloatTensor + is provided, it will be added to the attention weight. + - static_k: :math:`(N*num_heads, S, head_dim)`, where S is the source sequence length, N is the batch size. + - static_v: :math:`(N*num_heads, S, head_dim)`, where S is the source sequence length, N is the batch size. + + - scaling: :math:`(num_heads,)`, where num_heads is the amount of heads. + + Outputs: + - attn_output: :math:`(L, N, E)`, where L is the target sequence length, N is the batch size, + E is the embedding dimension. + - attn_output_weights: :math:`(N, L, S)`, where N is the batch size, + L is the target sequence length, S is the source sequence length. + - attn_raw: :math:``(N, num_heads, L, S)`, where N is the batch size, + L is the target sequence length, S is the source sequence length. + """ + if not torch.jit.is_scripting(): + tens_ops = (query, key, value, in_proj_weight, in_proj_bias, bias_k, bias_v, + out_proj_weight, out_proj_bias) + if any([type(t) is not Tensor for t in tens_ops]) and nn.functional.has_torch_function(tens_ops): + return nn.functional.handle_torch_function( + hopfield_core_forward, tens_ops, query, key, value, + embed_dim_to_check, num_heads, in_proj_weight, in_proj_bias, + bias_k, bias_v, add_zero_attn, dropout_p, out_proj_weight, + out_proj_bias, training=training, key_padding_mask=key_padding_mask, + need_weights=need_weights, attn_mask=attn_mask, + use_separate_proj_weight=use_separate_proj_weight, + q_proj_weight=q_proj_weight, k_proj_weight=k_proj_weight, + v_proj_weight=v_proj_weight, static_k=static_k, static_v=static_v, + key_as_static=key_as_static, query_as_static=query_as_static, + value_as_static=value_as_static, value_as_connected=value_as_connected, + normalize_pattern=normalize_pattern, p_norm_weight=p_norm_weight, p_norm_bias=p_norm_bias, + head_dim=head_dim, pattern_dim=pattern_dim, scaling=scaling, update_steps_max=update_steps_max, + update_steps_eps=update_steps_eps, return_raw_associations=return_raw_associations) + tgt_len, bsz, embed_dim = query.shape[0], value.shape[1], query.shape[2] + assert embed_dim == embed_dim_to_check + # allow MHA to have different sizes for the feature dimension + assert key.size(0) == value.size(0) and key.size(1) == value.size(1) + + assert (scaling is None) or (type(scaling) in (float, torch.Tensor)) + if type(scaling) == torch.Tensor: + assert scaling.ndimension() == 1 and scaling.shape[0] == num_heads, "only one entry per head." + + assert (update_steps_max is None) or (type(update_steps_max) in (int, torch.Tensor)) + if type(update_steps_max) == torch.Tensor: + assert update_steps_max.ndimension() == 1 and update_steps_max.shape[0] == num_heads, "only one entry per head." + elif type(update_steps_max) == int: + update_steps_max = torch.tensor([update_steps_max] * num_heads, dtype=torch.int32, device=query.device) + elif update_steps_max is None: + update_steps_max = -torch.ones(size=(num_heads,), dtype=torch.int32, device=query.device) + + assert type(update_steps_eps) in (float, torch.Tensor) + if type(update_steps_eps) == torch.Tensor: + assert update_steps_eps.ndimension() == 1 and update_steps_eps.shape[0] == num_heads, "only one entry per head." + assert (update_steps_eps <= 0.0).sum() == 0, "only positive thresholds allowed." + update_steps_eps = update_steps_eps.to(device=query.device) + elif type(update_steps_eps) == float: + assert update_steps_eps > 0, "only positive thresholds allowed." + update_steps_eps = torch.tensor([update_steps_eps] * num_heads, dtype=query.dtype, device=query.device) + + # Adapt dimensionality of each each. + if head_dim is None: + head_dim = embed_dim // num_heads + assert head_dim * num_heads == embed_dim, r'embed_dim must be divisible by num_heads.' + hopfield_dim = num_heads * head_dim + + # Adapt dimensionality of each value projection. + if pattern_dim is None: + pattern_dim = head_dim + assert (not value_as_connected) or (pattern_dim == head_dim) + + q, k, v, xi, src_len = None, None, None, None, 0 + update_step, xi_old, xi_difference_norm = 0, None, float(r'+inf') + update_active_heads = torch.tensor([[[True]]] * num_heads * bsz, device=query.device) + assert update_active_heads.any(), "at least one head needs to be active." + + #################################################################################################################### + # BEGIN HOPFIELD UPDATE ITERATION # + #################################################################################################################### + + while update_active_heads.any(): + + # The query is already projected into the "Hopfield" space at "update_step" equals 0. + # No more projection necessary if "update_step" greater than 0. + if update_step == 0: + if not use_separate_proj_weight: + + if torch.equal(query, key) and torch.equal(key, value) and not ( + key_as_static or query_as_static or value_as_static): + # self-attention + q, k, v = nn.functional.linear(query, in_proj_weight, in_proj_bias).chunk(3, dim=-1) + + elif torch.equal(key, value) and not (key_as_static or value_as_static): + # encoder-decoder attention + _start, _end = 0, hopfield_dim + if query_as_static: + q = query.repeat(1, num_heads, 1) + else: + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + q = nn.functional.linear(query, _w, _b) + _start = hopfield_dim + _end = None + + if key is None: + assert value is None + k = None + v = None + else: + + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + k, v = nn.functional.linear(key, _w, _b).chunk(2, dim=-1) + + else: + _start, _end = 0, hopfield_dim + if query_as_static: + q = query.repeat(1, num_heads, 1) + else: + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + q = nn.functional.linear(query, _w, _b) + _start += hopfield_dim + _end += hopfield_dim + + if key_as_static: + k = key.repeat(1, num_heads, 1) + else: + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + k = nn.functional.linear(key, _w, _b) + _start += hopfield_dim + _end += hopfield_dim + + if value_as_static: + v = value.repeat(1, num_heads, 1) + else: + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + v = nn.functional.linear(value, _w, _b) + else: + _start, _end = 0, hopfield_dim + if query_as_static: + q = query.repeat(1, num_heads, 1) + else: + q_proj_weight_non_opt = torch.jit._unwrap_optional(q_proj_weight) + len1, len2 = q_proj_weight_non_opt.size() + assert len1 == hopfield_dim and len2 == query.size(-1) + if in_proj_bias is not None: + q = nn.functional.linear(query, q_proj_weight_non_opt, in_proj_bias[_start:_end]) + _start += hopfield_dim + _end += hopfield_dim + else: + q = nn.functional.linear(query, q_proj_weight_non_opt, in_proj_bias) + + v = value + if key_as_static: + k = key.repeat(1, num_heads, 1) + else: + k_proj_weight_non_opt = torch.jit._unwrap_optional(k_proj_weight) + len1, len2 = k_proj_weight_non_opt.size() + assert len1 == hopfield_dim and len2 == key.size(-1) + + _bias = None if in_proj_bias is None else in_proj_bias[_start:_end] + k = nn.functional.linear(key, k_proj_weight_non_opt, _bias) + if value_as_connected: + v = nn.functional.linear(v, k_proj_weight_non_opt, _bias) + _start += hopfield_dim + _end += num_heads * pattern_dim + + if value_as_static: + if not (value_as_connected or key_as_static): + v = v.repeat(1, num_heads, 1) + else: + v_proj_weight_non_opt = torch.jit._unwrap_optional(v_proj_weight) + len1, len2 = v_proj_weight_non_opt.size() + assert len1 == (num_heads * pattern_dim) and len2 == v.size(-1) + if in_proj_bias is not None: + v = nn.functional.linear(v, v_proj_weight_non_opt, in_proj_bias[_start:]) + else: + v = nn.functional.linear(v, v_proj_weight_non_opt, in_proj_bias) + + if attn_mask is not None: + assert attn_mask.dtype == torch.float32 or attn_mask.dtype == torch.float64 or \ + attn_mask.dtype == torch.float16 or attn_mask.dtype == torch.uint8 or \ + attn_mask.dtype == torch.bool, \ + 'Only float, byte, and bool types are supported for attn_mask, not {}'.format(attn_mask.dtype) + if attn_mask.dtype == torch.uint8: + warnings.warn( + "Byte tensor for attn_mask in nn.HopfieldCore is deprecated. Use bool tensor instead.") + attn_mask = attn_mask.to(torch.bool) + + if attn_mask.dim() == 2: + attn_mask = attn_mask.unsqueeze(0) + if list(attn_mask.size()) != [1, query.size(0), key.size(0)]: + raise RuntimeError('The size of the 2D attn_mask is not correct.') + elif attn_mask.dim() == 3: + if list(attn_mask.size()) != [bsz * num_heads, query.size(0), key.size(0)]: + raise RuntimeError('The size of the 3D attn_mask is not correct.') + else: + raise RuntimeError("attn_mask's dimension {} is not supported".format(attn_mask.dim())) + # attn_mask's dim is 3 now. + + # Optionally normalize patterns. + if normalize_pattern: + q = torch.nn.functional.layer_norm( + input=q.reshape(shape=(-1, head_dim)), normalized_shape=(head_dim,), + weight=p_norm_weight, bias=p_norm_bias).reshape(shape=q.shape) + k = torch.nn.functional.layer_norm( + input=k.reshape(shape=(-1, head_dim)), normalized_shape=(head_dim,), + weight=p_norm_weight, bias=p_norm_bias).reshape(shape=k.shape) + + else: + active_xi = xi.masked_select(mask=update_active_heads).view(size=(-1, *xi.shape[1:])) + active_k = k.masked_select(mask=update_active_heads).view(size=(-1, *k.shape[1:])) + q = torch.masked_scatter(input=q, mask=update_active_heads, source=torch.bmm(active_xi, active_k)) + + # Optionally scale association heads (each head separately). + if type(scaling) == float: + q = q * scaling + elif type(scaling) == torch.Tensor: + q = q * scaling.view(1, 1, -1).repeat(repeats=(1, 1, q.shape[2] // scaling.shape[0])) + + if update_step == 0: + # convert ByteTensor key_padding_mask to bool + if key_padding_mask is not None and key_padding_mask.dtype == torch.uint8: + warnings.warn( + "Byte tensor for key_padding_mask in nn.HopfieldCore is deprecated. Use bool tensor instead.") + key_padding_mask = key_padding_mask.to(torch.bool) + + if bias_k is not None and bias_v is not None: + if static_k is None and static_v is None and key_as_static is None and value_as_static is None: + k = torch.cat([k, bias_k.repeat(1, bsz, 1)]) + v = torch.cat([v, bias_v.repeat(1, bsz, 1)]) + if attn_mask is not None: + attn_mask = nn.functional.pad(attn_mask, [0, 1]) + if key_padding_mask is not None: + key_padding_mask = nn.functional.pad(key_padding_mask, [0, 1]) + else: + assert static_k is None, "bias cannot be added to static key." + assert static_v is None, "bias cannot be added to static value." + assert not key_as_static, "bias cannot be added to static key." + assert not value_as_static, "bias cannot be added to static value." + else: + assert bias_k is None + assert bias_v is None + + q = q.contiguous().view(tgt_len, -1, head_dim).transpose(0, 1) + if k is not None: + k = k.contiguous().view(-1, bsz * num_heads, head_dim).transpose(0, 1) + if v is not None: + v = v.contiguous().view(v.shape[0], bsz * num_heads, -1).transpose(0, 1) + + if static_k is not None: + assert static_k.size(0) == bsz * num_heads + assert static_k.size(2) == head_dim + k = static_k + + if static_v is not None: + assert static_v.size(0) == bsz * num_heads + assert static_v.size(2) == pattern_dim + v = static_v + + src_len = k.size(1) + + if key_padding_mask is not None: + assert key_padding_mask.size(0) == bsz + assert key_padding_mask.size(1) == src_len + + if add_zero_attn: + src_len += 1 + k = torch.cat([k, torch.zeros((k.size(0), 1) + k.size()[2:], dtype=k.dtype, device=k.device)], dim=1) + v = torch.cat([v, torch.zeros((v.size(0), 1) + v.size()[2:], dtype=v.dtype, device=v.device)], dim=1) + if attn_mask is not None: + attn_mask = nn.functional.pad(attn_mask, [0, 1]) + if key_padding_mask is not None: + key_padding_mask = nn.functional.pad(key_padding_mask, [0, 1]) + + attn_output_weights = torch.bmm(q, k.transpose(1, 2)) + assert list(attn_output_weights.size()) == [bsz * num_heads, tgt_len, src_len] + + if attn_mask is not None: + if attn_mask.dtype == torch.bool: + attn_output_weights.masked_fill_(attn_mask, float('-inf')) + else: + attn_output_weights += attn_mask + + if key_padding_mask is not None: + attn_output_weights = attn_output_weights.view(bsz, num_heads, tgt_len, src_len) + attn_output_weights = attn_output_weights.masked_fill( + key_padding_mask.unsqueeze(1).unsqueeze(2), + float('-inf'), + ) + attn_output_weights = attn_output_weights.view(bsz * num_heads, tgt_len, src_len) + + # Compute new xi for Hopfield retrieve iterations. + if xi is None: + xi = nn.functional.softmax(attn_output_weights, dim=-1) + else: + xi = torch.masked_scatter(input=xi, mask=update_active_heads, source=nn.functional.softmax( + attn_output_weights.masked_select(mask=update_active_heads).view(size=(-1, *xi.shape[1:])), dim=-1)) + + # Compute threshold-based stopping criterion for Hopfield retrieve iterations. + with torch.no_grad(): + xi_active = xi.view(size=(bsz, num_heads, tgt_len, src_len)) + update_active_heads = (update_step < update_steps_max) | (update_steps_max < 0) + if xi_old is not None: + update_active_heads &= ((xi_old - xi_active).norm(p=2, dim=(2, 3)).max(axis=0)[0]) > update_steps_eps + update_active_heads = update_active_heads.unsqueeze(dim=1).unsqueeze(dim=2).repeat(repeats=(bsz, 1, 1)) + xi_old = xi_active + update_step += 1 + + #################################################################################################################### + # END HOPFIELD UPDATE ITERATION # + #################################################################################################################### + + attn_output_weights = nn.functional.dropout(xi, p=dropout_p, training=training) + attn_output = torch.bmm(attn_output_weights, v) + assert list(attn_output.shape[:2]) == [bsz * num_heads, tgt_len] + attn_output = attn_output.transpose(0, 1).contiguous().view(tgt_len, bsz, -1) + if out_proj_weight is not None: + assert attn_output.shape[2] == num_heads * pattern_dim + attn_output = nn.functional.linear(attn_output, out_proj_weight, out_proj_bias) + + xi = xi.view(bsz, num_heads, tgt_len, src_len) if return_raw_associations else None + v = v.view(bsz, num_heads, src_len, -1) if return_projected_patterns else None + if need_weights: + # average attention weights over heads + attn_output_weights = attn_output_weights.view(bsz, num_heads, tgt_len, src_len) + return attn_output, attn_output_weights.sum(dim=1) / num_heads, xi, v + else: + return attn_output, None, xi, v diff --git a/src/mhnfs/hopfield/examples/latch_sequence/modules/transformer.py b/src/mhnfs/hopfield/examples/latch_sequence/modules/transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..884e0cb4b57610cf1daf8147f2c3d59f17824750 --- /dev/null +++ b/src/mhnfs/hopfield/examples/latch_sequence/modules/transformer.py @@ -0,0 +1,209 @@ +import torch +import torch.nn as nn + +from copy import deepcopy +from torch import Tensor +from torch.nn.modules import Module +from typing import Optional, Tuple, Union + +from . import Hopfield + + +class HopfieldEncoderLayer(Module): + """ + Module with underlying Hopfield association to be used as an encoder in transformer-like architectures. + """ + + def __init__(self, + hopfield_association: Hopfield, + dim_feedforward: int = 2048, + dropout: float = 0.1, + activation: str = r'relu' + ): + """ + Initialise a new instance of a Hopfield association-based encoder module. + + :param hopfield_association: instance of Hopfield association module + :param dim_feedforward: depth of the linear projections applied internally + :param activation: activation to be applied on the result of the internal linear projections + :param dropout: dropout probability to be applied internally + """ + super(HopfieldEncoderLayer, self).__init__() + self.hopfield_association = deepcopy(hopfield_association) + + self.linear_residual = nn.Linear(self.hopfield_association.state_pattern_dim, dim_feedforward) + self.dropout_residual = nn.Dropout(dropout) + self.linear_output = nn.Linear(dim_feedforward, self.hopfield_association.state_pattern_dim) + + self.norm_residual = nn.LayerNorm(self.hopfield_association.state_pattern_dim) + self.norm_output = nn.LayerNorm(self.hopfield_association.state_pattern_dim) + self.dropout_hopfield_association = nn.Dropout(dropout) + self.dropout_output = nn.Dropout(dropout) + + self.activation_residual = getattr(torch, activation, None) + assert self.activation_residual is not None, r'invalid activation function supplied.' + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset parameters, including Hopfield association. + + :return: None + """ + for module in (self.hopfield_association, self.linear_residual, + self.linear_output, self.norm_residual, self.norm_output): + if hasattr(module, r'reset_parameters'): + module.reset_parameters() + + def forward(self, src: Tensor, src_mask: Optional[Tensor] = None, + src_key_padding_mask: Optional[Tensor] = None) -> Tensor: + """ + Apply Hopfield encoding on specified data. + + :param src: data to be processed by Hopfield encoder module + :param src_mask: mask to be applied on association matrix + :param src_key_padding_mask: mask to be applied on stored patterns + :return: Hopfield-encoded input data + """ + data_associated = self.hopfield_association( + input=src, stored_pattern_padding_mask=src_key_padding_mask, association_mask=src_mask) + src = src + self.dropout_hopfield_association(input=data_associated) + src = self.norm_residual(input=src) + + result_residual_inner = self.activation_residual(input=self.linear_residual(input=src)) + data_associated = self.linear_output(input=self.dropout_residual(input=result_residual_inner)) + src = src + self.dropout_output(input=data_associated) + + return self.norm_output(input=src) + + def get_association_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]]) -> Tensor: + """ + Fetch Hopfield association matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :return: association matrix as computed by the Hopfield core module + """ + return self.hopfield_association.get_association_matrix(input=input) + + @property + def batch_first(self) -> int: + return self.hopfield_association.batch_first + + @property + def input_size(self) -> int: + return self.hopfield_association.input_size + + @property + def output_size(self) -> int: + return self.linear_output.out_features + + +class HopfieldDecoderLayer(Module): + + def __init__(self, + hopfield_association_self: Hopfield, + hopfield_association_cross: Hopfield, + dim_feedforward: int = 2048, + dropout: float = 0.1, + activation: str = r'relu' + ): + """ + Initialise a new instance of a Hopfield association-based encoder module. + + :param hopfield_association_self: instance of Hopfield self-association module + :param hopfield_association_cross: instance of Hopfield cross-association module + :param dim_feedforward: depth of the linear projections applied internally + :param dropout: dropout probability to be applied internally + :param activation: activation to be applied on the result of the internal linear projections + """ + super(HopfieldDecoderLayer, self).__init__() + self.hopfield_association_self = deepcopy(hopfield_association_self) + self.hopfield_association_cross = deepcopy(hopfield_association_cross) + + self.linear_residual = nn.Linear(self.hopfield_association_self.state_pattern_dim, dim_feedforward) + self.dropout_residual = nn.Dropout(dropout) + self.linear_output = nn.Linear(dim_feedforward, self.hopfield_association_self.state_pattern_dim) + + self.norm_residual_self = nn.LayerNorm(self.hopfield_association_self.state_pattern_dim) + self.norm_residual_cross = nn.LayerNorm(self.hopfield_association_self.state_pattern_dim) + self.norm_output = nn.LayerNorm(self.hopfield_association_self.state_pattern_dim) + self.dropout_hopfield_association_self = nn.Dropout(dropout) + self.dropout_hopfield_association_cross = nn.Dropout(dropout) + self.dropout_output = nn.Dropout(dropout) + + self.activation_residual = getattr(torch, activation, None) + assert self.activation_residual is not None, r'invalid activation function supplied.' + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset parameters, including Hopfield association. + + :return: None + """ + for module in (self.hopfield_association_self, self.hopfield_association_cross, + self.linear_residual, self.linear_output, self.norm_residual_self, + self.norm_residual_cross, self.norm_output): + if hasattr(module, r'reset_parameters'): + module.reset_parameters() + + def forward(self, tgt: Tensor, memory: Tensor, tgt_mask: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, tgt_key_padding_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None) -> Tensor: + """ + Apply Hopfield decoding on specified data. + + :param tgt: data to be processed by Hopfield decoder module (self-association) + :param memory: data to be processed by Hopfield encoder module (cross-association) + :param tgt_mask: mask to be applied on self-association matrix + :param memory_mask: mask to be applied on cross-association matrix + :param tgt_key_padding_mask: mask to be applied on stored patterns + :param memory_key_padding_mask: mask to be applied on state patterns as well as pattern projection + :return: Hopfield-decoded input + """ + data_associated = self.hopfield_association_self( + input=tgt, stored_pattern_padding_mask=tgt_key_padding_mask, + association_mask=tgt_mask) + tgt = tgt + self.dropout_hopfield_association_self(input=data_associated) + tgt = self.norm_residual_self(input=tgt) + + data_associated = self.hopfield_association_cross( + input=(memory, tgt, memory), stored_pattern_padding_mask=memory_key_padding_mask, + association_mask=memory_mask) + tgt = tgt + self.dropout_hopfield_association_cross(input=data_associated) + tgt = self.norm_residual_cross(input=tgt) + + result_residual_inner = self.activation_residual(input=self.linear_residual(input=tgt)) + data_associated = self.linear_output(input=self.dropout_residual(input=result_residual_inner)) + tgt = tgt + self.dropout_output(input=data_associated) + return self.norm_output(input=tgt) + + def get_association_matrix_self(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]]) -> Tensor: + """ + Fetch Hopfield self-association matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :return: association matrix as computed by the Hopfield core module + """ + return self.hopfield_association_self.get_association_matrix(input=input) + + def get_association_matrix_cross(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]]) -> Tensor: + """ + Fetch Hopfield cross-association matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :return: association matrix as computed by the Hopfield core module + """ + return self.hopfield_association_cross.get_association_matrix(input=input) + + @property + def batch_first(self) -> int: + return self.hopfield_association_self.batch_first + + @property + def input_size(self) -> int: + return self.hopfield_association_self.input_size + + @property + def output_size(self) -> int: + return self.linear_output_self.out_features diff --git a/src/mhnfs/hopfield/examples/latch_sequence/resources/hopfield_adapted.pdf b/src/mhnfs/hopfield/examples/latch_sequence/resources/hopfield_adapted.pdf new file mode 100644 index 0000000000000000000000000000000000000000..a372354c143235492963af3c030fe9e57ef52384 Binary files /dev/null and b/src/mhnfs/hopfield/examples/latch_sequence/resources/hopfield_adapted.pdf differ diff --git a/src/mhnfs/hopfield/examples/latch_sequence/resources/hopfield_base.pdf b/src/mhnfs/hopfield/examples/latch_sequence/resources/hopfield_base.pdf new file mode 100644 index 0000000000000000000000000000000000000000..d79776dad1aaa8521d5e262da58b10a72729f9ec Binary files /dev/null and b/src/mhnfs/hopfield/examples/latch_sequence/resources/hopfield_base.pdf differ diff --git a/src/mhnfs/hopfield/examples/latch_sequence/resources/hopfield_lookup.pdf b/src/mhnfs/hopfield/examples/latch_sequence/resources/hopfield_lookup.pdf new file mode 100644 index 0000000000000000000000000000000000000000..7d77e71d3d435bb1c7f2cba80325f3568351c5ca Binary files /dev/null and b/src/mhnfs/hopfield/examples/latch_sequence/resources/hopfield_lookup.pdf differ diff --git a/src/mhnfs/hopfield/examples/latch_sequence/resources/hopfield_lookup_adapted.pdf b/src/mhnfs/hopfield/examples/latch_sequence/resources/hopfield_lookup_adapted.pdf new file mode 100644 index 0000000000000000000000000000000000000000..4311173d107115696730da2a301f5214834bf6c0 Binary files /dev/null and b/src/mhnfs/hopfield/examples/latch_sequence/resources/hopfield_lookup_adapted.pdf differ diff --git a/src/mhnfs/hopfield/examples/latch_sequence/resources/hopfield_pooling.pdf b/src/mhnfs/hopfield/examples/latch_sequence/resources/hopfield_pooling.pdf new file mode 100644 index 0000000000000000000000000000000000000000..0b6a6629bd3338c42b73d976bfcb60464ffb6387 Binary files /dev/null and b/src/mhnfs/hopfield/examples/latch_sequence/resources/hopfield_pooling.pdf differ diff --git a/src/mhnfs/hopfield/examples/latch_sequence/resources/hopfield_pooling_adapted.pdf b/src/mhnfs/hopfield/examples/latch_sequence/resources/hopfield_pooling_adapted.pdf new file mode 100644 index 0000000000000000000000000000000000000000..42603ab847c67dd4ab644a2b39a593f034f3a539 Binary files /dev/null and b/src/mhnfs/hopfield/examples/latch_sequence/resources/hopfield_pooling_adapted.pdf differ diff --git a/src/mhnfs/hopfield/examples/latch_sequence/resources/lstm_base.pdf b/src/mhnfs/hopfield/examples/latch_sequence/resources/lstm_base.pdf new file mode 100644 index 0000000000000000000000000000000000000000..b04c2d77f5af97d116474bc74fb32d37a8766f78 Binary files /dev/null and b/src/mhnfs/hopfield/examples/latch_sequence/resources/lstm_base.pdf differ diff --git a/src/mhnfs/hopfield/examples/mnist_bags/LICENSE b/src/mhnfs/hopfield/examples/mnist_bags/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..236fb4bb131d2ac5692a0f8bd71c54d2b8c3f002 --- /dev/null +++ b/src/mhnfs/hopfield/examples/mnist_bags/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 Maximilian Ilse and Jakub Tomczak + +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. \ No newline at end of file diff --git a/src/mhnfs/hopfield/examples/mnist_bags/README.md b/src/mhnfs/hopfield/examples/mnist_bags/README.md new file mode 100644 index 0000000000000000000000000000000000000000..27f0e35170dd51bd7f6ebf6ee18cb5e396bfe776 --- /dev/null +++ b/src/mhnfs/hopfield/examples/mnist_bags/README.md @@ -0,0 +1,28 @@ +# Application of Hopfield-based pooling on Attention-based Deep Multiple Instance Learning + +This notebook demonstrates how to apply the Hopfield pooling layer. +It is based on the PyTorch implementation of the paper [Attention-based Deep Multiple Instance Learning](https://github.com/AMLab-Amsterdam/AttentionDeepMIL) by +* Ilse, M., Tomczak, J. M., & Welling, M. (2018). Attention-based Deep Multiple Instance Learning. [arXiv preprint arXiv:1802.04712](https://arxiv.org/pdf/1802.04712.pdf). + + +## Installation +Download the PyTorch code of Attention-based Deep Multiple Instance Learning (ADMIL) from the accompanying [repository](https://github.com/AMLab-Amsterdam/AttentionDeepMIL) into a directory AttentionDeepMIL on the current directory level ([examples/mnist_bags](.)). Afterwards, line 60 of the file [model.py](https://github.com/AMLab-Amsterdam/AttentionDeepMIL/blob/master/model.py#L60) of this repository needs to be modified. Change +```python +error = 1. - Y_hat.eq(Y).cpu().float().mean().data[0] +``` +to +```python +error = 1. - Y_hat.eq(Y).cpu().float().mean().item() +``` + +Cell 5 specifies the parameters defining the data set properties, whereas cell 15 defines the Hopfield-based pooling network. As a last step, run the notebook. + + +## Note +* The neural network with Hopfield-based pooling, implemented in cell 15 of the [mnist_bags_demo.ipynb](mnist_bags_demo.ipynb) notebook is based on the models proposed in [ADMIL](https://github.com/AMLab-Amsterdam/AttentionDeepMIL). + +* The code in the [mnist_bags_demo.ipynb](mnist_bags_demo.ipynb) notebook is based on the [main.py](https://github.com/AMLab-Amsterdam/AttentionDeepMIL/blob/master/main.py) file from ADMIL. + + +## Disclaimer +The purpose of this notebook is merely to demonstrate how to use HopfieldPooling layer. In no way it is intended as a comparison of the methods. diff --git a/src/mhnfs/hopfield/examples/mnist_bags/mnist_bags_demo.ipynb b/src/mhnfs/hopfield/examples/mnist_bags/mnist_bags_demo.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..eb7996e2b392511f8501d753d3d1e2a770adb0b5 --- /dev/null +++ b/src/mhnfs/hopfield/examples/mnist_bags/mnist_bags_demo.ipynb @@ -0,0 +1,736 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Example: Attention-based Deep Multiple Instance Learning

" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Import general modules used for e.g. plotting.\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import os\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import sys\n", + "import torch\n", + "\n", + "# Import Hopfield-specific modules.\n", + "from modules import HopfieldPooling\n", + "\n", + "# Import auxiliary modules.\n", + "from distutils.version import LooseVersion\n", + "from typing import Optional, Tuple\n", + "\n", + "# Importing PyTorch specific modules.\n", + "from torch import Tensor\n", + "from torch.autograd import Variable\n", + "from torch.nn import Conv2d, Dropout, Linear, MaxPool2d, Module, ReLU, Sequential, Sigmoid\n", + "from torch.nn.utils import clip_grad_norm_\n", + "from torch.optim import AdamW\n", + "from torch.utils.data import DataLoader\n", + "\n", + "# Set plotting style.\n", + "sns.set()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Append the path of the Attention-based Deep Multiple Instance Learning (ADMIL) repository to the system path in order for Python to find the corresponding modules to import." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "sys.path.append(r'./AttentionDeepMIL')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Afterwards, the corresponding modules\n", + "- MnistBags\n", + "- Attention\n", + "- GatedAttention\n", + "\n", + "are imported to the global namespace." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from dataloader import MnistBags\n", + "from model import Attention, GatedAttention" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Specific minimum versions of Python itself as well as of some used modules is required." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Installed Python version: 3.8.8 (βœ“)\n", + "Installed PyTorch version: 1.7.0 (βœ“)\n" + ] + } + ], + "source": [ + "python_check = '(\\u2713)' if sys.version_info >= (3, 8) else '(\\u2717)'\n", + "pytorch_check = '(\\u2713)' if torch.__version__ >= LooseVersion(r'1.5') else '(\\u2717)'\n", + "\n", + "print(f'Installed Python version: {sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro} {python_check}')\n", + "print(f'Installed PyTorch version: {torch.__version__} {pytorch_check}')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "

Create Dataset

\n", + "\n", + "The dataset itself falls into the category of binary classification tasks in the domain of Multiple Instance Learning (MIL) problems.\n", + "The MNIST-bags task was introcuded by Ilse and Tomczak:
\n", + "Ilse, M., Tomczak, J.M. and Welling, M., 2018. Attention-based deep multiple instance learning. arXiv preprint arXiv:1802.04712.

\n", + "Each bag comprises a collection of $28\\times{}28$ grayscale images/instances, whereas each instance is a sequence of pixel values in the range of $[0; 255]$. The amount of instances per pag is drawn from a Gaussian with specified mean and variance. The positive class is defined by the presence of the target number/digit, whereas the negative one by its absence. This demonstration shows, that HopfieldPooling is capable of learning and filtering each bag with respect to the class-defining target number/digit. Defining arguments are:\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ArgumentValue (used in this demo)Description
target_number9Target number/digit defining class affiliation.
mean_bag_length10Mean amount of instances per bag.
var_bag_length2Variance of amount of instances per bag.
num_bag{200; 50}Amount of samples of the training as well as validation set.
\n", + "\n", + "Let's define the dataset using previously mentioned properties as well as a logging directory for storing all auxiliary outputs like performance plots." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device(r'cuda:0' if torch.cuda.is_available() else r'cpu')\n", + "\n", + "# Create data loader of training set.\n", + "data_loader_train = DataLoader(MnistBags(\n", + " target_number=9,\n", + " mean_bag_length=10,\n", + " var_bag_length=2,\n", + " num_bag=200,\n", + " train=True\n", + "), batch_size=1, shuffle=True)\n", + "\n", + "# Create data loader of validation set.\n", + "data_loader_eval = DataLoader(MnistBags(\n", + " target_number=9,\n", + " mean_bag_length=10,\n", + " var_bag_length=2,\n", + " num_bag=50,\n", + " train=False\n", + "), batch_size=1, shuffle=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "log_dir = f'resources/'\n", + "os.makedirs(log_dir, exist_ok=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "

Create Auxiliaries

\n", + "\n", + "Before digging into Hopfield-based networks, a few auxiliary variables and functions need to be defined. This is nothing special with respect to Hopfield-based networks, but rather common preparation work of (almost) every machine learning setting (e.g. definition of a data loader as well as a training loop). We will see, that this comprises the most work of this whole demo." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def train_epoch(network: Module,\n", + " optimiser: AdamW,\n", + " data_loader: DataLoader\n", + " ) -> Tuple[float, float, float]:\n", + " \"\"\"\n", + " Execute one training epoch.\n", + " \n", + " :param network: network instance to train\n", + " :param optimiser: optimiser instance responsible for updating network parameters\n", + " :param data_loader: data loader instance providing training data\n", + " :return: tuple comprising training loss, training error as well as accuracy\n", + " \"\"\"\n", + " network.train()\n", + " losses, errors, accuracies = [], [], []\n", + " for data, target in data_loader:\n", + " data, target = data.to(device=device), target[0].to(device=device)\n", + "\n", + " # Process data by Hopfield-based network.\n", + " loss = network.calculate_objective(data, target)[0]\n", + "\n", + " # Update network parameters.\n", + " optimiser.zero_grad()\n", + " loss.backward()\n", + " clip_grad_norm_(parameters=network.parameters(), max_norm=1.0, norm_type=2)\n", + " optimiser.step()\n", + "\n", + " # Compute performance measures of current model.\n", + " error, prediction = network.calculate_classification_error(data, target)\n", + " accuracy = (prediction == target).to(dtype=torch.float32).mean()\n", + " accuracies.append(accuracy.detach().item())\n", + " errors.append(error)\n", + " losses.append(loss.detach().item())\n", + " \n", + " # Report progress of training procedure.\n", + " return sum(losses) / len(losses), sum(errors) / len(errors), sum(accuracies) / len(accuracies)\n", + "\n", + "\n", + "def eval_iter(network: Module,\n", + " data_loader: DataLoader\n", + " ) -> Tuple[float, float, float]:\n", + " \"\"\"\n", + " Evaluate the current model.\n", + " \n", + " :param network: network instance to evaluate\n", + " :param data_loader: data loader instance providing validation data\n", + " :return: tuple comprising validation loss, validation error as well as accuracy\n", + " \"\"\"\n", + " network.eval()\n", + " with torch.no_grad():\n", + " losses, errors, accuracies = [], [], []\n", + " for data, target in data_loader:\n", + " data, target = data.to(device=device), target[0].to(device=device)\n", + "\n", + " # Process data by Hopfield-based network.\n", + " loss = network.calculate_objective(data, target)[0]\n", + "\n", + " # Compute performance measures of current model.\n", + " error, prediction = network.calculate_classification_error(data, target)\n", + " accuracy = (prediction == target).to(dtype=torch.float32).mean()\n", + " accuracies.append(accuracy.detach().item())\n", + " errors.append(error)\n", + " losses.append(loss.detach().item())\n", + "\n", + " # Report progress of validation procedure.\n", + " return sum(losses) / len(losses), sum(errors) / len(errors), sum(accuracies) / len(accuracies)\n", + "\n", + " \n", + "def operate(network: Module,\n", + " optimiser: AdamW,\n", + " data_loader_train: DataLoader,\n", + " data_loader_eval: DataLoader,\n", + " num_epochs: int = 1\n", + " ) -> Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:\n", + " \"\"\"\n", + " Train the specified network by gradient descent using backpropagation.\n", + " \n", + " :param network: network instance to train\n", + " :param optimiser: optimiser instance responsible for updating network parameters\n", + " :param data_loader_train: data loader instance providing training data\n", + " :param data_loader_eval: data loader instance providing validation data\n", + " :param num_epochs: amount of epochs to train\n", + " :return: data frame comprising training as well as evaluation performance\n", + " \"\"\"\n", + " losses, errors, accuracies = {r'train': [], r'eval': []}, {r'train': [], r'eval': []}, {r'train': [], r'eval': []}\n", + " for epoch in range(num_epochs):\n", + " \n", + " # Train network.\n", + " performance = train_epoch(network, optimiser, data_loader_train)\n", + " losses[r'train'].append(performance[0])\n", + " errors[r'train'].append(performance[1])\n", + " accuracies[r'train'].append(performance[2])\n", + " \n", + " # Evaluate current model.\n", + " performance = eval_iter(network, data_loader_eval)\n", + " losses[r'eval'].append(performance[0])\n", + " errors[r'eval'].append(performance[1])\n", + " accuracies[r'eval'].append(performance[2])\n", + " \n", + " # Report progress of training and validation procedures.\n", + " return pd.DataFrame(losses), pd.DataFrame(errors), pd.DataFrame(accuracies)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def set_seed(seed: int = 42) -> None:\n", + " \"\"\"\n", + " Set seed for all underlying (pseudo) random number sources.\n", + " \n", + " :param seed: seed to be used\n", + " :return: None\n", + " \"\"\"\n", + " torch.manual_seed(42)\n", + " torch.backends.cudnn.deterministic = True\n", + " torch.backends.cudnn.benchmark = False\n", + "\n", + "\n", + "def plot_performance(loss: pd.DataFrame,\n", + " error: pd.DataFrame,\n", + " accuracy: pd.DataFrame,\n", + " log_file: str\n", + " ) -> None:\n", + " \"\"\"\n", + " Plot and save loss and accuracy.\n", + " \n", + " :param loss: loss to be plotted\n", + " :param error: error to be plotted\n", + " :param accuracy: accuracy to be plotted\n", + " :param log_file: target file for storing the resulting plot\n", + " :return: None\n", + " \"\"\"\n", + " fig, ax = plt.subplots(1, 3, figsize=(20, 7))\n", + " \n", + " loss_plot = sns.lineplot(data=loss, ax=ax[0])\n", + " loss_plot.set(xlabel=r'Epoch', ylabel=r'Loss')\n", + " \n", + " error_plot = sns.lineplot(data=error, ax=ax[1])\n", + " error_plot.set(xlabel=r'Epoch', ylabel=r'Error')\n", + " \n", + " accuracy_plot = sns.lineplot(data=accuracy, ax=ax[2])\n", + " accuracy_plot.set(xlabel=r'Epoch', ylabel=r'Accuracy')\n", + " \n", + " fig.tight_layout()\n", + " fig.savefig(log_file)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Attention-based Network

" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "set_seed()\n", + "network = Attention().to(device=device)\n", + "optimiser = AdamW(params=network.parameters(), lr=5e-4, weight_decay=1e-4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Operate Attention-based Network

" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "losses, errors, accuracies = operate(\n", + " network=network,\n", + " optimiser=optimiser,\n", + " data_loader_train=data_loader_train,\n", + " data_loader_eval=data_loader_eval,\n", + " num_epochs=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance(loss=losses, error=errors, accuracy=accuracies, log_file=f'{log_dir}/attention_base.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

GatedAttention-based Network

" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "set_seed()\n", + "network = GatedAttention().to(device=device)\n", + "optimiser = AdamW(params=network.parameters(), lr=5e-4, weight_decay=1e-4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Operate GatedAttention-based Network

" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "losses, errors, accuracies = operate(\n", + " network=network,\n", + " optimiser=optimiser,\n", + " data_loader_train=data_loader_train,\n", + " data_loader_eval=data_loader_eval,\n", + " num_epochs=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance(loss=losses, error=errors, accuracy=accuracies, log_file=f'{log_dir}/gated_attention_base.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Hopfield-based Pooling

" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "class HfPooling(Module): \n", + " def __init__(self):\n", + " \"\"\"\n", + " Initialize a new instance of a Hopfield-based pooling network.\n", + " \n", + " Note: all hyperparameters of the network are fixed for demonstration purposes.\n", + " Morevover, most of the notation of the original implementation is kept in order\n", + " to be easier comparable (partially ignoring PEP8).\n", + " \"\"\"\n", + " super(HfPooling, self).__init__()\n", + " self.L = 500\n", + " self.D = 128\n", + " self.K = 1\n", + "\n", + " self.feature_extractor_part1 = Sequential(\n", + " Conv2d(1, 20, kernel_size=5),\n", + " ReLU(),\n", + " MaxPool2d(2, stride=2),\n", + " Conv2d(20, 50, kernel_size=5),\n", + " ReLU(),\n", + " MaxPool2d(2, stride=2)\n", + " )\n", + " self.feature_extractor_part2 = Sequential(\n", + " Linear(50 * 4 * 4, self.L),\n", + " ReLU(),\n", + " )\n", + " self.hopfield_pooling = HopfieldPooling(\n", + " input_size=self.L, hidden_size=32, output_size=self.L, num_heads=1\n", + " )\n", + " self.dp = Dropout(\n", + " p=0.1\n", + " )\n", + " self.classifier = Sequential(\n", + " Linear(self.L * self.K, 1),\n", + " Sigmoid()\n", + " )\n", + " \n", + " def forward(self, input: Tensor) -> Tuple[Tensor, Tensor, Optional[Tensor]]:\n", + " \"\"\"\n", + " Compute result of Hopfield-based pooling network on specified data.\n", + " \n", + " :param input: data to be processed by the Hopfield-based pooling network\n", + " :return: result as computed by the Hopfield-based pooling network\n", + " \"\"\"\n", + " x = input.squeeze(0)\n", + " H = self.feature_extractor_part1(x)\n", + " H = H.view(-1, 50 * 4 * 4)\n", + " H = self.feature_extractor_part2(H)\n", + " \n", + " H = H.unsqueeze(0)\n", + " H = self.hopfield_pooling(H)\n", + " H = H.squeeze(0)\n", + " H = self.dp(H)\n", + "\n", + " Y_prob = self.classifier(H)\n", + " Y_hat = torch.ge(Y_prob, 0.5).float()\n", + "\n", + " return Y_prob, Y_hat, None\n", + "\n", + " def calculate_classification_error(self, input: Tensor, target: Tensor) -> Tuple[Tensor, Tensor]:\n", + " \"\"\"\n", + " Compute classification error of current model.\n", + " \n", + " :param input: data to be processed by the Hopfield-based pooling network\n", + " :param target: target to be used to compute the classification error of the current model\n", + " :return: classification error as well as predicted class\n", + " \"\"\"\n", + " Y = target.float()\n", + " _, Y_hat, _ = self.forward(input)\n", + " error = 1.0 - Y_hat.eq(Y).cpu().float().mean().item()\n", + "\n", + " return error, Y_hat\n", + "\n", + " def calculate_objective(self, input: Tensor, target: Tensor) -> Tuple[Tensor, Optional[Tensor]]:\n", + " \"\"\"\n", + " Compute objective of the current model.\n", + " \n", + " :param input: data to be processed by the Hopfield-based pooling network\n", + " :param target: target to be used to compute the objective of the current model\n", + " :return: objective as well as dummy A (see accompanying paper for more information)\n", + " \"\"\"\n", + " Y = target.float()\n", + " Y_prob, _, A = self.forward(input)\n", + " Y_prob = torch.clamp(Y_prob, min=1e-5, max=(1.0 - 1e-5))\n", + " neg_log_likelihood = -1.0 * (Y * torch.log(Y_prob) + (1.0 - Y) * torch.log(1.0 - Y_prob))\n", + "\n", + " return neg_log_likelihood, A" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "set_seed()\n", + "network = HfPooling().to(device=device)\n", + "optimiser = AdamW(params=network.parameters(), lr=5e-4, weight_decay=1e-4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Operate HopfieldPooling-based Network

" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "losses, errors, accuracies = operate(\n", + " network=network,\n", + " optimiser=optimiser,\n", + " data_loader_train=data_loader_train,\n", + " data_loader_eval=data_loader_eval,\n", + " num_epochs=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance(loss=losses, error=errors, accuracy=accuracies, log_file=f'{log_dir}/hopfield_pooling.pdf')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/src/mhnfs/hopfield/examples/mnist_bags/modules/__init__.py b/src/mhnfs/hopfield/examples/mnist_bags/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c11713739acb1aca3b32cca53acf0c3faf1fa9f6 --- /dev/null +++ b/src/mhnfs/hopfield/examples/mnist_bags/modules/__init__.py @@ -0,0 +1,898 @@ +import torch +import torch.nn as nn + +from math import sqrt +from torch import Tensor +from torch.nn import Module, Parameter +from typing import Optional, Tuple, Union + +from .activation import HopfieldCore + + +class Hopfield(Module): + """ + Module with underlying Hopfield association. + """ + + def __init__(self, + input_size: Optional[int] = None, + hidden_size: Optional[int] = None, + output_size: Optional[int] = None, + pattern_size: Optional[int] = None, + num_heads: int = 1, + scaling: Optional[Union[float, Tensor]] = None, + update_steps_max: Optional[Union[int, Tensor]] = 0, + update_steps_eps: Union[float, Tensor] = 1e-4, + + normalize_stored_pattern: bool = True, + normalize_stored_pattern_affine: bool = True, + normalize_state_pattern: bool = True, + normalize_state_pattern_affine: bool = True, + normalize_pattern_projection: bool = True, + normalize_pattern_projection_affine: bool = True, + normalize_hopfield_space: bool = False, + normalize_hopfield_space_affine: bool = False, + stored_pattern_as_static: bool = False, + state_pattern_as_static: bool = False, + pattern_projection_as_static: bool = False, + pattern_projection_as_connected: bool = False, + stored_pattern_size: Optional[int] = None, + pattern_projection_size: Optional[int] = None, + + batch_first: bool = True, + association_activation: Optional[str] = None, + dropout: float = 0.0, + input_bias: bool = True, + concat_bias_pattern: bool = False, + add_zero_association: bool = False, + disable_out_projection: bool = False + ): + """ + Initialise new instance of a Hopfield module. + + :param input_size: depth of the input (state pattern) + :param hidden_size: depth of the association space + :param output_size: depth of the output projection + :param pattern_size: depth of patterns to be selected + :param num_heads: amount of parallel association heads + :param scaling: scaling of association heads, often represented as beta (one entry per head) + :param update_steps_max: maximum count of association update steps (None equals to infinity) + :param update_steps_eps: minimum difference threshold between two consecutive association update steps + :param normalize_stored_pattern: apply normalization on stored patterns + :param normalize_stored_pattern_affine: additionally enable affine normalization of stored patterns + :param normalize_state_pattern: apply normalization on state patterns + :param normalize_state_pattern_affine: additionally enable affine normalization of state patterns + :param normalize_pattern_projection: apply normalization on the pattern projection + :param normalize_pattern_projection_affine: additionally enable affine normalization of pattern projection + :param normalize_hopfield_space: enable normalization of patterns in the Hopfield space + :param normalize_hopfield_space_affine: additionally enable affine normalization of patterns in Hopfield space + :param stored_pattern_as_static: interpret specified stored patterns as being static + :param state_pattern_as_static: interpret specified state patterns as being static + :param pattern_projection_as_static: interpret specified pattern projections as being static + :param pattern_projection_as_connected: connect pattern projection with stored pattern + :param stored_pattern_size: depth of input (stored pattern) + :param pattern_projection_size: depth of input (pattern projection) + :param batch_first: flag for specifying if the first dimension of data fed to "forward" reflects the batch size + :param association_activation: additional activation to be applied on the result of the Hopfield association + :param dropout: dropout probability applied on the association matrix + :param input_bias: bias to be added to input (state and stored pattern as well as pattern projection) + :param concat_bias_pattern: bias to be concatenated to stored pattern as well as pattern projection + :param add_zero_association: add a new batch of zeros to stored pattern as well as pattern projection + :param disable_out_projection: disable output projection + """ + super(Hopfield, self).__init__() + assert type(batch_first) == bool, f'"batch_first" needs to be a boolean, not {type(batch_first)}.' + assert (association_activation is None) or (type(association_activation) == str) + + # Initialise Hopfield association module. + self.association_core = HopfieldCore( + embed_dim=input_size, num_heads=num_heads, dropout=dropout, bias=input_bias, + add_bias_kv=concat_bias_pattern, add_zero_attn=add_zero_association, kdim=stored_pattern_size, + vdim=pattern_projection_size, head_dim=hidden_size, pattern_dim=pattern_size, out_dim=output_size, + disable_out_projection=disable_out_projection, key_as_static=stored_pattern_as_static, + query_as_static=state_pattern_as_static, value_as_static=pattern_projection_as_static, + value_as_connected=pattern_projection_as_connected, normalize_pattern=normalize_hopfield_space, + normalize_pattern_affine=normalize_hopfield_space_affine) + self.association_activation = None + if association_activation is not None: + self.association_activation = getattr(torch, association_activation, None) + + # Initialise stored pattern normalization. + self.norm_stored_pattern = None + if normalize_stored_pattern_affine: + assert normalize_stored_pattern, "affine normalization without normalization has no effect." + if normalize_stored_pattern: + normalized_shape = input_size if stored_pattern_size is None else stored_pattern_size + assert normalized_shape is not None, "stored pattern size required for setting up normalisation" + self.norm_stored_pattern = nn.LayerNorm( + normalized_shape=normalized_shape, elementwise_affine=normalize_stored_pattern_affine) + + # Initialise state pattern normalization. + self.norm_state_pattern = None + if normalize_state_pattern_affine: + assert normalize_state_pattern, "affine normalization without normalization has no effect." + if normalize_state_pattern: + assert input_size is not None, "input size required for setting up normalisation" + self.norm_state_pattern = nn.LayerNorm( + normalized_shape=input_size, elementwise_affine=normalize_state_pattern_affine) + + # Initialise pattern projection normalization. + self.norm_pattern_projection = None + if normalize_pattern_projection_affine: + assert normalize_pattern_projection, "affine normalization without normalization has no effect." + if normalize_pattern_projection: + normalized_shape = input_size if pattern_projection_size is None else pattern_projection_size + assert normalized_shape is not None, "pattern projection size required for setting up normalisation" + self.norm_pattern_projection = nn.LayerNorm( + normalized_shape=normalized_shape, elementwise_affine=normalize_pattern_projection_affine) + + # Initialise remaining auxiliary properties. + if self.association_core.static_execution: + self.__scaling = 1.0 if scaling is None else scaling + else: + assert self.association_core.head_dim > 0, f'invalid hidden dimension encountered.' + self.__scaling = (1.0 / sqrt(self.association_core.head_dim)) if scaling is None else scaling + self.__batch_first = batch_first + self.__update_steps_max = update_steps_max + self.__update_steps_eps = update_steps_eps + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset Hopfield association. + + :return: None + """ + for module in (self.association_core, self.norm_stored_pattern, + self.norm_state_pattern, self.norm_pattern_projection): + if hasattr(module, r'reset_parameters'): + module.reset_parameters() + + def _maybe_transpose(self, *args: Tuple[Tensor, ...]) -> Union[Tensor, Tuple[Tensor, ...]]: + """ + Eventually transpose specified data. + + :param args: tensors to eventually transpose (dependent on the state of "batch_first") + :return: eventually transposed tensors + """ + transposed_result = tuple(_.transpose(0, 1) for _ in args) if self.__batch_first else args + return transposed_result[0] if len(transposed_result) == 1 else transposed_result + + def _associate(self, data: Union[Tensor, Tuple[Tensor, Tensor, Tensor]], + return_raw_associations: bool = False, return_projected_patterns: bool = False, + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tuple[Optional[Tensor], ...]: + """ + Apply Hopfield association module on specified data. + + :param data: data to be processed by Hopfield core module + :param return_raw_associations: return raw association (softmax) values, unmodified + :param return_projected_patterns: return pattern projection values, unmodified + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: Hopfield-processed input data + """ + assert (type(data) == Tensor) or ((type(data) == tuple) and (len(data) == 3)), \ + r'either one tensor to be used as "stored pattern", "state pattern" and' \ + r' "pattern_projection" must be provided, or three separate ones.' + if type(data) == Tensor: + stored_pattern, state_pattern, pattern_projection = data, data, data + else: + stored_pattern, state_pattern, pattern_projection = data + + # Optionally transpose data. + stored_pattern, state_pattern, pattern_projection = self._maybe_transpose( + stored_pattern, state_pattern, pattern_projection) + + # Optionally apply stored pattern normalization. + if self.norm_stored_pattern is not None: + stored_pattern = self.norm_stored_pattern(input=stored_pattern.reshape( + shape=(-1, stored_pattern.shape[2]))).reshape(shape=stored_pattern.shape) + + # Optionally apply state pattern normalization. + if self.norm_state_pattern is not None: + state_pattern = self.norm_state_pattern(input=state_pattern.reshape( + shape=(-1, state_pattern.shape[2]))).reshape(shape=state_pattern.shape) + + # Optionally apply pattern projection normalization. + if self.norm_pattern_projection is not None: + pattern_projection = self.norm_pattern_projection(input=pattern_projection.reshape( + shape=(-1, pattern_projection.shape[2]))).reshape(shape=pattern_projection.shape) + + # Apply Hopfield association and optional activation function. + return self.association_core( + query=state_pattern, key=stored_pattern, value=pattern_projection, + key_padding_mask=stored_pattern_padding_mask, need_weights=False, attn_mask=association_mask, + scaling=self.__scaling, update_steps_max=self.__update_steps_max, update_steps_eps=self.__update_steps_eps, + return_raw_associations=return_raw_associations, return_pattern_projections=return_projected_patterns) + + def forward(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Apply Hopfield association on specified data. + + :param input: data to be processed by Hopfield association module + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: Hopfield-processed input data + """ + association_output = self._maybe_transpose(self._associate( + data=input, return_raw_associations=False, + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask)[0]) + if self.association_activation is not None: + association_output = self.association_activation(association_output) + return association_output + + def get_association_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield association matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: association matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self._associate( + data=input, return_raw_associations=True, + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask)[2] + + def get_projected_pattern_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield projected pattern matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: pattern projection matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self._associate( + data=input, return_projected_patterns=True, + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask)[3] + + @property + def batch_first(self) -> bool: + return self.__batch_first + + @property + def scaling(self) -> Union[float, Tensor]: + return self.__scaling.clone() if type(self.__scaling) == Tensor else self.__scaling + + @property + def stored_pattern_dim(self) -> Optional[int]: + return self.association_core.kdim + + @property + def state_pattern_dim(self) -> Optional[int]: + return self.association_core.embed_dim + + @property + def pattern_projection_dim(self) -> Optional[int]: + return self.association_core.vdim + + @property + def input_size(self) -> Optional[int]: + return self.state_pattern_dim + + @property + def hidden_size(self) -> Optional[int]: + return self.association_core.head_dim + + @property + def output_size(self) -> Optional[int]: + return self.association_core.out_dim + + @property + def pattern_size(self) -> Optional[int]: + return self.association_core.pattern_dim + + @property + def update_steps_max(self) -> Optional[Union[int, Tensor]]: + return self.__update_steps_max.clone() if type(self.__update_steps_max) == Tensor else self.__update_steps_max + + @property + def update_steps_eps(self) -> Optional[Union[float, Tensor]]: + return self.__update_steps_eps.clone() if type(self.__update_steps_eps) == Tensor else self.__update_steps_eps + + @property + def stored_pattern_as_static(self) -> bool: + return self.association_core.key_as_static + + @property + def state_pattern_as_static(self) -> bool: + return self.association_core.query_as_static + + @property + def pattern_projection_as_static(self) -> bool: + return self.association_core.value_as_static + + @property + def normalize_stored_pattern(self) -> bool: + return self.norm_stored_pattern is not None + + @property + def normalize_stored_pattern_affine(self) -> bool: + return self.normalize_stored_pattern and self.norm_stored_pattern.elementwise_affine + + @property + def normalize_state_pattern(self) -> bool: + return self.norm_state_pattern is not None + + @property + def normalize_state_pattern_affine(self) -> bool: + return self.normalize_state_pattern and self.norm_state_pattern.elementwise_affine + + @property + def normalize_pattern_projection(self) -> bool: + return self.norm_pattern_projection is not None + + @property + def normalize_pattern_projection_affine(self) -> bool: + return self.normalize_pattern_projection and self.norm_pattern_projection.elementwise_affine + + @property + def normalize_hopfield_space(self) -> bool: + return self.hopfield.normalize_hopfield_space + + @property + def normalize_hopfield_space_affine(self) -> bool: + return self.hopfield.normalize_hopfield_space_affine + + +class HopfieldPooling(Module): + """ + Wrapper class encapsulating a trainable but fixed state pattern and "Hopfield" in + one combined module to be used as a Hopfield-based pooling layer. + """ + + def __init__(self, + input_size: int, + hidden_size: Optional[int] = None, + output_size: Optional[int] = None, + pattern_size: Optional[int] = None, + num_heads: int = 1, + scaling: Optional[Union[float, Tensor]] = None, + update_steps_max: Optional[Union[int, Tensor]] = 0, + update_steps_eps: Union[float, Tensor] = 1e-4, + + normalize_stored_pattern: bool = True, + normalize_stored_pattern_affine: bool = True, + normalize_state_pattern: bool = True, + normalize_state_pattern_affine: bool = True, + normalize_pattern_projection: bool = True, + normalize_pattern_projection_affine: bool = True, + normalize_hopfield_space: bool = False, + normalize_hopfield_space_affine: bool = False, + stored_pattern_as_static: bool = False, + state_pattern_as_static: bool = False, + pattern_projection_as_static: bool = False, + pattern_projection_as_connected: bool = False, + stored_pattern_size: Optional[int] = None, + pattern_projection_size: Optional[int] = None, + + batch_first: bool = True, + association_activation: Optional[str] = None, + dropout: float = 0.0, + input_bias: bool = True, + concat_bias_pattern: bool = False, + add_zero_association: bool = False, + disable_out_projection: bool = False, + quantity: int = 1, + trainable: bool = True + ): + """ + Initialise a new instance of a Hopfield-based pooling layer. + + :param input_size: depth of the input (state pattern) + :param hidden_size: depth of the association space + :param output_size: depth of the output projection + :param pattern_size: depth of patterns to be selected + :param num_heads: amount of parallel association heads + :param scaling: scaling of association heads, often represented as beta (one entry per head) + :param update_steps_max: maximum count of association update steps (None equals to infinity) + :param update_steps_eps: minimum difference threshold between two consecutive association update steps + :param normalize_stored_pattern: apply normalization on stored patterns + :param normalize_stored_pattern_affine: additionally enable affine normalization of stored patterns + :param normalize_state_pattern: apply normalization on state patterns + :param normalize_state_pattern_affine: additionally enable affine normalization of state patterns + :param normalize_pattern_projection: apply normalization on the pattern projection + :param normalize_pattern_projection_affine: additionally enable affine normalization of pattern projection + :param normalize_hopfield_space: enable normalization of patterns in the Hopfield space + :param normalize_hopfield_space_affine: additionally enable affine normalization of patterns in Hopfield space + :param stored_pattern_as_static: interpret specified stored patterns as being static + :param state_pattern_as_static: interpret specified state patterns as being static + :param pattern_projection_as_static: interpret specified pattern projections as being static + :param pattern_projection_as_connected: connect pattern projection with stored pattern + :param stored_pattern_size: depth of input (stored pattern) + :param pattern_projection_size: depth of input (pattern projection) + :param batch_first: flag for specifying if the first dimension of data fed to "forward" reflects the batch size + :param association_activation: additional activation to be applied on the result of the Hopfield association + :param dropout: dropout probability applied on the association matrix + :param input_bias: bias to be added to input (state and stored pattern as well as pattern projection) + :param concat_bias_pattern: bias to be concatenated to stored pattern as well as pattern projection + :param add_zero_association: add a new batch of zeros to stored pattern as well as pattern projection + :param disable_out_projection: disable output projection + :param quantity: amount of state patterns + :param trainable: state pattern used for pooling is trainable + """ + super(HopfieldPooling, self).__init__() + self.hopfield = Hopfield( + input_size=input_size, hidden_size=hidden_size, output_size=output_size, pattern_size=pattern_size, + num_heads=num_heads, scaling=scaling, update_steps_max=update_steps_max, update_steps_eps=update_steps_eps, + normalize_stored_pattern=normalize_stored_pattern, + normalize_stored_pattern_affine=normalize_stored_pattern_affine, + normalize_state_pattern=normalize_state_pattern, + normalize_state_pattern_affine=normalize_state_pattern_affine, + normalize_pattern_projection=normalize_pattern_projection, + normalize_pattern_projection_affine=normalize_pattern_projection_affine, + normalize_hopfield_space=normalize_hopfield_space, + normalize_hopfield_space_affine=normalize_hopfield_space_affine, + stored_pattern_as_static=stored_pattern_as_static, state_pattern_as_static=state_pattern_as_static, + pattern_projection_as_static=pattern_projection_as_static, + pattern_projection_as_connected=pattern_projection_as_connected, stored_pattern_size=stored_pattern_size, + pattern_projection_size=pattern_projection_size, batch_first=batch_first, + association_activation=association_activation, dropout=dropout, input_bias=input_bias, + concat_bias_pattern=concat_bias_pattern, add_zero_association=add_zero_association, + disable_out_projection=disable_out_projection) + self._quantity = quantity + pooling_weight_size = self.hopfield.hidden_size if state_pattern_as_static else self.hopfield.input_size + self.pooling_weights = nn.Parameter(torch.empty(size=(*( + (1, quantity) if batch_first else (quantity, 1) + ), input_size if pooling_weight_size is None else pooling_weight_size)), requires_grad=trainable) + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset pooling weights and underlying Hopfield association. + + :return: None + """ + if hasattr(self.hopfield, r'reset_parameters'): + self.hopfield.reset_parameters() + + # Explicitly initialise pooling weights. + nn.init.normal_(self.pooling_weights, mean=0.0, std=0.02) + + def _prepare_input(self, input: Union[Tensor, Tuple[Tensor, Tensor]]) -> Tuple[Tensor, Tensor, Tensor]: + """ + Prepare input for Hopfield association. + + :param input: data to be prepared + :return: stored pattern, expanded state pattern as well as pattern projection + """ + assert (type(input) == Tensor) or ((type(input) == tuple) and (len(input) == 2)), \ + r'either one tensor to be used as "stored pattern" and' \ + r' "pattern_projection" must be provided, or two separate ones.' + if type(input) == Tensor: + stored_pattern, pattern_projection = input, input + else: + stored_pattern, pattern_projection = input + + batch_size = stored_pattern.shape[0 if self.batch_first else 1] + return stored_pattern, self.pooling_weights.expand(size=(*( + (batch_size, self.quantity) if self.batch_first else (self.quantity, batch_size) + ), self.pooling_weights.shape[2])), pattern_projection + + def forward(self, input: Union[Tensor, Tuple[Tensor, Tensor]], stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Compute Hopfield-based pooling on specified data. + + :param input: data to be pooled + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: Hopfield-pooled input data + """ + return self.hopfield( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask).flatten(start_dim=1) + + def get_association_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield association matrix used for pooling gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: association matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self.hopfield.get_association_matrix( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + def get_projected_pattern_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield projected pattern matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: pattern projection matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self.hopfield.get_projected_pattern_matrix( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + @property + def batch_first(self) -> bool: + return self.hopfield.batch_first + + @property + def scaling(self) -> Union[float, Tensor]: + return self.hopfield.scaling + + @property + def stored_pattern_dim(self) -> Optional[int]: + return self.hopfield.stored_pattern_dim + + @property + def state_pattern_dim(self) -> Optional[int]: + return self.hopfield.state_pattern_dim + + @property + def pattern_projection_dim(self) -> Optional[int]: + return self.hopfield.pattern_projection_dim + + @property + def input_size(self) -> Optional[int]: + return self.hopfield.input_size + + @property + def hidden_size(self) -> int: + return self.hopfield.hidden_size + + @property + def output_size(self) -> Optional[int]: + return self.hopfield.output_size + + @property + def pattern_size(self) -> Optional[int]: + return self.hopfield.pattern_size + + @property + def quantity(self) -> int: + return self._quantity + + @property + def update_steps_max(self) -> Optional[Union[int, Tensor]]: + return self.hopfield.update_steps_max + + @property + def update_steps_eps(self) -> Optional[Union[float, Tensor]]: + return self.hopfield.update_steps_eps + + @property + def stored_pattern_as_static(self) -> bool: + return self.hopfield.stored_pattern_as_static + + @property + def state_pattern_as_static(self) -> bool: + return self.hopfield.state_pattern_as_static + + @property + def pattern_projection_as_static(self) -> bool: + return self.hopfield.pattern_projection_as_static + + @property + def normalize_stored_pattern(self) -> bool: + return self.hopfield.normalize_stored_pattern + + @property + def normalize_stored_pattern_affine(self) -> bool: + return self.hopfield.normalize_stored_pattern_affine + + @property + def normalize_state_pattern(self) -> bool: + return self.hopfield.normalize_state_pattern + + @property + def normalize_state_pattern_affine(self) -> bool: + return self.hopfield.normalize_state_pattern_affine + + @property + def normalize_pattern_projection(self) -> bool: + return self.hopfield.normalize_pattern_projection + + @property + def normalize_pattern_projection_affine(self) -> bool: + return self.hopfield.normalize_pattern_projection_affine + + +class HopfieldLayer(Module): + """ + Wrapper class encapsulating a trainable but fixed stored pattern, pattern projection and "Hopfield" in + one combined module to be used as a Hopfield-based pooling layer. + """ + + def __init__(self, + input_size: int, + hidden_size: Optional[int] = None, + output_size: Optional[int] = None, + pattern_size: Optional[int] = None, + num_heads: int = 1, + scaling: Optional[Union[float, Tensor]] = None, + update_steps_max: Optional[Union[int, Tensor]] = 0, + update_steps_eps: Union[float, Tensor] = 1e-4, + lookup_weights_as_separated: bool = False, + lookup_targets_as_trainable: bool = True, + + normalize_stored_pattern: bool = True, + normalize_stored_pattern_affine: bool = True, + normalize_state_pattern: bool = True, + normalize_state_pattern_affine: bool = True, + normalize_pattern_projection: bool = True, + normalize_pattern_projection_affine: bool = True, + normalize_hopfield_space: bool = False, + normalize_hopfield_space_affine: bool = False, + stored_pattern_as_static: bool = False, + state_pattern_as_static: bool = False, + pattern_projection_as_static: bool = False, + pattern_projection_as_connected: bool = False, + stored_pattern_size: Optional[int] = None, + pattern_projection_size: Optional[int] = None, + + batch_first: bool = True, + association_activation: Optional[str] = None, + dropout: float = 0.0, + input_bias: bool = True, + concat_bias_pattern: bool = False, + add_zero_association: bool = False, + disable_out_projection: bool = False, + quantity: int = 1, + trainable: bool = True + ): + """ + Initialise a new instance of a Hopfield-based lookup layer. + + :param input_size: depth of the input (state pattern) + :param hidden_size: depth of the association space + :param output_size: depth of the output projection + :param pattern_size: depth of patterns to be selected + :param num_heads: amount of parallel association heads + :param scaling: scaling of association heads, often represented as beta (one entry per head) + :param update_steps_max: maximum count of association update steps (None equals to infinity) + :param update_steps_eps: minimum difference threshold between two consecutive association update steps + :param lookup_weights_as_separated: separate lookup weights from lookup target weights + :param lookup_targets_as_trainable: employ trainable lookup target weights (used as pattern projection input) + :param normalize_stored_pattern: apply normalization on stored patterns + :param normalize_stored_pattern_affine: additionally enable affine normalization of stored patterns + :param normalize_state_pattern: apply normalization on state patterns + :param normalize_state_pattern_affine: additionally enable affine normalization of state patterns + :param normalize_pattern_projection: apply normalization on the pattern projection + :param normalize_pattern_projection_affine: additionally enable affine normalization of pattern projection + :param normalize_hopfield_space: enable normalization of patterns in the Hopfield space + :param normalize_hopfield_space_affine: additionally enable affine normalization of patterns in Hopfield space + :param stored_pattern_as_static: interpret specified stored patterns as being static + :param state_pattern_as_static: interpret specified state patterns as being static + :param pattern_projection_as_static: interpret specified pattern projections as being static + :param pattern_projection_as_connected: connect pattern projection with stored pattern + :param stored_pattern_size: depth of input (stored pattern) + :param pattern_projection_size: depth of input (pattern projection) + :param batch_first: flag for specifying if the first dimension of data fed to "forward" reflects the batch size + :param association_activation: additional activation to be applied on the result of the Hopfield association + :param dropout: dropout probability applied on the association matrix + :param input_bias: bias to be added to input (state and stored pattern as well as pattern projection) + :param concat_bias_pattern: bias to be concatenated to stored pattern as well as pattern projection + :param add_zero_association: add a new batch of zeros to stored pattern as well as pattern projection + :param disable_out_projection: disable output projection + :param quantity: amount of stored patterns + :param trainable: stored pattern used for lookup is trainable + """ + super(HopfieldLayer, self).__init__() + self.hopfield = Hopfield( + input_size=input_size, hidden_size=hidden_size, output_size=output_size, pattern_size=pattern_size, + num_heads=num_heads, scaling=scaling, update_steps_max=update_steps_max, update_steps_eps=update_steps_eps, + normalize_stored_pattern=normalize_stored_pattern, + normalize_stored_pattern_affine=normalize_stored_pattern_affine, + normalize_state_pattern=normalize_state_pattern, + normalize_state_pattern_affine=normalize_state_pattern_affine, + normalize_pattern_projection=normalize_pattern_projection, + normalize_pattern_projection_affine=normalize_pattern_projection_affine, + normalize_hopfield_space=normalize_hopfield_space, + normalize_hopfield_space_affine=normalize_hopfield_space_affine, + stored_pattern_as_static=stored_pattern_as_static, state_pattern_as_static=state_pattern_as_static, + pattern_projection_as_static=pattern_projection_as_static, + pattern_projection_as_connected=pattern_projection_as_connected, stored_pattern_size=stored_pattern_size, + pattern_projection_size=pattern_projection_size, batch_first=batch_first, + association_activation=association_activation, dropout=dropout, input_bias=input_bias, + concat_bias_pattern=concat_bias_pattern, add_zero_association=add_zero_association, + disable_out_projection=disable_out_projection) + self._quantity = quantity + lookup_weight_size = self.hopfield.hidden_size if stored_pattern_as_static else self.hopfield.stored_pattern_dim + self.lookup_weights = nn.Parameter(torch.empty(size=(*( + (1, quantity) if batch_first else (quantity, 1) + ), input_size if lookup_weight_size is None else lookup_weight_size)), requires_grad=trainable) + + if lookup_weights_as_separated: + target_weight_size = self.lookup_weights.shape[ + 2] if pattern_projection_size is None else pattern_projection_size + self.target_weights = nn.Parameter(torch.empty(size=(*( + (1, quantity) if batch_first else (quantity, 1) + ), target_weight_size)), requires_grad=lookup_targets_as_trainable) + else: + self.register_parameter(name=r'target_weights', param=None) + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset lookup and lookup target weights, including underlying Hopfield association. + + :return: None + """ + if hasattr(self.hopfield, r'reset_parameters'): + self.hopfield.reset_parameters() + + # Explicitly initialise lookup and target weights. + nn.init.normal_(self.lookup_weights, mean=0.0, std=0.02) + if self.target_weights is not None: + nn.init.normal_(self.target_weights, mean=0.0, std=0.02) + + def _prepare_input(self, input: Tensor) -> Tuple[Tensor, Tensor, Tensor]: + """ + Prepare input for Hopfield association. + + :param input: data to be prepared + :return: stored pattern, expanded state pattern as well as pattern projection + """ + batch_size = input.shape[0 if self.batch_first else 1] + stored_pattern = self.lookup_weights.expand(size=(*( + (batch_size, self.quantity) if self.batch_first else (self.quantity, batch_size) + ), self.lookup_weights.shape[2])) + if self.target_weights is None: + pattern_projection = stored_pattern + else: + pattern_projection = self.target_weights.expand(size=(*( + (batch_size, self.quantity) if self.batch_first else (self.quantity, batch_size) + ), self.target_weights.shape[2])) + + return stored_pattern, input, pattern_projection + + def forward(self, input: Tensor, stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Compute Hopfield-based lookup on specified data. + + :param input: data to used in lookup + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: result of Hopfield-based lookup on input data + """ + return self.hopfield( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + def get_association_matrix(self, input: Tensor, stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield association matrix used for lookup gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: association matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self.hopfield.get_association_matrix( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + def get_projected_pattern_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield projected pattern matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: pattern projection matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self.hopfield.get_projected_pattern_matrix( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + @property + def batch_first(self) -> bool: + return self.hopfield.batch_first + + @property + def scaling(self) -> Union[float, Tensor]: + return self.hopfield.scaling + + @property + def stored_pattern_dim(self) -> Optional[int]: + return self.hopfield.stored_pattern_dim + + @property + def state_pattern_dim(self) -> Optional[int]: + return self.hopfield.state_pattern_dim + + @property + def pattern_projection_dim(self) -> Optional[int]: + return self.hopfield.pattern_projection_dim + + @property + def input_size(self) -> Optional[int]: + return self.hopfield.input_size + + @property + def hidden_size(self) -> int: + return self.hopfield.hidden_size + + @property + def output_size(self) -> Optional[int]: + return self.hopfield.output_size + + @property + def pattern_size(self) -> Optional[int]: + return self.hopfield.pattern_size + + @property + def quantity(self) -> int: + return self._quantity + + @property + def update_steps_max(self) -> Optional[Union[int, Tensor]]: + return self.hopfield.update_steps_max + + @property + def update_steps_eps(self) -> Optional[Union[float, Tensor]]: + return self.hopfield.update_steps_eps + + @property + def stored_pattern_as_static(self) -> bool: + return self.hopfield.stored_pattern_as_static + + @property + def state_pattern_as_static(self) -> bool: + return self.hopfield.state_pattern_as_static + + @property + def pattern_projection_as_static(self) -> bool: + return self.hopfield.pattern_projection_as_static + + @property + def normalize_stored_pattern(self) -> bool: + return self.hopfield.normalize_stored_pattern + + @property + def normalize_stored_pattern_affine(self) -> bool: + return self.hopfield.normalize_stored_pattern_affine + + @property + def normalize_state_pattern(self) -> bool: + return self.hopfield.normalize_state_pattern + + @property + def normalize_state_pattern_affine(self) -> bool: + return self.hopfield.normalize_state_pattern_affine + + @property + def normalize_pattern_projection(self) -> bool: + return self.hopfield.normalize_pattern_projection + + @property + def normalize_pattern_projection_affine(self) -> bool: + return self.hopfield.normalize_pattern_projection_affine diff --git a/src/mhnfs/hopfield/examples/mnist_bags/modules/activation.py b/src/mhnfs/hopfield/examples/mnist_bags/modules/activation.py new file mode 100644 index 0000000000000000000000000000000000000000..6dcd6e56cddb954cf6b049687bdf5e7783aa2bc9 --- /dev/null +++ b/src/mhnfs/hopfield/examples/mnist_bags/modules/activation.py @@ -0,0 +1,337 @@ +import torch +import torch.nn as nn + +from torch import Tensor +from torch.nn import Linear, Module, Parameter +from typing import Optional + +from .functional import hopfield_core_forward + +try: + from torch.nn.modules.linear import _LinearWithBias +except ImportError: + _LinearWithBias = None + + +class HopfieldCore(Module): + r"""Allows the model to jointly attend to information + from different representation subspaces. + See references: "Hopfield Networks is All You Need" and + "Attention Is All You Need" (on which this implementation is partly based on). + + .. math:: + \text{HopfieldHead}(Q, K, V) = \text{Concat}(head_1,\dots,head_h)W^O + \text{where} head_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V) + + Args: + embed_dim: total dimension of the model. + num_heads: parallel attention heads. + dropout: a Dropout layer on attn_output_weights. Default: 0.0. + bias: add bias as module parameter. Default: True. + add_bias_kv: add bias to the key and value sequences at dim=0. + add_zero_attn: add a new batch of zeros to the key and + value sequences at dim=1. + kdim: total number of features in key. Default: None. + vdim: total number of features in value. Default: None. + + Note: if kdim and vdim are None, they will be set to embed_dim such that + query, key, and value have the same number of features. + + Examples:: + + >>> hopfield_attn = HopfieldCore(embed_dim, num_heads) + >>> attn_output, attn_output_weights, attn_matrix = hopfield_attn(query, key, value) + """ + __annotations__ = { + 'bias_k': torch._jit_internal.Optional[torch.Tensor], + 'bias_v': torch._jit_internal.Optional[torch.Tensor], + } + + def __init__(self, + embed_dim=None, # type: Optional[int] + num_heads=1, # type: int + dropout=0.0, # type: float + bias=True, # type: bool + add_bias_kv=False, # type: bool + add_zero_attn=False, # type: bool + kdim=None, # type: Optional[int] + vdim=None, # type: Optional[int] + + head_dim=None, # type: Optional[int] + pattern_dim=None, # type: Optional[int] + out_dim=None, # type: Optional[int] + disable_out_projection=False, # type: bool + key_as_static=False, # type: bool + query_as_static=False, # type: bool + value_as_static=False, # type: bool + value_as_connected=False, # type: bool + normalize_pattern=False, # type: bool + normalize_pattern_affine=False # type: bool + ): + super(HopfieldCore, self).__init__() + + assert (type(key_as_static) == bool) and (type(query_as_static) == bool) and (type(value_as_static) == bool) + self.key_as_static, self.query_as_static, self.value_as_static = key_as_static, query_as_static, value_as_static + num_non_static = 3 - (self.key_as_static + self.query_as_static + self.value_as_static) + assert 0 <= num_non_static < 4 + + self.value_as_connected = value_as_connected + self.normalize_pattern, self.normalize_pattern_affine = normalize_pattern, normalize_pattern_affine + self.disable_out_projection = disable_out_projection + + # In case of a static-only executions, check corresponding projections and normalizations. + self.static_execution = self._check_execution_mode() + if self.static_execution: + embed_dim, kdim, vdim = None, None, None + if embed_dim is None: + assert self.static_execution, r'static-only execution requires all projections to be deactivated.' + + # Check and set all other properties, conditioned on . + self.embed_dim = embed_dim + self.kdim = kdim if kdim is not None else embed_dim + self.vdim = vdim if vdim is not None else embed_dim + self._qkv_same_embed_dim = all(( + self.kdim == embed_dim, self.vdim == embed_dim, pattern_dim is None, not self.value_as_connected)) + assert (not self.value_as_connected) or (self.kdim == self.vdim), r'key and value need to be of same dimension.' + + self.num_heads = num_heads + self.dropout = dropout + self.head_dim = None + self.pattern_dim = pattern_dim + self.virtual_hopfield_dim = None + self.virtual_pattern_dim = None + if not self.static_execution: + if head_dim is None: + self.head_dim = embed_dim // num_heads + assert self.head_dim * num_heads == self.embed_dim, "embed_dim must be divisible by num_heads." + else: + assert head_dim > 0, "dimension of the association space has to be positive." + self.head_dim = head_dim + if self.pattern_dim is None: + self.pattern_dim = self.head_dim + self.virtual_hopfield_dim = self.num_heads * self.head_dim + self.virtual_pattern_dim = self.num_heads * self.pattern_dim + + self.out_dim = embed_dim if out_dim is None else out_dim + assert disable_out_projection or (self.out_dim > 0), "output projection dimension has to be positive." + + if normalize_pattern_affine: + assert normalize_pattern, "affine pattern normalization without pattern normalization has no effect." + self.p_norm_weight = Parameter(torch.Tensor(head_dim)) + self.p_norm_bias = Parameter(torch.Tensor(head_dim)) + else: + self.register_parameter('p_norm_weight', None) + self.register_parameter('p_norm_bias', None) + + if self._qkv_same_embed_dim is False: + if query_as_static: + self.register_parameter('q_proj_weight', None) + else: + self.q_proj_weight = Parameter(torch.Tensor(self.virtual_hopfield_dim, embed_dim)) + if key_as_static: + self.register_parameter('k_proj_weight', None) + else: + self.k_proj_weight = Parameter(torch.Tensor(self.virtual_hopfield_dim, self.kdim)) + if value_as_static: + self.register_parameter('v_proj_weight', None) + else: + self.v_proj_weight = Parameter(torch.Tensor( + self.virtual_pattern_dim, + self.virtual_hopfield_dim if (value_as_connected and not key_as_static) else self.vdim)) + self.register_parameter('in_proj_weight', None) + else: + if num_non_static > 0: + self.in_proj_weight = Parameter(torch.empty( + (not query_as_static) * self.virtual_hopfield_dim + + (not key_as_static) * self.virtual_hopfield_dim + + (not value_as_static) * self.virtual_pattern_dim, embed_dim)) + else: + self.register_parameter('in_proj_weight', None) + self.register_parameter('q_proj_weight', None) + self.register_parameter('k_proj_weight', None) + self.register_parameter('v_proj_weight', None) + + if bias and (num_non_static > 0): + self.in_proj_bias = Parameter(torch.empty( + (not query_as_static) * self.virtual_hopfield_dim + + (not key_as_static) * self.virtual_hopfield_dim + self.virtual_pattern_dim)) + else: + self.register_parameter('in_proj_bias', None) + if disable_out_projection: + self.register_parameter('out_proj', None) + else: + if bias and _LinearWithBias is not None: + self.out_proj = _LinearWithBias(self.virtual_pattern_dim, self.out_dim) + else: + self.out_proj = Linear(self.virtual_pattern_dim, self.out_dim, bias=bias) + + self.bias_k, self.bias_v = None, None + if add_bias_kv: + if not key_as_static: + self.bias_k = Parameter(torch.empty(1, 1, self.virtual_hopfield_dim)) + if not value_as_static: + self.bias_v = Parameter(torch.empty(1, 1, self.virtual_hopfield_dim)) + assert not (self.bias_k is None and self.bias_v is None), r'cannot set key/value bias if both are static.' + + self.add_zero_attn = add_zero_attn + self.reset_parameters() + + def _check_execution_mode(self) -> bool: + return all(( + self.key_as_static, self.query_as_static, self.value_as_static, not self.value_as_connected, + not self.normalize_pattern, not self.normalize_pattern_affine, self.disable_out_projection + )) + + def reset_parameters(self): + if self.p_norm_weight is not None: + nn.init.ones_(self.p_norm_weight) + nn.init.zeros_(self.p_norm_bias) + + if self._qkv_same_embed_dim and (self.in_proj_weight is not None): + nn.init.normal_(self.in_proj_weight, mean=0.0, std=0.02) + else: + if self.q_proj_weight is not None: + nn.init.normal_(self.q_proj_weight, mean=0.0, std=0.02) + if self.k_proj_weight is not None: + nn.init.normal_(self.k_proj_weight, mean=0.0, std=0.02) + if self.v_proj_weight is not None: + nn.init.normal_(self.v_proj_weight, mean=0.0, std=0.02) + + if self.in_proj_bias is not None: + nn.init.constant_(self.in_proj_bias, 0.0) + if not self.disable_out_projection: + nn.init.normal_(self.out_proj.weight, mean=0.0, std=0.02) + if self.out_proj.bias is not None: + nn.init.constant_(self.out_proj.bias, 0.0) + if self.bias_k is not None: + nn.init.normal_(self.bias_k, mean=0.0, std=0.02) + if self.bias_v is not None: + nn.init.normal_(self.bias_v, mean=0.0, std=0.02) + + def __setstate__(self, state): + super(HopfieldCore, self).__setstate__(state) + + def forward(self, + query, # type: Tensor + key, # type: Tensor + value, # type: Tensor + key_padding_mask=None, # type: Optional[Tensor] + need_weights=True, # type: bool + attn_mask=None, # type: Optional[Tensor] + + scaling=None, # type: Optional[Tensor] + update_steps_max=0, # type: Optional[int] + update_steps_eps=1e-4, # type: float + return_raw_associations=False, # type: bool + return_pattern_projections=False # type: bool + ): + # type: (...) -> Tuple[Tensor, Optional[Tensor], Optional[Tensor]] + r""" + Args: + query, key, value: map a query and a set of key-value pairs to an output. + See "Attention Is All You Need" for more details. + See "Hopfield Networks is All You Need" for more details in the setting of Hopfield networks. + key_padding_mask: if provided, specified padding elements in the key will + be ignored by the attention. When given a binary mask and a value is True, + the corresponding value on the attention layer will be ignored. When given + a byte mask and a value is non-zero, the corresponding value on the attention + layer will be ignored. + need_weights: output attn_output_weights. + attn_mask: 2D or 3D mask that prevents attention to certain positions. A 2D mask will be broadcasted for all + the batches while a 3D mask allows to specify a different mask for the entries of each batch. + + scaling: scaling of association heads, often represented as beta (one entry per head). + update_steps_max: maximum count of association update steps (None equals to infinity). + update_steps_eps: minimum difference threshold between two consecutive association update steps. + return_raw_associations: return raw association (softmax) values, unmodified. + return_pattern_projections: return pattern projection values, unmodified. + + Shape: + - Inputs: + - query: :math:`(L, N, E)` where L is the target sequence length, N is the batch size, E is + the embedding dimension. + - key: :math:`(S, N, E)`, where S is the source sequence length, N is the batch size, E is + the embedding dimension. + - value: :math:`(S, N, E)` where S is the source sequence length, N is the batch size, E is + the embedding dimension. + - key_padding_mask: :math:`(N, S)` where N is the batch size, S is the source sequence length. + If a ByteTensor is provided, the non-zero positions will be ignored while the position + with the zero positions will be unchanged. If a BoolTensor is provided, the positions with the + value of ``True`` will be ignored while the position with the value of ``False`` will be unchanged. + - attn_mask: 2D mask :math:`(L, S)` where L is the target sequence length, S is the source sequence length. + 3D mask :math:`(N*num_heads, L, S)` where N is the batch size, L is the target sequence length, + S is the source sequence length. attn_mask ensure that position i is allowed to attend the unmasked + positions. If a ByteTensor is provided, the non-zero positions are not allowed to attend + while the zero positions will be unchanged. If a BoolTensor is provided, positions with ``True`` + is not allowed to attend while ``False`` values will be unchanged. If a FloatTensor + is provided, it will be added to the attention weight. + + - scaling: :math:`(num_heads,)`, where num_heads is the amount of heads. + + - Outputs: + - attn_output: :math:`(L, N, E)` where L is the target sequence length, N is the batch size, + E is the embedding dimension. + - attn_output_weights: :math:`(N, L, S)` where N is the batch size, + L is the target sequence length, S is the source sequence length. + - attn_raw: :math:``(N, num_heads, L, S)`, where N is the batch size, + L is the target sequence length, S is the source sequence length. + """ + if self.query_as_static and self.key_as_static: + assert query.shape[2] == key.shape[2], \ + f'query shape[2] of {query.shape[2]} and key shape[2] of {key.shape[2]} need to be equal' + head_dim, embed_dim_to_check = query.shape[2], query.shape[2] + else: + assert self.query_as_static or (query.shape[2] == self.embed_dim), \ + f'query shape[2] of {query.shape[2]} invalid, needs to be {self.embed_dim}.' + assert (not self.query_as_static) or (self.query_as_static and query.shape[2] == self.head_dim), \ + f'query shape[2] of {query.shape[2]} invalid, needs to be {self.head_dim}' + + assert self.key_as_static or (key.shape[2] == self.kdim), \ + f'key shape[2] of {key.shape[2]} invalid, needs to be {self.kdim}.' + assert (not self.key_as_static) or (self.key_as_static and key.shape[2] == self.head_dim), \ + f'key shape[2] of {key.shape[2]} invalid, needs to be {self.head_dim}' + head_dim, embed_dim_to_check = self.head_dim, self.head_dim if self.query_as_static else self.embed_dim + + assert self.value_as_static or (value.shape[2] == self.vdim), \ + f'value shape[2] of {value.shape[2]} invalid, needs to be {self.vdim}.' + assert any(( + not self.value_as_static, self.value_as_static and value.shape[2] == self.pattern_dim, + self.disable_out_projection) + ), f'value shape[2] of {value.shape[2]} invalid, needs to be {self.pattern_dim}' + + out_weights, out_bias = None, None + if not self.disable_out_projection: + out_weights, out_bias = self.out_proj.weight, self.out_proj.bias + + if not self._qkv_same_embed_dim: + return hopfield_core_forward( + query=query, key=key, value=value, embed_dim_to_check=embed_dim_to_check, num_heads=self.num_heads, + in_proj_weight=self.in_proj_weight, in_proj_bias=self.in_proj_bias, bias_k=self.bias_k, + bias_v=self.bias_v, add_zero_attn=self.add_zero_attn, dropout_p=self.dropout, + out_proj_weight=out_weights, out_proj_bias=out_bias, training=self.training, + key_padding_mask=key_padding_mask, need_weights=need_weights, attn_mask=attn_mask, + use_separate_proj_weight=True, q_proj_weight=self.q_proj_weight, k_proj_weight=self.k_proj_weight, + v_proj_weight=self.v_proj_weight, + + key_as_static=self.key_as_static, query_as_static=self.query_as_static, + value_as_static=self.value_as_static, value_as_connected=self.value_as_connected, + normalize_pattern=self.normalize_pattern, + p_norm_weight=self.p_norm_weight, p_norm_bias=self.p_norm_bias, + head_dim=head_dim, pattern_dim=self.pattern_dim, scaling=scaling, + update_steps_max=update_steps_max, update_steps_eps=update_steps_eps, + return_raw_associations=return_raw_associations, return_projected_patterns=return_pattern_projections) + else: + return hopfield_core_forward( + query=query, key=key, value=value, embed_dim_to_check=embed_dim_to_check, num_heads=self.num_heads, + in_proj_weight=self.in_proj_weight, in_proj_bias=self.in_proj_bias, bias_k=self.bias_k, + bias_v=self.bias_v, add_zero_attn=self.add_zero_attn, dropout_p=self.dropout, + out_proj_weight=out_weights, out_proj_bias=out_bias, training=self.training, + key_padding_mask=key_padding_mask, need_weights=need_weights, attn_mask=attn_mask, + + key_as_static=self.key_as_static, query_as_static=self.query_as_static, + value_as_static=self.value_as_static, value_as_connected=self.value_as_connected, + normalize_pattern=self.normalize_pattern, + p_norm_weight=self.p_norm_weight, p_norm_bias=self.p_norm_bias, + head_dim=head_dim, pattern_dim=self.pattern_dim, scaling=scaling, + update_steps_max=update_steps_max, update_steps_eps=update_steps_eps, + return_raw_associations=return_raw_associations, return_projected_patterns=return_pattern_projections) diff --git a/src/mhnfs/hopfield/examples/mnist_bags/modules/functional.py b/src/mhnfs/hopfield/examples/mnist_bags/modules/functional.py new file mode 100644 index 0000000000000000000000000000000000000000..2619c45fd87dc5f0348db393aa9b305611b4dd32 --- /dev/null +++ b/src/mhnfs/hopfield/examples/mnist_bags/modules/functional.py @@ -0,0 +1,450 @@ +import torch +import torch.nn as nn + +from torch.tensor import Tensor +from typing import Optional, Tuple, Union + + +def hopfield_core_forward(query, # type: Tensor + key, # type: Tensor + value, # type: Tensor + embed_dim_to_check, # type: int + num_heads, # type: int + in_proj_weight, # type: Optional[Tensor] + in_proj_bias, # type: Optional[Tensor] + bias_k, # type: Optional[Tensor] + bias_v, # type: Optional[Tensor] + add_zero_attn, # type: bool + dropout_p, # type: float + out_proj_weight, # type: Tensor + out_proj_bias, # type: Tensor + training=True, # type: bool + key_padding_mask=None, # type: Optional[Tensor] + need_weights=True, # type: bool + attn_mask=None, # type: Optional[Tensor] + use_separate_proj_weight=False, # type: bool + q_proj_weight=None, # type: Optional[Tensor] + k_proj_weight=None, # type: Optional[Tensor] + v_proj_weight=None, # type: Optional[Tensor] + static_k=None, # type: Optional[Tensor] + static_v=None, # type: Optional[Tensor] + + key_as_static=False, # type: bool + query_as_static=False, # type: bool + value_as_static=False, # type: bool + value_as_connected=False, # type: bool + normalize_pattern=False, # type: bool + p_norm_weight=None, # type: Optional[Tensor] + p_norm_bias=None, # type: Optional[Tensor] + head_dim=None, # type: Optional[int] + pattern_dim=None, # type: Optional[int] + scaling=None, # type: Optional[Union[float, Tensor]] + update_steps_max=0, # type: Optional[Union[int, Tensor]] + update_steps_eps=1e-4, # type: Union[float, Tensor] + return_raw_associations=False, # type: bool + return_projected_patterns=False # type: bool + ): + # type: (...) -> Tuple[Tensor, Optional[Tensor]] + r""" + Args: + query, key, value: map a query and a set of key-value pairs to an output. + See "Attention Is All You Need" for more details. + See "Hopfield Networks is All You Need" for more details in the setting of Hopfield networks. + embed_dim_to_check: total dimension of the model (in case of default head dimension). + num_heads: parallel attention heads. + in_proj_weight, in_proj_bias: input projection weight and bias. + bias_k, bias_v: bias of the key and value sequences to be added at dim=0. + add_zero_attn: add a new batch of zeros to the key and + value sequences at dim=1. + dropout_p: probability of an element to be zeroed. + out_proj_weight, out_proj_bias: the output projection weight and bias. + training: apply dropout if is ``True``. + key_padding_mask: if provided, specified padding elements in the key will + be ignored by the attention. This is an binary mask. When the value is True, + the corresponding value on the attention layer will be filled with -inf. + need_weights: output attn_output_weights. + attn_mask: 2D or 3D mask that prevents attention to certain positions. A 2D mask will be broadcasted for all + the batches while a 3D mask allows to specify a different mask for the entries of each batch. + use_separate_proj_weight: the function accept the proj. weights for query, key, + and value in different forms. If false, in_proj_weight will be used, which is + a combination of q_proj_weight, k_proj_weight, v_proj_weight. + q_proj_weight, k_proj_weight, v_proj_weight, in_proj_bias: input projection weight and bias. + static_k, static_v: static key and value used for attention operators. + + key_as_static: interpret specified key as being static. + query_as_static: interpret specified key as being static. + value_as_static: interpret specified key as being static. + value_as_connected: connect value projection with key projection. + normalize_pattern: enable normalization of patterns. + p_norm_weight, p_norm_bias: pattern normalization weight and bias. + head_dim: dimensionality of each head. + pattern_dim: dimensionality of each projected value input. + scaling: scaling of association heads, often represented as beta (one entry per head). + update_steps_max: maximum count of association update steps (None equals to infinity). + update_steps_eps: minimum difference threshold between two consecutive association update steps. + return_raw_associations: return raw association (softmax) values, unmodified. + return_projected_patterns: return pattern projection values, unmodified. + + Shape: + Inputs: + - query: :math:`(L, N, E)` where L is the target sequence length, N is the batch size, E is + the embedding dimension. + - key: :math:`(S, N, E)`, where S is the source sequence length, N is the batch size, E is + the embedding dimension. + - value: :math:`(S, N, E)` where S is the source sequence length, N is the batch size, E is + the embedding dimension. + - key_padding_mask: :math:`(N, S)` where N is the batch size, S is the source sequence length. + If a ByteTensor is provided, the non-zero positions will be ignored while the zero positions + will be unchanged. If a BoolTensor is provided, the positions with the + value of ``True`` will be ignored while the position with the value of ``False`` will be unchanged. + - attn_mask: 2D mask :math:`(L, S)` where L is the target sequence length, S is the source sequence length. + 3D mask :math:`(N*num_heads, L, S)` where N is the batch size, L is the target sequence length, + S is the source sequence length. attn_mask ensures that position i is allowed to attend the unmasked + positions. If a ByteTensor is provided, the non-zero positions are not allowed to attend + while the zero positions will be unchanged. If a BoolTensor is provided, positions with ``True`` + are not allowed to attend while ``False`` values will be unchanged. If a FloatTensor + is provided, it will be added to the attention weight. + - static_k: :math:`(N*num_heads, S, head_dim)`, where S is the source sequence length, N is the batch size. + - static_v: :math:`(N*num_heads, S, head_dim)`, where S is the source sequence length, N is the batch size. + + - scaling: :math:`(num_heads,)`, where num_heads is the amount of heads. + + Outputs: + - attn_output: :math:`(L, N, E)`, where L is the target sequence length, N is the batch size, + E is the embedding dimension. + - attn_output_weights: :math:`(N, L, S)`, where N is the batch size, + L is the target sequence length, S is the source sequence length. + - attn_raw: :math:``(N, num_heads, L, S)`, where N is the batch size, + L is the target sequence length, S is the source sequence length. + """ + if not torch.jit.is_scripting(): + tens_ops = (query, key, value, in_proj_weight, in_proj_bias, bias_k, bias_v, + out_proj_weight, out_proj_bias) + if any([type(t) is not Tensor for t in tens_ops]) and nn.functional.has_torch_function(tens_ops): + return nn.functional.handle_torch_function( + hopfield_core_forward, tens_ops, query, key, value, + embed_dim_to_check, num_heads, in_proj_weight, in_proj_bias, + bias_k, bias_v, add_zero_attn, dropout_p, out_proj_weight, + out_proj_bias, training=training, key_padding_mask=key_padding_mask, + need_weights=need_weights, attn_mask=attn_mask, + use_separate_proj_weight=use_separate_proj_weight, + q_proj_weight=q_proj_weight, k_proj_weight=k_proj_weight, + v_proj_weight=v_proj_weight, static_k=static_k, static_v=static_v, + key_as_static=key_as_static, query_as_static=query_as_static, + value_as_static=value_as_static, value_as_connected=value_as_connected, + normalize_pattern=normalize_pattern, p_norm_weight=p_norm_weight, p_norm_bias=p_norm_bias, + head_dim=head_dim, pattern_dim=pattern_dim, scaling=scaling, update_steps_max=update_steps_max, + update_steps_eps=update_steps_eps, return_raw_associations=return_raw_associations) + tgt_len, bsz, embed_dim = query.shape[0], value.shape[1], query.shape[2] + assert embed_dim == embed_dim_to_check + # allow MHA to have different sizes for the feature dimension + assert key.size(0) == value.size(0) and key.size(1) == value.size(1) + + assert (scaling is None) or (type(scaling) in (float, torch.Tensor)) + if type(scaling) == torch.Tensor: + assert scaling.ndimension() == 1 and scaling.shape[0] == num_heads, "only one entry per head." + + assert (update_steps_max is None) or (type(update_steps_max) in (int, torch.Tensor)) + if type(update_steps_max) == torch.Tensor: + assert update_steps_max.ndimension() == 1 and update_steps_max.shape[0] == num_heads, "only one entry per head." + elif type(update_steps_max) == int: + update_steps_max = torch.tensor([update_steps_max] * num_heads, dtype=torch.int32, device=query.device) + elif update_steps_max is None: + update_steps_max = -torch.ones(size=(num_heads,), dtype=torch.int32, device=query.device) + + assert type(update_steps_eps) in (float, torch.Tensor) + if type(update_steps_eps) == torch.Tensor: + assert update_steps_eps.ndimension() == 1 and update_steps_eps.shape[0] == num_heads, "only one entry per head." + assert (update_steps_eps <= 0.0).sum() == 0, "only positive thresholds allowed." + update_steps_eps = update_steps_eps.to(device=query.device) + elif type(update_steps_eps) == float: + assert update_steps_eps > 0, "only positive thresholds allowed." + update_steps_eps = torch.tensor([update_steps_eps] * num_heads, dtype=query.dtype, device=query.device) + + # Adapt dimensionality of each each. + if head_dim is None: + head_dim = embed_dim // num_heads + assert head_dim * num_heads == embed_dim, r'embed_dim must be divisible by num_heads.' + hopfield_dim = num_heads * head_dim + + # Adapt dimensionality of each value projection. + if pattern_dim is None: + pattern_dim = head_dim + assert (not value_as_connected) or (pattern_dim == head_dim) + + q, k, v, xi, src_len = None, None, None, None, 0 + update_step, xi_old, xi_difference_norm = 0, None, float(r'+inf') + update_active_heads = torch.tensor([[[True]]] * num_heads * bsz, device=query.device) + assert update_active_heads.any(), "at least one head needs to be active." + + #################################################################################################################### + # BEGIN HOPFIELD UPDATE ITERATION # + #################################################################################################################### + + while update_active_heads.any(): + + # The query is already projected into the "Hopfield" space at "update_step" equals 0. + # No more projection necessary if "update_step" greater than 0. + if update_step == 0: + if not use_separate_proj_weight: + + if torch.equal(query, key) and torch.equal(key, value) and not ( + key_as_static or query_as_static or value_as_static): + # self-attention + q, k, v = nn.functional.linear(query, in_proj_weight, in_proj_bias).chunk(3, dim=-1) + + elif torch.equal(key, value) and not (key_as_static or value_as_static): + # encoder-decoder attention + _start, _end = 0, hopfield_dim + if query_as_static: + q = query.repeat(1, num_heads, 1) + else: + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + q = nn.functional.linear(query, _w, _b) + _start = hopfield_dim + _end = None + + if key is None: + assert value is None + k = None + v = None + else: + + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + k, v = nn.functional.linear(key, _w, _b).chunk(2, dim=-1) + + else: + _start, _end = 0, hopfield_dim + if query_as_static: + q = query.repeat(1, num_heads, 1) + else: + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + q = nn.functional.linear(query, _w, _b) + _start += hopfield_dim + _end += hopfield_dim + + if key_as_static: + k = key.repeat(1, num_heads, 1) + else: + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + k = nn.functional.linear(key, _w, _b) + _start += hopfield_dim + _end += hopfield_dim + + if value_as_static: + v = value.repeat(1, num_heads, 1) + else: + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + v = nn.functional.linear(value, _w, _b) + else: + _start, _end = 0, hopfield_dim + if query_as_static: + q = query.repeat(1, num_heads, 1) + else: + q_proj_weight_non_opt = torch.jit._unwrap_optional(q_proj_weight) + len1, len2 = q_proj_weight_non_opt.size() + assert len1 == hopfield_dim and len2 == query.size(-1) + if in_proj_bias is not None: + q = nn.functional.linear(query, q_proj_weight_non_opt, in_proj_bias[_start:_end]) + _start += hopfield_dim + _end += hopfield_dim + else: + q = nn.functional.linear(query, q_proj_weight_non_opt, in_proj_bias) + + v = value + if key_as_static: + k = key.repeat(1, num_heads, 1) + else: + k_proj_weight_non_opt = torch.jit._unwrap_optional(k_proj_weight) + len1, len2 = k_proj_weight_non_opt.size() + assert len1 == hopfield_dim and len2 == key.size(-1) + + _bias = None if in_proj_bias is None else in_proj_bias[_start:_end] + k = nn.functional.linear(key, k_proj_weight_non_opt, _bias) + if value_as_connected: + v = nn.functional.linear(v, k_proj_weight_non_opt, _bias) + _start += hopfield_dim + _end += num_heads * pattern_dim + + if value_as_static: + if not (value_as_connected or key_as_static): + v = v.repeat(1, num_heads, 1) + else: + v_proj_weight_non_opt = torch.jit._unwrap_optional(v_proj_weight) + len1, len2 = v_proj_weight_non_opt.size() + assert len1 == (num_heads * pattern_dim) and len2 == v.size(-1) + if in_proj_bias is not None: + v = nn.functional.linear(v, v_proj_weight_non_opt, in_proj_bias[_start:]) + else: + v = nn.functional.linear(v, v_proj_weight_non_opt, in_proj_bias) + + if attn_mask is not None: + assert attn_mask.dtype == torch.float32 or attn_mask.dtype == torch.float64 or \ + attn_mask.dtype == torch.float16 or attn_mask.dtype == torch.uint8 or \ + attn_mask.dtype == torch.bool, \ + 'Only float, byte, and bool types are supported for attn_mask, not {}'.format(attn_mask.dtype) + if attn_mask.dtype == torch.uint8: + warnings.warn( + "Byte tensor for attn_mask in nn.HopfieldCore is deprecated. Use bool tensor instead.") + attn_mask = attn_mask.to(torch.bool) + + if attn_mask.dim() == 2: + attn_mask = attn_mask.unsqueeze(0) + if list(attn_mask.size()) != [1, query.size(0), key.size(0)]: + raise RuntimeError('The size of the 2D attn_mask is not correct.') + elif attn_mask.dim() == 3: + if list(attn_mask.size()) != [bsz * num_heads, query.size(0), key.size(0)]: + raise RuntimeError('The size of the 3D attn_mask is not correct.') + else: + raise RuntimeError("attn_mask's dimension {} is not supported".format(attn_mask.dim())) + # attn_mask's dim is 3 now. + + # Optionally normalize patterns. + if normalize_pattern: + q = torch.nn.functional.layer_norm( + input=q.reshape(shape=(-1, head_dim)), normalized_shape=(head_dim,), + weight=p_norm_weight, bias=p_norm_bias).reshape(shape=q.shape) + k = torch.nn.functional.layer_norm( + input=k.reshape(shape=(-1, head_dim)), normalized_shape=(head_dim,), + weight=p_norm_weight, bias=p_norm_bias).reshape(shape=k.shape) + + else: + active_xi = xi.masked_select(mask=update_active_heads).view(size=(-1, *xi.shape[1:])) + active_k = k.masked_select(mask=update_active_heads).view(size=(-1, *k.shape[1:])) + q = torch.masked_scatter(input=q, mask=update_active_heads, source=torch.bmm(active_xi, active_k)) + + # Optionally scale association heads (each head separately). + if type(scaling) == float: + q = q * scaling + elif type(scaling) == torch.Tensor: + q = q * scaling.view(1, 1, -1).repeat(repeats=(1, 1, q.shape[2] // scaling.shape[0])) + + if update_step == 0: + # convert ByteTensor key_padding_mask to bool + if key_padding_mask is not None and key_padding_mask.dtype == torch.uint8: + warnings.warn( + "Byte tensor for key_padding_mask in nn.HopfieldCore is deprecated. Use bool tensor instead.") + key_padding_mask = key_padding_mask.to(torch.bool) + + if bias_k is not None and bias_v is not None: + if static_k is None and static_v is None and key_as_static is None and value_as_static is None: + k = torch.cat([k, bias_k.repeat(1, bsz, 1)]) + v = torch.cat([v, bias_v.repeat(1, bsz, 1)]) + if attn_mask is not None: + attn_mask = nn.functional.pad(attn_mask, [0, 1]) + if key_padding_mask is not None: + key_padding_mask = nn.functional.pad(key_padding_mask, [0, 1]) + else: + assert static_k is None, "bias cannot be added to static key." + assert static_v is None, "bias cannot be added to static value." + assert not key_as_static, "bias cannot be added to static key." + assert not value_as_static, "bias cannot be added to static value." + else: + assert bias_k is None + assert bias_v is None + + q = q.contiguous().view(tgt_len, -1, head_dim).transpose(0, 1) + if k is not None: + k = k.contiguous().view(-1, bsz * num_heads, head_dim).transpose(0, 1) + if v is not None: + v = v.contiguous().view(v.shape[0], bsz * num_heads, -1).transpose(0, 1) + + if static_k is not None: + assert static_k.size(0) == bsz * num_heads + assert static_k.size(2) == head_dim + k = static_k + + if static_v is not None: + assert static_v.size(0) == bsz * num_heads + assert static_v.size(2) == pattern_dim + v = static_v + + src_len = k.size(1) + + if key_padding_mask is not None: + assert key_padding_mask.size(0) == bsz + assert key_padding_mask.size(1) == src_len + + if add_zero_attn: + src_len += 1 + k = torch.cat([k, torch.zeros((k.size(0), 1) + k.size()[2:], dtype=k.dtype, device=k.device)], dim=1) + v = torch.cat([v, torch.zeros((v.size(0), 1) + v.size()[2:], dtype=v.dtype, device=v.device)], dim=1) + if attn_mask is not None: + attn_mask = nn.functional.pad(attn_mask, [0, 1]) + if key_padding_mask is not None: + key_padding_mask = nn.functional.pad(key_padding_mask, [0, 1]) + + attn_output_weights = torch.bmm(q, k.transpose(1, 2)) + assert list(attn_output_weights.size()) == [bsz * num_heads, tgt_len, src_len] + + if attn_mask is not None: + if attn_mask.dtype == torch.bool: + attn_output_weights.masked_fill_(attn_mask, float('-inf')) + else: + attn_output_weights += attn_mask + + if key_padding_mask is not None: + attn_output_weights = attn_output_weights.view(bsz, num_heads, tgt_len, src_len) + attn_output_weights = attn_output_weights.masked_fill( + key_padding_mask.unsqueeze(1).unsqueeze(2), + float('-inf'), + ) + attn_output_weights = attn_output_weights.view(bsz * num_heads, tgt_len, src_len) + + # Compute new xi for Hopfield retrieve iterations. + if xi is None: + xi = nn.functional.softmax(attn_output_weights, dim=-1) + else: + xi = torch.masked_scatter(input=xi, mask=update_active_heads, source=nn.functional.softmax( + attn_output_weights.masked_select(mask=update_active_heads).view(size=(-1, *xi.shape[1:])), dim=-1)) + + # Compute threshold-based stopping criterion for Hopfield retrieve iterations. + with torch.no_grad(): + xi_active = xi.view(size=(bsz, num_heads, tgt_len, src_len)) + update_active_heads = (update_step < update_steps_max) | (update_steps_max < 0) + if xi_old is not None: + update_active_heads &= ((xi_old - xi_active).norm(p=2, dim=(2, 3)).max(axis=0)[0]) > update_steps_eps + update_active_heads = update_active_heads.unsqueeze(dim=1).unsqueeze(dim=2).repeat(repeats=(bsz, 1, 1)) + xi_old = xi_active + update_step += 1 + + #################################################################################################################### + # END HOPFIELD UPDATE ITERATION # + #################################################################################################################### + + attn_output_weights = nn.functional.dropout(xi, p=dropout_p, training=training) + attn_output = torch.bmm(attn_output_weights, v) + assert list(attn_output.shape[:2]) == [bsz * num_heads, tgt_len] + attn_output = attn_output.transpose(0, 1).contiguous().view(tgt_len, bsz, -1) + if out_proj_weight is not None: + assert attn_output.shape[2] == num_heads * pattern_dim + attn_output = nn.functional.linear(attn_output, out_proj_weight, out_proj_bias) + + xi = xi.view(bsz, num_heads, tgt_len, src_len) if return_raw_associations else None + v = v.view(bsz, num_heads, src_len, -1) if return_projected_patterns else None + if need_weights: + # average attention weights over heads + attn_output_weights = attn_output_weights.view(bsz, num_heads, tgt_len, src_len) + return attn_output, attn_output_weights.sum(dim=1) / num_heads, xi, v + else: + return attn_output, None, xi, v diff --git a/src/mhnfs/hopfield/examples/mnist_bags/modules/transformer.py b/src/mhnfs/hopfield/examples/mnist_bags/modules/transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..884e0cb4b57610cf1daf8147f2c3d59f17824750 --- /dev/null +++ b/src/mhnfs/hopfield/examples/mnist_bags/modules/transformer.py @@ -0,0 +1,209 @@ +import torch +import torch.nn as nn + +from copy import deepcopy +from torch import Tensor +from torch.nn.modules import Module +from typing import Optional, Tuple, Union + +from . import Hopfield + + +class HopfieldEncoderLayer(Module): + """ + Module with underlying Hopfield association to be used as an encoder in transformer-like architectures. + """ + + def __init__(self, + hopfield_association: Hopfield, + dim_feedforward: int = 2048, + dropout: float = 0.1, + activation: str = r'relu' + ): + """ + Initialise a new instance of a Hopfield association-based encoder module. + + :param hopfield_association: instance of Hopfield association module + :param dim_feedforward: depth of the linear projections applied internally + :param activation: activation to be applied on the result of the internal linear projections + :param dropout: dropout probability to be applied internally + """ + super(HopfieldEncoderLayer, self).__init__() + self.hopfield_association = deepcopy(hopfield_association) + + self.linear_residual = nn.Linear(self.hopfield_association.state_pattern_dim, dim_feedforward) + self.dropout_residual = nn.Dropout(dropout) + self.linear_output = nn.Linear(dim_feedforward, self.hopfield_association.state_pattern_dim) + + self.norm_residual = nn.LayerNorm(self.hopfield_association.state_pattern_dim) + self.norm_output = nn.LayerNorm(self.hopfield_association.state_pattern_dim) + self.dropout_hopfield_association = nn.Dropout(dropout) + self.dropout_output = nn.Dropout(dropout) + + self.activation_residual = getattr(torch, activation, None) + assert self.activation_residual is not None, r'invalid activation function supplied.' + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset parameters, including Hopfield association. + + :return: None + """ + for module in (self.hopfield_association, self.linear_residual, + self.linear_output, self.norm_residual, self.norm_output): + if hasattr(module, r'reset_parameters'): + module.reset_parameters() + + def forward(self, src: Tensor, src_mask: Optional[Tensor] = None, + src_key_padding_mask: Optional[Tensor] = None) -> Tensor: + """ + Apply Hopfield encoding on specified data. + + :param src: data to be processed by Hopfield encoder module + :param src_mask: mask to be applied on association matrix + :param src_key_padding_mask: mask to be applied on stored patterns + :return: Hopfield-encoded input data + """ + data_associated = self.hopfield_association( + input=src, stored_pattern_padding_mask=src_key_padding_mask, association_mask=src_mask) + src = src + self.dropout_hopfield_association(input=data_associated) + src = self.norm_residual(input=src) + + result_residual_inner = self.activation_residual(input=self.linear_residual(input=src)) + data_associated = self.linear_output(input=self.dropout_residual(input=result_residual_inner)) + src = src + self.dropout_output(input=data_associated) + + return self.norm_output(input=src) + + def get_association_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]]) -> Tensor: + """ + Fetch Hopfield association matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :return: association matrix as computed by the Hopfield core module + """ + return self.hopfield_association.get_association_matrix(input=input) + + @property + def batch_first(self) -> int: + return self.hopfield_association.batch_first + + @property + def input_size(self) -> int: + return self.hopfield_association.input_size + + @property + def output_size(self) -> int: + return self.linear_output.out_features + + +class HopfieldDecoderLayer(Module): + + def __init__(self, + hopfield_association_self: Hopfield, + hopfield_association_cross: Hopfield, + dim_feedforward: int = 2048, + dropout: float = 0.1, + activation: str = r'relu' + ): + """ + Initialise a new instance of a Hopfield association-based encoder module. + + :param hopfield_association_self: instance of Hopfield self-association module + :param hopfield_association_cross: instance of Hopfield cross-association module + :param dim_feedforward: depth of the linear projections applied internally + :param dropout: dropout probability to be applied internally + :param activation: activation to be applied on the result of the internal linear projections + """ + super(HopfieldDecoderLayer, self).__init__() + self.hopfield_association_self = deepcopy(hopfield_association_self) + self.hopfield_association_cross = deepcopy(hopfield_association_cross) + + self.linear_residual = nn.Linear(self.hopfield_association_self.state_pattern_dim, dim_feedforward) + self.dropout_residual = nn.Dropout(dropout) + self.linear_output = nn.Linear(dim_feedforward, self.hopfield_association_self.state_pattern_dim) + + self.norm_residual_self = nn.LayerNorm(self.hopfield_association_self.state_pattern_dim) + self.norm_residual_cross = nn.LayerNorm(self.hopfield_association_self.state_pattern_dim) + self.norm_output = nn.LayerNorm(self.hopfield_association_self.state_pattern_dim) + self.dropout_hopfield_association_self = nn.Dropout(dropout) + self.dropout_hopfield_association_cross = nn.Dropout(dropout) + self.dropout_output = nn.Dropout(dropout) + + self.activation_residual = getattr(torch, activation, None) + assert self.activation_residual is not None, r'invalid activation function supplied.' + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset parameters, including Hopfield association. + + :return: None + """ + for module in (self.hopfield_association_self, self.hopfield_association_cross, + self.linear_residual, self.linear_output, self.norm_residual_self, + self.norm_residual_cross, self.norm_output): + if hasattr(module, r'reset_parameters'): + module.reset_parameters() + + def forward(self, tgt: Tensor, memory: Tensor, tgt_mask: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, tgt_key_padding_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None) -> Tensor: + """ + Apply Hopfield decoding on specified data. + + :param tgt: data to be processed by Hopfield decoder module (self-association) + :param memory: data to be processed by Hopfield encoder module (cross-association) + :param tgt_mask: mask to be applied on self-association matrix + :param memory_mask: mask to be applied on cross-association matrix + :param tgt_key_padding_mask: mask to be applied on stored patterns + :param memory_key_padding_mask: mask to be applied on state patterns as well as pattern projection + :return: Hopfield-decoded input + """ + data_associated = self.hopfield_association_self( + input=tgt, stored_pattern_padding_mask=tgt_key_padding_mask, + association_mask=tgt_mask) + tgt = tgt + self.dropout_hopfield_association_self(input=data_associated) + tgt = self.norm_residual_self(input=tgt) + + data_associated = self.hopfield_association_cross( + input=(memory, tgt, memory), stored_pattern_padding_mask=memory_key_padding_mask, + association_mask=memory_mask) + tgt = tgt + self.dropout_hopfield_association_cross(input=data_associated) + tgt = self.norm_residual_cross(input=tgt) + + result_residual_inner = self.activation_residual(input=self.linear_residual(input=tgt)) + data_associated = self.linear_output(input=self.dropout_residual(input=result_residual_inner)) + tgt = tgt + self.dropout_output(input=data_associated) + return self.norm_output(input=tgt) + + def get_association_matrix_self(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]]) -> Tensor: + """ + Fetch Hopfield self-association matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :return: association matrix as computed by the Hopfield core module + """ + return self.hopfield_association_self.get_association_matrix(input=input) + + def get_association_matrix_cross(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]]) -> Tensor: + """ + Fetch Hopfield cross-association matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :return: association matrix as computed by the Hopfield core module + """ + return self.hopfield_association_cross.get_association_matrix(input=input) + + @property + def batch_first(self) -> int: + return self.hopfield_association_self.batch_first + + @property + def input_size(self) -> int: + return self.hopfield_association_self.input_size + + @property + def output_size(self) -> int: + return self.linear_output_self.out_features diff --git a/src/mhnfs/hopfield/examples/mnist_bags/resources/attention_base.pdf b/src/mhnfs/hopfield/examples/mnist_bags/resources/attention_base.pdf new file mode 100644 index 0000000000000000000000000000000000000000..9bda3dcc2e08778205dc34f009e1ae59efdf4ac4 Binary files /dev/null and b/src/mhnfs/hopfield/examples/mnist_bags/resources/attention_base.pdf differ diff --git a/src/mhnfs/hopfield/examples/mnist_bags/resources/gated_attention_base.pdf b/src/mhnfs/hopfield/examples/mnist_bags/resources/gated_attention_base.pdf new file mode 100644 index 0000000000000000000000000000000000000000..f810c2f8e6d8f277e4f0073c3d1c9312e986caa4 Binary files /dev/null and b/src/mhnfs/hopfield/examples/mnist_bags/resources/gated_attention_base.pdf differ diff --git a/src/mhnfs/hopfield/examples/mnist_bags/resources/hopfield_pooling.pdf b/src/mhnfs/hopfield/examples/mnist_bags/resources/hopfield_pooling.pdf new file mode 100644 index 0000000000000000000000000000000000000000..998d74eea9f281277cfb49cb05f25fd6dc8fbd2d Binary files /dev/null and b/src/mhnfs/hopfield/examples/mnist_bags/resources/hopfield_pooling.pdf differ diff --git a/src/mhnfs/hopfield/modules/__init__.py b/src/mhnfs/hopfield/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c11713739acb1aca3b32cca53acf0c3faf1fa9f6 --- /dev/null +++ b/src/mhnfs/hopfield/modules/__init__.py @@ -0,0 +1,898 @@ +import torch +import torch.nn as nn + +from math import sqrt +from torch import Tensor +from torch.nn import Module, Parameter +from typing import Optional, Tuple, Union + +from .activation import HopfieldCore + + +class Hopfield(Module): + """ + Module with underlying Hopfield association. + """ + + def __init__(self, + input_size: Optional[int] = None, + hidden_size: Optional[int] = None, + output_size: Optional[int] = None, + pattern_size: Optional[int] = None, + num_heads: int = 1, + scaling: Optional[Union[float, Tensor]] = None, + update_steps_max: Optional[Union[int, Tensor]] = 0, + update_steps_eps: Union[float, Tensor] = 1e-4, + + normalize_stored_pattern: bool = True, + normalize_stored_pattern_affine: bool = True, + normalize_state_pattern: bool = True, + normalize_state_pattern_affine: bool = True, + normalize_pattern_projection: bool = True, + normalize_pattern_projection_affine: bool = True, + normalize_hopfield_space: bool = False, + normalize_hopfield_space_affine: bool = False, + stored_pattern_as_static: bool = False, + state_pattern_as_static: bool = False, + pattern_projection_as_static: bool = False, + pattern_projection_as_connected: bool = False, + stored_pattern_size: Optional[int] = None, + pattern_projection_size: Optional[int] = None, + + batch_first: bool = True, + association_activation: Optional[str] = None, + dropout: float = 0.0, + input_bias: bool = True, + concat_bias_pattern: bool = False, + add_zero_association: bool = False, + disable_out_projection: bool = False + ): + """ + Initialise new instance of a Hopfield module. + + :param input_size: depth of the input (state pattern) + :param hidden_size: depth of the association space + :param output_size: depth of the output projection + :param pattern_size: depth of patterns to be selected + :param num_heads: amount of parallel association heads + :param scaling: scaling of association heads, often represented as beta (one entry per head) + :param update_steps_max: maximum count of association update steps (None equals to infinity) + :param update_steps_eps: minimum difference threshold between two consecutive association update steps + :param normalize_stored_pattern: apply normalization on stored patterns + :param normalize_stored_pattern_affine: additionally enable affine normalization of stored patterns + :param normalize_state_pattern: apply normalization on state patterns + :param normalize_state_pattern_affine: additionally enable affine normalization of state patterns + :param normalize_pattern_projection: apply normalization on the pattern projection + :param normalize_pattern_projection_affine: additionally enable affine normalization of pattern projection + :param normalize_hopfield_space: enable normalization of patterns in the Hopfield space + :param normalize_hopfield_space_affine: additionally enable affine normalization of patterns in Hopfield space + :param stored_pattern_as_static: interpret specified stored patterns as being static + :param state_pattern_as_static: interpret specified state patterns as being static + :param pattern_projection_as_static: interpret specified pattern projections as being static + :param pattern_projection_as_connected: connect pattern projection with stored pattern + :param stored_pattern_size: depth of input (stored pattern) + :param pattern_projection_size: depth of input (pattern projection) + :param batch_first: flag for specifying if the first dimension of data fed to "forward" reflects the batch size + :param association_activation: additional activation to be applied on the result of the Hopfield association + :param dropout: dropout probability applied on the association matrix + :param input_bias: bias to be added to input (state and stored pattern as well as pattern projection) + :param concat_bias_pattern: bias to be concatenated to stored pattern as well as pattern projection + :param add_zero_association: add a new batch of zeros to stored pattern as well as pattern projection + :param disable_out_projection: disable output projection + """ + super(Hopfield, self).__init__() + assert type(batch_first) == bool, f'"batch_first" needs to be a boolean, not {type(batch_first)}.' + assert (association_activation is None) or (type(association_activation) == str) + + # Initialise Hopfield association module. + self.association_core = HopfieldCore( + embed_dim=input_size, num_heads=num_heads, dropout=dropout, bias=input_bias, + add_bias_kv=concat_bias_pattern, add_zero_attn=add_zero_association, kdim=stored_pattern_size, + vdim=pattern_projection_size, head_dim=hidden_size, pattern_dim=pattern_size, out_dim=output_size, + disable_out_projection=disable_out_projection, key_as_static=stored_pattern_as_static, + query_as_static=state_pattern_as_static, value_as_static=pattern_projection_as_static, + value_as_connected=pattern_projection_as_connected, normalize_pattern=normalize_hopfield_space, + normalize_pattern_affine=normalize_hopfield_space_affine) + self.association_activation = None + if association_activation is not None: + self.association_activation = getattr(torch, association_activation, None) + + # Initialise stored pattern normalization. + self.norm_stored_pattern = None + if normalize_stored_pattern_affine: + assert normalize_stored_pattern, "affine normalization without normalization has no effect." + if normalize_stored_pattern: + normalized_shape = input_size if stored_pattern_size is None else stored_pattern_size + assert normalized_shape is not None, "stored pattern size required for setting up normalisation" + self.norm_stored_pattern = nn.LayerNorm( + normalized_shape=normalized_shape, elementwise_affine=normalize_stored_pattern_affine) + + # Initialise state pattern normalization. + self.norm_state_pattern = None + if normalize_state_pattern_affine: + assert normalize_state_pattern, "affine normalization without normalization has no effect." + if normalize_state_pattern: + assert input_size is not None, "input size required for setting up normalisation" + self.norm_state_pattern = nn.LayerNorm( + normalized_shape=input_size, elementwise_affine=normalize_state_pattern_affine) + + # Initialise pattern projection normalization. + self.norm_pattern_projection = None + if normalize_pattern_projection_affine: + assert normalize_pattern_projection, "affine normalization without normalization has no effect." + if normalize_pattern_projection: + normalized_shape = input_size if pattern_projection_size is None else pattern_projection_size + assert normalized_shape is not None, "pattern projection size required for setting up normalisation" + self.norm_pattern_projection = nn.LayerNorm( + normalized_shape=normalized_shape, elementwise_affine=normalize_pattern_projection_affine) + + # Initialise remaining auxiliary properties. + if self.association_core.static_execution: + self.__scaling = 1.0 if scaling is None else scaling + else: + assert self.association_core.head_dim > 0, f'invalid hidden dimension encountered.' + self.__scaling = (1.0 / sqrt(self.association_core.head_dim)) if scaling is None else scaling + self.__batch_first = batch_first + self.__update_steps_max = update_steps_max + self.__update_steps_eps = update_steps_eps + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset Hopfield association. + + :return: None + """ + for module in (self.association_core, self.norm_stored_pattern, + self.norm_state_pattern, self.norm_pattern_projection): + if hasattr(module, r'reset_parameters'): + module.reset_parameters() + + def _maybe_transpose(self, *args: Tuple[Tensor, ...]) -> Union[Tensor, Tuple[Tensor, ...]]: + """ + Eventually transpose specified data. + + :param args: tensors to eventually transpose (dependent on the state of "batch_first") + :return: eventually transposed tensors + """ + transposed_result = tuple(_.transpose(0, 1) for _ in args) if self.__batch_first else args + return transposed_result[0] if len(transposed_result) == 1 else transposed_result + + def _associate(self, data: Union[Tensor, Tuple[Tensor, Tensor, Tensor]], + return_raw_associations: bool = False, return_projected_patterns: bool = False, + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tuple[Optional[Tensor], ...]: + """ + Apply Hopfield association module on specified data. + + :param data: data to be processed by Hopfield core module + :param return_raw_associations: return raw association (softmax) values, unmodified + :param return_projected_patterns: return pattern projection values, unmodified + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: Hopfield-processed input data + """ + assert (type(data) == Tensor) or ((type(data) == tuple) and (len(data) == 3)), \ + r'either one tensor to be used as "stored pattern", "state pattern" and' \ + r' "pattern_projection" must be provided, or three separate ones.' + if type(data) == Tensor: + stored_pattern, state_pattern, pattern_projection = data, data, data + else: + stored_pattern, state_pattern, pattern_projection = data + + # Optionally transpose data. + stored_pattern, state_pattern, pattern_projection = self._maybe_transpose( + stored_pattern, state_pattern, pattern_projection) + + # Optionally apply stored pattern normalization. + if self.norm_stored_pattern is not None: + stored_pattern = self.norm_stored_pattern(input=stored_pattern.reshape( + shape=(-1, stored_pattern.shape[2]))).reshape(shape=stored_pattern.shape) + + # Optionally apply state pattern normalization. + if self.norm_state_pattern is not None: + state_pattern = self.norm_state_pattern(input=state_pattern.reshape( + shape=(-1, state_pattern.shape[2]))).reshape(shape=state_pattern.shape) + + # Optionally apply pattern projection normalization. + if self.norm_pattern_projection is not None: + pattern_projection = self.norm_pattern_projection(input=pattern_projection.reshape( + shape=(-1, pattern_projection.shape[2]))).reshape(shape=pattern_projection.shape) + + # Apply Hopfield association and optional activation function. + return self.association_core( + query=state_pattern, key=stored_pattern, value=pattern_projection, + key_padding_mask=stored_pattern_padding_mask, need_weights=False, attn_mask=association_mask, + scaling=self.__scaling, update_steps_max=self.__update_steps_max, update_steps_eps=self.__update_steps_eps, + return_raw_associations=return_raw_associations, return_pattern_projections=return_projected_patterns) + + def forward(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Apply Hopfield association on specified data. + + :param input: data to be processed by Hopfield association module + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: Hopfield-processed input data + """ + association_output = self._maybe_transpose(self._associate( + data=input, return_raw_associations=False, + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask)[0]) + if self.association_activation is not None: + association_output = self.association_activation(association_output) + return association_output + + def get_association_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield association matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: association matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self._associate( + data=input, return_raw_associations=True, + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask)[2] + + def get_projected_pattern_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield projected pattern matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: pattern projection matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self._associate( + data=input, return_projected_patterns=True, + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask)[3] + + @property + def batch_first(self) -> bool: + return self.__batch_first + + @property + def scaling(self) -> Union[float, Tensor]: + return self.__scaling.clone() if type(self.__scaling) == Tensor else self.__scaling + + @property + def stored_pattern_dim(self) -> Optional[int]: + return self.association_core.kdim + + @property + def state_pattern_dim(self) -> Optional[int]: + return self.association_core.embed_dim + + @property + def pattern_projection_dim(self) -> Optional[int]: + return self.association_core.vdim + + @property + def input_size(self) -> Optional[int]: + return self.state_pattern_dim + + @property + def hidden_size(self) -> Optional[int]: + return self.association_core.head_dim + + @property + def output_size(self) -> Optional[int]: + return self.association_core.out_dim + + @property + def pattern_size(self) -> Optional[int]: + return self.association_core.pattern_dim + + @property + def update_steps_max(self) -> Optional[Union[int, Tensor]]: + return self.__update_steps_max.clone() if type(self.__update_steps_max) == Tensor else self.__update_steps_max + + @property + def update_steps_eps(self) -> Optional[Union[float, Tensor]]: + return self.__update_steps_eps.clone() if type(self.__update_steps_eps) == Tensor else self.__update_steps_eps + + @property + def stored_pattern_as_static(self) -> bool: + return self.association_core.key_as_static + + @property + def state_pattern_as_static(self) -> bool: + return self.association_core.query_as_static + + @property + def pattern_projection_as_static(self) -> bool: + return self.association_core.value_as_static + + @property + def normalize_stored_pattern(self) -> bool: + return self.norm_stored_pattern is not None + + @property + def normalize_stored_pattern_affine(self) -> bool: + return self.normalize_stored_pattern and self.norm_stored_pattern.elementwise_affine + + @property + def normalize_state_pattern(self) -> bool: + return self.norm_state_pattern is not None + + @property + def normalize_state_pattern_affine(self) -> bool: + return self.normalize_state_pattern and self.norm_state_pattern.elementwise_affine + + @property + def normalize_pattern_projection(self) -> bool: + return self.norm_pattern_projection is not None + + @property + def normalize_pattern_projection_affine(self) -> bool: + return self.normalize_pattern_projection and self.norm_pattern_projection.elementwise_affine + + @property + def normalize_hopfield_space(self) -> bool: + return self.hopfield.normalize_hopfield_space + + @property + def normalize_hopfield_space_affine(self) -> bool: + return self.hopfield.normalize_hopfield_space_affine + + +class HopfieldPooling(Module): + """ + Wrapper class encapsulating a trainable but fixed state pattern and "Hopfield" in + one combined module to be used as a Hopfield-based pooling layer. + """ + + def __init__(self, + input_size: int, + hidden_size: Optional[int] = None, + output_size: Optional[int] = None, + pattern_size: Optional[int] = None, + num_heads: int = 1, + scaling: Optional[Union[float, Tensor]] = None, + update_steps_max: Optional[Union[int, Tensor]] = 0, + update_steps_eps: Union[float, Tensor] = 1e-4, + + normalize_stored_pattern: bool = True, + normalize_stored_pattern_affine: bool = True, + normalize_state_pattern: bool = True, + normalize_state_pattern_affine: bool = True, + normalize_pattern_projection: bool = True, + normalize_pattern_projection_affine: bool = True, + normalize_hopfield_space: bool = False, + normalize_hopfield_space_affine: bool = False, + stored_pattern_as_static: bool = False, + state_pattern_as_static: bool = False, + pattern_projection_as_static: bool = False, + pattern_projection_as_connected: bool = False, + stored_pattern_size: Optional[int] = None, + pattern_projection_size: Optional[int] = None, + + batch_first: bool = True, + association_activation: Optional[str] = None, + dropout: float = 0.0, + input_bias: bool = True, + concat_bias_pattern: bool = False, + add_zero_association: bool = False, + disable_out_projection: bool = False, + quantity: int = 1, + trainable: bool = True + ): + """ + Initialise a new instance of a Hopfield-based pooling layer. + + :param input_size: depth of the input (state pattern) + :param hidden_size: depth of the association space + :param output_size: depth of the output projection + :param pattern_size: depth of patterns to be selected + :param num_heads: amount of parallel association heads + :param scaling: scaling of association heads, often represented as beta (one entry per head) + :param update_steps_max: maximum count of association update steps (None equals to infinity) + :param update_steps_eps: minimum difference threshold between two consecutive association update steps + :param normalize_stored_pattern: apply normalization on stored patterns + :param normalize_stored_pattern_affine: additionally enable affine normalization of stored patterns + :param normalize_state_pattern: apply normalization on state patterns + :param normalize_state_pattern_affine: additionally enable affine normalization of state patterns + :param normalize_pattern_projection: apply normalization on the pattern projection + :param normalize_pattern_projection_affine: additionally enable affine normalization of pattern projection + :param normalize_hopfield_space: enable normalization of patterns in the Hopfield space + :param normalize_hopfield_space_affine: additionally enable affine normalization of patterns in Hopfield space + :param stored_pattern_as_static: interpret specified stored patterns as being static + :param state_pattern_as_static: interpret specified state patterns as being static + :param pattern_projection_as_static: interpret specified pattern projections as being static + :param pattern_projection_as_connected: connect pattern projection with stored pattern + :param stored_pattern_size: depth of input (stored pattern) + :param pattern_projection_size: depth of input (pattern projection) + :param batch_first: flag for specifying if the first dimension of data fed to "forward" reflects the batch size + :param association_activation: additional activation to be applied on the result of the Hopfield association + :param dropout: dropout probability applied on the association matrix + :param input_bias: bias to be added to input (state and stored pattern as well as pattern projection) + :param concat_bias_pattern: bias to be concatenated to stored pattern as well as pattern projection + :param add_zero_association: add a new batch of zeros to stored pattern as well as pattern projection + :param disable_out_projection: disable output projection + :param quantity: amount of state patterns + :param trainable: state pattern used for pooling is trainable + """ + super(HopfieldPooling, self).__init__() + self.hopfield = Hopfield( + input_size=input_size, hidden_size=hidden_size, output_size=output_size, pattern_size=pattern_size, + num_heads=num_heads, scaling=scaling, update_steps_max=update_steps_max, update_steps_eps=update_steps_eps, + normalize_stored_pattern=normalize_stored_pattern, + normalize_stored_pattern_affine=normalize_stored_pattern_affine, + normalize_state_pattern=normalize_state_pattern, + normalize_state_pattern_affine=normalize_state_pattern_affine, + normalize_pattern_projection=normalize_pattern_projection, + normalize_pattern_projection_affine=normalize_pattern_projection_affine, + normalize_hopfield_space=normalize_hopfield_space, + normalize_hopfield_space_affine=normalize_hopfield_space_affine, + stored_pattern_as_static=stored_pattern_as_static, state_pattern_as_static=state_pattern_as_static, + pattern_projection_as_static=pattern_projection_as_static, + pattern_projection_as_connected=pattern_projection_as_connected, stored_pattern_size=stored_pattern_size, + pattern_projection_size=pattern_projection_size, batch_first=batch_first, + association_activation=association_activation, dropout=dropout, input_bias=input_bias, + concat_bias_pattern=concat_bias_pattern, add_zero_association=add_zero_association, + disable_out_projection=disable_out_projection) + self._quantity = quantity + pooling_weight_size = self.hopfield.hidden_size if state_pattern_as_static else self.hopfield.input_size + self.pooling_weights = nn.Parameter(torch.empty(size=(*( + (1, quantity) if batch_first else (quantity, 1) + ), input_size if pooling_weight_size is None else pooling_weight_size)), requires_grad=trainable) + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset pooling weights and underlying Hopfield association. + + :return: None + """ + if hasattr(self.hopfield, r'reset_parameters'): + self.hopfield.reset_parameters() + + # Explicitly initialise pooling weights. + nn.init.normal_(self.pooling_weights, mean=0.0, std=0.02) + + def _prepare_input(self, input: Union[Tensor, Tuple[Tensor, Tensor]]) -> Tuple[Tensor, Tensor, Tensor]: + """ + Prepare input for Hopfield association. + + :param input: data to be prepared + :return: stored pattern, expanded state pattern as well as pattern projection + """ + assert (type(input) == Tensor) or ((type(input) == tuple) and (len(input) == 2)), \ + r'either one tensor to be used as "stored pattern" and' \ + r' "pattern_projection" must be provided, or two separate ones.' + if type(input) == Tensor: + stored_pattern, pattern_projection = input, input + else: + stored_pattern, pattern_projection = input + + batch_size = stored_pattern.shape[0 if self.batch_first else 1] + return stored_pattern, self.pooling_weights.expand(size=(*( + (batch_size, self.quantity) if self.batch_first else (self.quantity, batch_size) + ), self.pooling_weights.shape[2])), pattern_projection + + def forward(self, input: Union[Tensor, Tuple[Tensor, Tensor]], stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Compute Hopfield-based pooling on specified data. + + :param input: data to be pooled + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: Hopfield-pooled input data + """ + return self.hopfield( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask).flatten(start_dim=1) + + def get_association_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield association matrix used for pooling gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: association matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self.hopfield.get_association_matrix( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + def get_projected_pattern_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield projected pattern matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: pattern projection matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self.hopfield.get_projected_pattern_matrix( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + @property + def batch_first(self) -> bool: + return self.hopfield.batch_first + + @property + def scaling(self) -> Union[float, Tensor]: + return self.hopfield.scaling + + @property + def stored_pattern_dim(self) -> Optional[int]: + return self.hopfield.stored_pattern_dim + + @property + def state_pattern_dim(self) -> Optional[int]: + return self.hopfield.state_pattern_dim + + @property + def pattern_projection_dim(self) -> Optional[int]: + return self.hopfield.pattern_projection_dim + + @property + def input_size(self) -> Optional[int]: + return self.hopfield.input_size + + @property + def hidden_size(self) -> int: + return self.hopfield.hidden_size + + @property + def output_size(self) -> Optional[int]: + return self.hopfield.output_size + + @property + def pattern_size(self) -> Optional[int]: + return self.hopfield.pattern_size + + @property + def quantity(self) -> int: + return self._quantity + + @property + def update_steps_max(self) -> Optional[Union[int, Tensor]]: + return self.hopfield.update_steps_max + + @property + def update_steps_eps(self) -> Optional[Union[float, Tensor]]: + return self.hopfield.update_steps_eps + + @property + def stored_pattern_as_static(self) -> bool: + return self.hopfield.stored_pattern_as_static + + @property + def state_pattern_as_static(self) -> bool: + return self.hopfield.state_pattern_as_static + + @property + def pattern_projection_as_static(self) -> bool: + return self.hopfield.pattern_projection_as_static + + @property + def normalize_stored_pattern(self) -> bool: + return self.hopfield.normalize_stored_pattern + + @property + def normalize_stored_pattern_affine(self) -> bool: + return self.hopfield.normalize_stored_pattern_affine + + @property + def normalize_state_pattern(self) -> bool: + return self.hopfield.normalize_state_pattern + + @property + def normalize_state_pattern_affine(self) -> bool: + return self.hopfield.normalize_state_pattern_affine + + @property + def normalize_pattern_projection(self) -> bool: + return self.hopfield.normalize_pattern_projection + + @property + def normalize_pattern_projection_affine(self) -> bool: + return self.hopfield.normalize_pattern_projection_affine + + +class HopfieldLayer(Module): + """ + Wrapper class encapsulating a trainable but fixed stored pattern, pattern projection and "Hopfield" in + one combined module to be used as a Hopfield-based pooling layer. + """ + + def __init__(self, + input_size: int, + hidden_size: Optional[int] = None, + output_size: Optional[int] = None, + pattern_size: Optional[int] = None, + num_heads: int = 1, + scaling: Optional[Union[float, Tensor]] = None, + update_steps_max: Optional[Union[int, Tensor]] = 0, + update_steps_eps: Union[float, Tensor] = 1e-4, + lookup_weights_as_separated: bool = False, + lookup_targets_as_trainable: bool = True, + + normalize_stored_pattern: bool = True, + normalize_stored_pattern_affine: bool = True, + normalize_state_pattern: bool = True, + normalize_state_pattern_affine: bool = True, + normalize_pattern_projection: bool = True, + normalize_pattern_projection_affine: bool = True, + normalize_hopfield_space: bool = False, + normalize_hopfield_space_affine: bool = False, + stored_pattern_as_static: bool = False, + state_pattern_as_static: bool = False, + pattern_projection_as_static: bool = False, + pattern_projection_as_connected: bool = False, + stored_pattern_size: Optional[int] = None, + pattern_projection_size: Optional[int] = None, + + batch_first: bool = True, + association_activation: Optional[str] = None, + dropout: float = 0.0, + input_bias: bool = True, + concat_bias_pattern: bool = False, + add_zero_association: bool = False, + disable_out_projection: bool = False, + quantity: int = 1, + trainable: bool = True + ): + """ + Initialise a new instance of a Hopfield-based lookup layer. + + :param input_size: depth of the input (state pattern) + :param hidden_size: depth of the association space + :param output_size: depth of the output projection + :param pattern_size: depth of patterns to be selected + :param num_heads: amount of parallel association heads + :param scaling: scaling of association heads, often represented as beta (one entry per head) + :param update_steps_max: maximum count of association update steps (None equals to infinity) + :param update_steps_eps: minimum difference threshold between two consecutive association update steps + :param lookup_weights_as_separated: separate lookup weights from lookup target weights + :param lookup_targets_as_trainable: employ trainable lookup target weights (used as pattern projection input) + :param normalize_stored_pattern: apply normalization on stored patterns + :param normalize_stored_pattern_affine: additionally enable affine normalization of stored patterns + :param normalize_state_pattern: apply normalization on state patterns + :param normalize_state_pattern_affine: additionally enable affine normalization of state patterns + :param normalize_pattern_projection: apply normalization on the pattern projection + :param normalize_pattern_projection_affine: additionally enable affine normalization of pattern projection + :param normalize_hopfield_space: enable normalization of patterns in the Hopfield space + :param normalize_hopfield_space_affine: additionally enable affine normalization of patterns in Hopfield space + :param stored_pattern_as_static: interpret specified stored patterns as being static + :param state_pattern_as_static: interpret specified state patterns as being static + :param pattern_projection_as_static: interpret specified pattern projections as being static + :param pattern_projection_as_connected: connect pattern projection with stored pattern + :param stored_pattern_size: depth of input (stored pattern) + :param pattern_projection_size: depth of input (pattern projection) + :param batch_first: flag for specifying if the first dimension of data fed to "forward" reflects the batch size + :param association_activation: additional activation to be applied on the result of the Hopfield association + :param dropout: dropout probability applied on the association matrix + :param input_bias: bias to be added to input (state and stored pattern as well as pattern projection) + :param concat_bias_pattern: bias to be concatenated to stored pattern as well as pattern projection + :param add_zero_association: add a new batch of zeros to stored pattern as well as pattern projection + :param disable_out_projection: disable output projection + :param quantity: amount of stored patterns + :param trainable: stored pattern used for lookup is trainable + """ + super(HopfieldLayer, self).__init__() + self.hopfield = Hopfield( + input_size=input_size, hidden_size=hidden_size, output_size=output_size, pattern_size=pattern_size, + num_heads=num_heads, scaling=scaling, update_steps_max=update_steps_max, update_steps_eps=update_steps_eps, + normalize_stored_pattern=normalize_stored_pattern, + normalize_stored_pattern_affine=normalize_stored_pattern_affine, + normalize_state_pattern=normalize_state_pattern, + normalize_state_pattern_affine=normalize_state_pattern_affine, + normalize_pattern_projection=normalize_pattern_projection, + normalize_pattern_projection_affine=normalize_pattern_projection_affine, + normalize_hopfield_space=normalize_hopfield_space, + normalize_hopfield_space_affine=normalize_hopfield_space_affine, + stored_pattern_as_static=stored_pattern_as_static, state_pattern_as_static=state_pattern_as_static, + pattern_projection_as_static=pattern_projection_as_static, + pattern_projection_as_connected=pattern_projection_as_connected, stored_pattern_size=stored_pattern_size, + pattern_projection_size=pattern_projection_size, batch_first=batch_first, + association_activation=association_activation, dropout=dropout, input_bias=input_bias, + concat_bias_pattern=concat_bias_pattern, add_zero_association=add_zero_association, + disable_out_projection=disable_out_projection) + self._quantity = quantity + lookup_weight_size = self.hopfield.hidden_size if stored_pattern_as_static else self.hopfield.stored_pattern_dim + self.lookup_weights = nn.Parameter(torch.empty(size=(*( + (1, quantity) if batch_first else (quantity, 1) + ), input_size if lookup_weight_size is None else lookup_weight_size)), requires_grad=trainable) + + if lookup_weights_as_separated: + target_weight_size = self.lookup_weights.shape[ + 2] if pattern_projection_size is None else pattern_projection_size + self.target_weights = nn.Parameter(torch.empty(size=(*( + (1, quantity) if batch_first else (quantity, 1) + ), target_weight_size)), requires_grad=lookup_targets_as_trainable) + else: + self.register_parameter(name=r'target_weights', param=None) + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset lookup and lookup target weights, including underlying Hopfield association. + + :return: None + """ + if hasattr(self.hopfield, r'reset_parameters'): + self.hopfield.reset_parameters() + + # Explicitly initialise lookup and target weights. + nn.init.normal_(self.lookup_weights, mean=0.0, std=0.02) + if self.target_weights is not None: + nn.init.normal_(self.target_weights, mean=0.0, std=0.02) + + def _prepare_input(self, input: Tensor) -> Tuple[Tensor, Tensor, Tensor]: + """ + Prepare input for Hopfield association. + + :param input: data to be prepared + :return: stored pattern, expanded state pattern as well as pattern projection + """ + batch_size = input.shape[0 if self.batch_first else 1] + stored_pattern = self.lookup_weights.expand(size=(*( + (batch_size, self.quantity) if self.batch_first else (self.quantity, batch_size) + ), self.lookup_weights.shape[2])) + if self.target_weights is None: + pattern_projection = stored_pattern + else: + pattern_projection = self.target_weights.expand(size=(*( + (batch_size, self.quantity) if self.batch_first else (self.quantity, batch_size) + ), self.target_weights.shape[2])) + + return stored_pattern, input, pattern_projection + + def forward(self, input: Tensor, stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Compute Hopfield-based lookup on specified data. + + :param input: data to used in lookup + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: result of Hopfield-based lookup on input data + """ + return self.hopfield( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + def get_association_matrix(self, input: Tensor, stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield association matrix used for lookup gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: association matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self.hopfield.get_association_matrix( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + def get_projected_pattern_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor]], + stored_pattern_padding_mask: Optional[Tensor] = None, + association_mask: Optional[Tensor] = None) -> Tensor: + """ + Fetch Hopfield projected pattern matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :param stored_pattern_padding_mask: mask to be applied on stored patterns + :param association_mask: mask to be applied on inner association matrix + :return: pattern projection matrix as computed by the Hopfield core module + """ + with torch.no_grad(): + return self.hopfield.get_projected_pattern_matrix( + input=self._prepare_input(input=input), + stored_pattern_padding_mask=stored_pattern_padding_mask, + association_mask=association_mask) + + @property + def batch_first(self) -> bool: + return self.hopfield.batch_first + + @property + def scaling(self) -> Union[float, Tensor]: + return self.hopfield.scaling + + @property + def stored_pattern_dim(self) -> Optional[int]: + return self.hopfield.stored_pattern_dim + + @property + def state_pattern_dim(self) -> Optional[int]: + return self.hopfield.state_pattern_dim + + @property + def pattern_projection_dim(self) -> Optional[int]: + return self.hopfield.pattern_projection_dim + + @property + def input_size(self) -> Optional[int]: + return self.hopfield.input_size + + @property + def hidden_size(self) -> int: + return self.hopfield.hidden_size + + @property + def output_size(self) -> Optional[int]: + return self.hopfield.output_size + + @property + def pattern_size(self) -> Optional[int]: + return self.hopfield.pattern_size + + @property + def quantity(self) -> int: + return self._quantity + + @property + def update_steps_max(self) -> Optional[Union[int, Tensor]]: + return self.hopfield.update_steps_max + + @property + def update_steps_eps(self) -> Optional[Union[float, Tensor]]: + return self.hopfield.update_steps_eps + + @property + def stored_pattern_as_static(self) -> bool: + return self.hopfield.stored_pattern_as_static + + @property + def state_pattern_as_static(self) -> bool: + return self.hopfield.state_pattern_as_static + + @property + def pattern_projection_as_static(self) -> bool: + return self.hopfield.pattern_projection_as_static + + @property + def normalize_stored_pattern(self) -> bool: + return self.hopfield.normalize_stored_pattern + + @property + def normalize_stored_pattern_affine(self) -> bool: + return self.hopfield.normalize_stored_pattern_affine + + @property + def normalize_state_pattern(self) -> bool: + return self.hopfield.normalize_state_pattern + + @property + def normalize_state_pattern_affine(self) -> bool: + return self.hopfield.normalize_state_pattern_affine + + @property + def normalize_pattern_projection(self) -> bool: + return self.hopfield.normalize_pattern_projection + + @property + def normalize_pattern_projection_affine(self) -> bool: + return self.hopfield.normalize_pattern_projection_affine diff --git a/src/mhnfs/hopfield/modules/__pycache__/__init__.cpython-37.pyc b/src/mhnfs/hopfield/modules/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fbd9b3c90d8ce62bd7a17c050da6cff3fd01e226 Binary files /dev/null and b/src/mhnfs/hopfield/modules/__pycache__/__init__.cpython-37.pyc differ diff --git a/src/mhnfs/hopfield/modules/__pycache__/__init__.cpython-38.pyc b/src/mhnfs/hopfield/modules/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..95278bbf7a3923658822391d5b1433e5b750c165 Binary files /dev/null and b/src/mhnfs/hopfield/modules/__pycache__/__init__.cpython-38.pyc differ diff --git a/src/mhnfs/hopfield/modules/__pycache__/__init__.cpython-39.pyc b/src/mhnfs/hopfield/modules/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dadf35bb102978b133cf39fc9c256dd53730aecf Binary files /dev/null and b/src/mhnfs/hopfield/modules/__pycache__/__init__.cpython-39.pyc differ diff --git a/src/mhnfs/hopfield/modules/__pycache__/activation.cpython-37.pyc b/src/mhnfs/hopfield/modules/__pycache__/activation.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..30ba1f5f8709e4c6910d179dbbba71bc629b944e Binary files /dev/null and b/src/mhnfs/hopfield/modules/__pycache__/activation.cpython-37.pyc differ diff --git a/src/mhnfs/hopfield/modules/__pycache__/activation.cpython-38.pyc b/src/mhnfs/hopfield/modules/__pycache__/activation.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..546029f7a27cdd97a69876aeb23f5e28942e5dc4 Binary files /dev/null and b/src/mhnfs/hopfield/modules/__pycache__/activation.cpython-38.pyc differ diff --git a/src/mhnfs/hopfield/modules/__pycache__/activation.cpython-39.pyc b/src/mhnfs/hopfield/modules/__pycache__/activation.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bb910f32c6ced43766d7117d2afe7d9b84114ed3 Binary files /dev/null and b/src/mhnfs/hopfield/modules/__pycache__/activation.cpython-39.pyc differ diff --git a/src/mhnfs/hopfield/modules/__pycache__/functional.cpython-37.pyc b/src/mhnfs/hopfield/modules/__pycache__/functional.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6924f592598e3b8e995d8cdd7144a4680c4e4265 Binary files /dev/null and b/src/mhnfs/hopfield/modules/__pycache__/functional.cpython-37.pyc differ diff --git a/src/mhnfs/hopfield/modules/__pycache__/functional.cpython-38.pyc b/src/mhnfs/hopfield/modules/__pycache__/functional.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4a7bd2c4087f0d9f0208d51fe8fa0f65639d4fe1 Binary files /dev/null and b/src/mhnfs/hopfield/modules/__pycache__/functional.cpython-38.pyc differ diff --git a/src/mhnfs/hopfield/modules/__pycache__/functional.cpython-39.pyc b/src/mhnfs/hopfield/modules/__pycache__/functional.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef4132b40a9aacc1917b88569c6fe57bd96ed805 Binary files /dev/null and b/src/mhnfs/hopfield/modules/__pycache__/functional.cpython-39.pyc differ diff --git a/src/mhnfs/hopfield/modules/activation.py b/src/mhnfs/hopfield/modules/activation.py new file mode 100644 index 0000000000000000000000000000000000000000..a84b44154be6f4fbbcf275166d5e470a1e2c0f90 --- /dev/null +++ b/src/mhnfs/hopfield/modules/activation.py @@ -0,0 +1,449 @@ +import torch +import torch.nn as nn + +from torch import Tensor +from torch.nn import Linear, Module, Parameter +from typing import Optional + +from .functional import hopfield_core_forward + +try: + from torch.nn.modules.linear import _LinearWithBias +except ImportError: + _LinearWithBias = None + + +class HopfieldCore(Module): + """Allows the model to jointly attend to information + from different representation subspaces. + See references: "Hopfield Networks is All You Need" and + "Attention Is All You Need" (on which this implementation is partly based on). + + .. math:: + \text{HopfieldHead}(Q, K, V) = \text{Concat}(head_1,\dots,head_h)W^O + \text{where} head_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V) + + Args: + embed_dim: total dimension of the model. + num_heads: parallel attention heads. + dropout: a Dropout layer on attn_output_weights. Default: 0.0. + bias: add bias as module parameter. Default: True. + add_bias_kv: add bias to the key and value sequences at dim=0. + add_zero_attn: add a new batch of zeros to the key and + value sequences at dim=1. + kdim: total number of features in key. Default: None. + vdim: total number of features in value. Default: None. + + Note: if kdim and vdim are None, they will be set to embed_dim such that + query, key, and value have the same number of features. + + Examples:: + + >>> hopfield_attn = HopfieldCore(embed_dim, num_heads) + >>> attn_output, attn_output_weights, attn_matrix = hopfield_attn(query, key, value) + """ + + __annotations__ = { + "bias_k": torch._jit_internal.Optional[torch.Tensor], + "bias_v": torch._jit_internal.Optional[torch.Tensor], + } + + def __init__( + self, + embed_dim=None, # type: Optional[int] + num_heads=1, # type: int + dropout=0.0, # type: float + bias=True, # type: bool + add_bias_kv=False, # type: bool + add_zero_attn=False, # type: bool + kdim=None, # type: Optional[int] + vdim=None, # type: Optional[int] + head_dim=None, # type: Optional[int] + pattern_dim=None, # type: Optional[int] + out_dim=None, # type: Optional[int] + disable_out_projection=False, # type: bool + key_as_static=False, # type: bool + query_as_static=False, # type: bool + value_as_static=False, # type: bool + value_as_connected=False, # type: bool + normalize_pattern=False, # type: bool + normalize_pattern_affine=False, # type: bool + ): + super(HopfieldCore, self).__init__() + + assert ( + (type(key_as_static) == bool) + and (type(query_as_static) == bool) + and (type(value_as_static) == bool) + ) + self.key_as_static, self.query_as_static, self.value_as_static = ( + key_as_static, + query_as_static, + value_as_static, + ) + num_non_static = 3 - ( + self.key_as_static + self.query_as_static + self.value_as_static + ) + assert 0 <= num_non_static < 4 + + self.value_as_connected = value_as_connected + self.normalize_pattern, self.normalize_pattern_affine = ( + normalize_pattern, + normalize_pattern_affine, + ) + self.disable_out_projection = disable_out_projection + + # In case of a static-only executions, check corresponding projections and normalizations. + self.static_execution = self._check_execution_mode() + if self.static_execution: + embed_dim, kdim, vdim = None, None, None + if embed_dim is None: + assert ( + self.static_execution + ), r"static-only execution requires all projections to be deactivated." + + # Check and set all other properties, conditioned on . + self.embed_dim = embed_dim + self.kdim = kdim if kdim is not None else embed_dim + self.vdim = vdim if vdim is not None else embed_dim + self._qkv_same_embed_dim = all( + ( + self.kdim == embed_dim, + self.vdim == embed_dim, + pattern_dim is None, + not self.value_as_connected, + ) + ) + assert (not self.value_as_connected) or ( + self.kdim == self.vdim + ), r"key and value need to be of same dimension." + + self.num_heads = num_heads + self.dropout = dropout + self.head_dim = None + self.pattern_dim = pattern_dim + self.virtual_hopfield_dim = None + self.virtual_pattern_dim = None + if not self.static_execution: + if head_dim is None: + self.head_dim = embed_dim // num_heads + assert ( + self.head_dim * num_heads == self.embed_dim + ), "embed_dim must be divisible by num_heads." + else: + assert ( + head_dim > 0 + ), "dimension of the association space has to be positive." + self.head_dim = head_dim + if self.pattern_dim is None: + self.pattern_dim = self.head_dim + self.virtual_hopfield_dim = self.num_heads * self.head_dim + self.virtual_pattern_dim = self.num_heads * self.pattern_dim + + self.out_dim = embed_dim if out_dim is None else out_dim + assert disable_out_projection or ( + self.out_dim > 0 + ), "output projection dimension has to be positive." + + if normalize_pattern_affine: + assert ( + normalize_pattern + ), "affine pattern normalization without pattern normalization has no effect." + self.p_norm_weight = Parameter(torch.Tensor(head_dim)) + self.p_norm_bias = Parameter(torch.Tensor(head_dim)) + else: + self.register_parameter("p_norm_weight", None) + self.register_parameter("p_norm_bias", None) + + if self._qkv_same_embed_dim is False: + if query_as_static: + self.register_parameter("q_proj_weight", None) + else: + self.q_proj_weight = Parameter( + torch.Tensor(self.virtual_hopfield_dim, embed_dim) + ) + if key_as_static: + self.register_parameter("k_proj_weight", None) + else: + self.k_proj_weight = Parameter( + torch.Tensor(self.virtual_hopfield_dim, self.kdim) + ) + if value_as_static: + self.register_parameter("v_proj_weight", None) + else: + self.v_proj_weight = Parameter( + torch.Tensor( + self.virtual_pattern_dim, + self.virtual_hopfield_dim + if (value_as_connected and not key_as_static) + else self.vdim, + ) + ) + self.register_parameter("in_proj_weight", None) + else: + if num_non_static > 0: + self.in_proj_weight = Parameter( + torch.empty( + (not query_as_static) * self.virtual_hopfield_dim + + (not key_as_static) * self.virtual_hopfield_dim + + (not value_as_static) * self.virtual_pattern_dim, + embed_dim, + ) + ) + else: + self.register_parameter("in_proj_weight", None) + self.register_parameter("q_proj_weight", None) + self.register_parameter("k_proj_weight", None) + self.register_parameter("v_proj_weight", None) + + if bias and (num_non_static > 0): + self.in_proj_bias = Parameter( + torch.empty( + (not query_as_static) * self.virtual_hopfield_dim + + (not key_as_static) * self.virtual_hopfield_dim + + self.virtual_pattern_dim + ) + ) + else: + self.register_parameter("in_proj_bias", None) + if disable_out_projection: + self.register_parameter("out_proj", None) + else: + if bias and _LinearWithBias is not None: + self.out_proj = _LinearWithBias(self.virtual_pattern_dim, self.out_dim) + else: + self.out_proj = Linear( + self.virtual_pattern_dim, self.out_dim, bias=bias + ) + + self.bias_k, self.bias_v = None, None + if add_bias_kv: + if not key_as_static: + self.bias_k = Parameter(torch.empty(1, 1, self.virtual_hopfield_dim)) + if not value_as_static: + self.bias_v = Parameter(torch.empty(1, 1, self.virtual_hopfield_dim)) + assert not ( + self.bias_k is None and self.bias_v is None + ), r"cannot set key/value bias if both are static." + + self.add_zero_attn = add_zero_attn + self.reset_parameters() + + def _check_execution_mode(self) -> bool: + return all( + ( + self.key_as_static, + self.query_as_static, + self.value_as_static, + not self.value_as_connected, + not self.normalize_pattern, + not self.normalize_pattern_affine, + self.disable_out_projection, + ) + ) + + def reset_parameters(self): + if self.p_norm_weight is not None: + nn.init.ones_(self.p_norm_weight) + nn.init.zeros_(self.p_norm_bias) + + if self._qkv_same_embed_dim and (self.in_proj_weight is not None): + nn.init.normal_(self.in_proj_weight, mean=0.0, std=0.02) + else: + if self.q_proj_weight is not None: + nn.init.normal_(self.q_proj_weight, mean=0.0, std=0.02) + if self.k_proj_weight is not None: + nn.init.normal_(self.k_proj_weight, mean=0.0, std=0.02) + if self.v_proj_weight is not None: + nn.init.normal_(self.v_proj_weight, mean=0.0, std=0.02) + + if self.in_proj_bias is not None: + nn.init.constant_(self.in_proj_bias, 0.0) + if not self.disable_out_projection: + nn.init.normal_(self.out_proj.weight, mean=0.0, std=0.02) + if self.out_proj.bias is not None: + nn.init.constant_(self.out_proj.bias, 0.0) + if self.bias_k is not None: + nn.init.normal_(self.bias_k, mean=0.0, std=0.02) + if self.bias_v is not None: + nn.init.normal_(self.bias_v, mean=0.0, std=0.02) + + def __setstate__(self, state): + super(HopfieldCore, self).__setstate__(state) + + def forward( + self, + query, # type: Tensor + key, # type: Tensor + value, # type: Tensor + key_padding_mask=None, # type: Optional[Tensor] + need_weights=True, # type: bool + attn_mask=None, # type: Optional[Tensor] + scaling=None, # type: Optional[Tensor] + update_steps_max=0, # type: Optional[int] + update_steps_eps=1e-4, # type: float + return_raw_associations=False, # type: bool + return_pattern_projections=False, # type: bool + ): + # type: (...) -> Tuple[Tensor, Optional[Tensor], Optional[Tensor]] + r""" + Args: + query, key, value: map a query and a set of key-value pairs to an output. + See "Attention Is All You Need" for more details. + See "Hopfield Networks is All You Need" for more details in the setting of Hopfield networks. + key_padding_mask: if provided, specified padding elements in the key will + be ignored by the attention. When given a binary mask and a value is True, + the corresponding value on the attention layer will be ignored. When given + a byte mask and a value is non-zero, the corresponding value on the attention + layer will be ignored. + need_weights: output attn_output_weights. + attn_mask: 2D or 3D mask that prevents attention to certain positions. A 2D mask will be broadcasted for all + the batches while a 3D mask allows to specify a different mask for the entries of each batch. + + scaling: scaling of association heads, often represented as beta (one entry per head). + update_steps_max: maximum count of association update steps (None equals to infinity). + update_steps_eps: minimum difference threshold between two consecutive association update steps. + return_raw_associations: return raw association (softmax) values, unmodified. + return_pattern_projections: return pattern projection values, unmodified. + + Shape: + - Inputs: + - query: :math:`(L, N, E)` where L is the target sequence length, N is the batch size, E is + the embedding dimension. + - key: :math:`(S, N, E)`, where S is the source sequence length, N is the batch size, E is + the embedding dimension. + - value: :math:`(S, N, E)` where S is the source sequence length, N is the batch size, E is + the embedding dimension. + - key_padding_mask: :math:`(N, S)` where N is the batch size, S is the source sequence length. + If a ByteTensor is provided, the non-zero positions will be ignored while the position + with the zero positions will be unchanged. If a BoolTensor is provided, the positions with the + value of ``True`` will be ignored while the position with the value of ``False`` will be unchanged. + - attn_mask: 2D mask :math:`(L, S)` where L is the target sequence length, S is the source sequence length. + 3D mask :math:`(N*num_heads, L, S)` where N is the batch size, L is the target sequence length, + S is the source sequence length. attn_mask ensure that position i is allowed to attend the unmasked + positions. If a ByteTensor is provided, the non-zero positions are not allowed to attend + while the zero positions will be unchanged. If a BoolTensor is provided, positions with ``True`` + is not allowed to attend while ``False`` values will be unchanged. If a FloatTensor + is provided, it will be added to the attention weight. + + - scaling: :math:`(num_heads,)`, where num_heads is the amount of heads. + + - Outputs: + - attn_output: :math:`(L, N, E)` where L is the target sequence length, N is the batch size, + E is the embedding dimension. + - attn_output_weights: :math:`(N, L, S)` where N is the batch size, + L is the target sequence length, S is the source sequence length. + - attn_raw: :math:``(N, num_heads, L, S)`, where N is the batch size, + L is the target sequence length, S is the source sequence length. + """ + if self.query_as_static and self.key_as_static: + assert ( + query.shape[2] == key.shape[2] + ), f"query shape[2] of {query.shape[2]} and key shape[2] of {key.shape[2]} need to be equal" + head_dim, embed_dim_to_check = query.shape[2], query.shape[2] + else: + assert self.query_as_static or ( + query.shape[2] == self.embed_dim + ), f"query shape[2] of {query.shape[2]} invalid, needs to be {self.embed_dim}." + assert (not self.query_as_static) or ( + self.query_as_static and query.shape[2] == self.head_dim + ), f"query shape[2] of {query.shape[2]} invalid, needs to be {self.head_dim}" + + assert self.key_as_static or ( + key.shape[2] == self.kdim + ), f"key shape[2] of {key.shape[2]} invalid, needs to be {self.kdim}." + assert (not self.key_as_static) or ( + self.key_as_static and key.shape[2] == self.head_dim + ), f"key shape[2] of {key.shape[2]} invalid, needs to be {self.head_dim}" + head_dim, embed_dim_to_check = ( + self.head_dim, + self.head_dim if self.query_as_static else self.embed_dim, + ) + + assert self.value_as_static or ( + value.shape[2] == self.vdim + ), f"value shape[2] of {value.shape[2]} invalid, needs to be {self.vdim}." + assert any( + ( + not self.value_as_static, + self.value_as_static and value.shape[2] == self.pattern_dim, + self.disable_out_projection, + ) + ), f"value shape[2] of {value.shape[2]} invalid, needs to be {self.pattern_dim}" + + out_weights, out_bias = None, None + if not self.disable_out_projection: + out_weights, out_bias = self.out_proj.weight, self.out_proj.bias + + if not self._qkv_same_embed_dim: + return hopfield_core_forward( + query=query, + key=key, + value=value, + embed_dim_to_check=embed_dim_to_check, + num_heads=self.num_heads, + in_proj_weight=self.in_proj_weight, + in_proj_bias=self.in_proj_bias, + bias_k=self.bias_k, + bias_v=self.bias_v, + add_zero_attn=self.add_zero_attn, + dropout_p=self.dropout, + out_proj_weight=out_weights, + out_proj_bias=out_bias, + training=self.training, + key_padding_mask=key_padding_mask, + need_weights=need_weights, + attn_mask=attn_mask, + use_separate_proj_weight=True, + q_proj_weight=self.q_proj_weight, + k_proj_weight=self.k_proj_weight, + v_proj_weight=self.v_proj_weight, + key_as_static=self.key_as_static, + query_as_static=self.query_as_static, + value_as_static=self.value_as_static, + value_as_connected=self.value_as_connected, + normalize_pattern=self.normalize_pattern, + p_norm_weight=self.p_norm_weight, + p_norm_bias=self.p_norm_bias, + head_dim=head_dim, + pattern_dim=self.pattern_dim, + scaling=scaling, + update_steps_max=update_steps_max, + update_steps_eps=update_steps_eps, + return_raw_associations=return_raw_associations, + return_projected_patterns=return_pattern_projections, + ) + else: + return hopfield_core_forward( + query=query, + key=key, + value=value, + embed_dim_to_check=embed_dim_to_check, + num_heads=self.num_heads, + in_proj_weight=self.in_proj_weight, + in_proj_bias=self.in_proj_bias, + bias_k=self.bias_k, + bias_v=self.bias_v, + add_zero_attn=self.add_zero_attn, + dropout_p=self.dropout, + out_proj_weight=out_weights, + out_proj_bias=out_bias, + training=self.training, + key_padding_mask=key_padding_mask, + need_weights=need_weights, + attn_mask=attn_mask, + key_as_static=self.key_as_static, + query_as_static=self.query_as_static, + value_as_static=self.value_as_static, + value_as_connected=self.value_as_connected, + normalize_pattern=self.normalize_pattern, + p_norm_weight=self.p_norm_weight, + p_norm_bias=self.p_norm_bias, + head_dim=head_dim, + pattern_dim=self.pattern_dim, + scaling=scaling, + update_steps_max=update_steps_max, + update_steps_eps=update_steps_eps, + return_raw_associations=return_raw_associations, + return_projected_patterns=return_pattern_projections, + ) diff --git a/src/mhnfs/hopfield/modules/functional.py b/src/mhnfs/hopfield/modules/functional.py new file mode 100644 index 0000000000000000000000000000000000000000..b3d429c272d3c06c0d96d72b084d7756a119de6c --- /dev/null +++ b/src/mhnfs/hopfield/modules/functional.py @@ -0,0 +1,450 @@ +import torch +import torch.nn as nn + +from torch import Tensor +from typing import Optional, Tuple, Union + + +def hopfield_core_forward(query, # type: Tensor + key, # type: Tensor + value, # type: Tensor + embed_dim_to_check, # type: int + num_heads, # type: int + in_proj_weight, # type: Optional[Tensor] + in_proj_bias, # type: Optional[Tensor] + bias_k, # type: Optional[Tensor] + bias_v, # type: Optional[Tensor] + add_zero_attn, # type: bool + dropout_p, # type: float + out_proj_weight, # type: Tensor + out_proj_bias, # type: Tensor + training=True, # type: bool + key_padding_mask=None, # type: Optional[Tensor] + need_weights=True, # type: bool + attn_mask=None, # type: Optional[Tensor] + use_separate_proj_weight=False, # type: bool + q_proj_weight=None, # type: Optional[Tensor] + k_proj_weight=None, # type: Optional[Tensor] + v_proj_weight=None, # type: Optional[Tensor] + static_k=None, # type: Optional[Tensor] + static_v=None, # type: Optional[Tensor] + + key_as_static=False, # type: bool + query_as_static=False, # type: bool + value_as_static=False, # type: bool + value_as_connected=False, # type: bool + normalize_pattern=False, # type: bool + p_norm_weight=None, # type: Optional[Tensor] + p_norm_bias=None, # type: Optional[Tensor] + head_dim=None, # type: Optional[int] + pattern_dim=None, # type: Optional[int] + scaling=None, # type: Optional[Union[float, Tensor]] + update_steps_max=0, # type: Optional[Union[int, Tensor]] + update_steps_eps=1e-4, # type: Union[float, Tensor] + return_raw_associations=False, # type: bool + return_projected_patterns=False # type: bool + ): + # type: (...) -> Tuple[Tensor, Optional[Tensor]] + r""" + Args: + query, key, value: map a query and a set of key-value pairs to an output. + See "Attention Is All You Need" for more details. + See "Hopfield Networks is All You Need" for more details in the setting of Hopfield networks. + embed_dim_to_check: total dimension of the model (in case of default head dimension). + num_heads: parallel attention heads. + in_proj_weight, in_proj_bias: input projection weight and bias. + bias_k, bias_v: bias of the key and value sequences to be added at dim=0. + add_zero_attn: add a new batch of zeros to the key and + value sequences at dim=1. + dropout_p: probability of an element to be zeroed. + out_proj_weight, out_proj_bias: the output projection weight and bias. + training: apply dropout if is ``True``. + key_padding_mask: if provided, specified padding elements in the key will + be ignored by the attention. This is an binary mask. When the value is True, + the corresponding value on the attention layer will be filled with -inf. + need_weights: output attn_output_weights. + attn_mask: 2D or 3D mask that prevents attention to certain positions. A 2D mask will be broadcasted for all + the batches while a 3D mask allows to specify a different mask for the entries of each batch. + use_separate_proj_weight: the function accept the proj. weights for query, key, + and value in different forms. If false, in_proj_weight will be used, which is + a combination of q_proj_weight, k_proj_weight, v_proj_weight. + q_proj_weight, k_proj_weight, v_proj_weight, in_proj_bias: input projection weight and bias. + static_k, static_v: static key and value used for attention operators. + + key_as_static: interpret specified key as being static. + query_as_static: interpret specified key as being static. + value_as_static: interpret specified key as being static. + value_as_connected: connect value projection with key projection. + normalize_pattern: enable normalization of patterns. + p_norm_weight, p_norm_bias: pattern normalization weight and bias. + head_dim: dimensionality of each head. + pattern_dim: dimensionality of each projected value input. + scaling: scaling of association heads, often represented as beta (one entry per head). + update_steps_max: maximum count of association update steps (None equals to infinity). + update_steps_eps: minimum difference threshold between two consecutive association update steps. + return_raw_associations: return raw association (softmax) values, unmodified. + return_projected_patterns: return pattern projection values, unmodified. + + Shape: + Inputs: + - query: :math:`(L, N, E)` where L is the target sequence length, N is the batch size, E is + the embedding dimension. + - key: :math:`(S, N, E)`, where S is the source sequence length, N is the batch size, E is + the embedding dimension. + - value: :math:`(S, N, E)` where S is the source sequence length, N is the batch size, E is + the embedding dimension. + - key_padding_mask: :math:`(N, S)` where N is the batch size, S is the source sequence length. + If a ByteTensor is provided, the non-zero positions will be ignored while the zero positions + will be unchanged. If a BoolTensor is provided, the positions with the + value of ``True`` will be ignored while the position with the value of ``False`` will be unchanged. + - attn_mask: 2D mask :math:`(L, S)` where L is the target sequence length, S is the source sequence length. + 3D mask :math:`(N*num_heads, L, S)` where N is the batch size, L is the target sequence length, + S is the source sequence length. attn_mask ensures that position i is allowed to attend the unmasked + positions. If a ByteTensor is provided, the non-zero positions are not allowed to attend + while the zero positions will be unchanged. If a BoolTensor is provided, positions with ``True`` + are not allowed to attend while ``False`` values will be unchanged. If a FloatTensor + is provided, it will be added to the attention weight. + - static_k: :math:`(N*num_heads, S, head_dim)`, where S is the source sequence length, N is the batch size. + - static_v: :math:`(N*num_heads, S, head_dim)`, where S is the source sequence length, N is the batch size. + + - scaling: :math:`(num_heads,)`, where num_heads is the amount of heads. + + Outputs: + - attn_output: :math:`(L, N, E)`, where L is the target sequence length, N is the batch size, + E is the embedding dimension. + - attn_output_weights: :math:`(N, L, S)`, where N is the batch size, + L is the target sequence length, S is the source sequence length. + - attn_raw: :math:``(N, num_heads, L, S)`, where N is the batch size, + L is the target sequence length, S is the source sequence length. + """ + if not torch.jit.is_scripting(): + tens_ops = (query, key, value, in_proj_weight, in_proj_bias, bias_k, bias_v, + out_proj_weight, out_proj_bias) + if any([type(t) is not Tensor for t in tens_ops]) and nn.functional.has_torch_function(tens_ops): + return nn.functional.handle_torch_function( + hopfield_core_forward, tens_ops, query, key, value, + embed_dim_to_check, num_heads, in_proj_weight, in_proj_bias, + bias_k, bias_v, add_zero_attn, dropout_p, out_proj_weight, + out_proj_bias, training=training, key_padding_mask=key_padding_mask, + need_weights=need_weights, attn_mask=attn_mask, + use_separate_proj_weight=use_separate_proj_weight, + q_proj_weight=q_proj_weight, k_proj_weight=k_proj_weight, + v_proj_weight=v_proj_weight, static_k=static_k, static_v=static_v, + key_as_static=key_as_static, query_as_static=query_as_static, + value_as_static=value_as_static, value_as_connected=value_as_connected, + normalize_pattern=normalize_pattern, p_norm_weight=p_norm_weight, p_norm_bias=p_norm_bias, + head_dim=head_dim, pattern_dim=pattern_dim, scaling=scaling, update_steps_max=update_steps_max, + update_steps_eps=update_steps_eps, return_raw_associations=return_raw_associations) + tgt_len, bsz, embed_dim = query.shape[0], value.shape[1], query.shape[2] + assert embed_dim == embed_dim_to_check + # allow MHA to have different sizes for the feature dimension + assert key.size(0) == value.size(0) and key.size(1) == value.size(1) + + assert (scaling is None) or (type(scaling) in (float, torch.Tensor)) + if type(scaling) == torch.Tensor: + assert scaling.ndimension() == 1 and scaling.shape[0] == num_heads, "only one entry per head." + + assert (update_steps_max is None) or (type(update_steps_max) in (int, torch.Tensor)) + if type(update_steps_max) == torch.Tensor: + assert update_steps_max.ndimension() == 1 and update_steps_max.shape[0] == num_heads, "only one entry per head." + elif type(update_steps_max) == int: + update_steps_max = torch.tensor([update_steps_max] * num_heads, dtype=torch.int32, device=query.device) + elif update_steps_max is None: + update_steps_max = -torch.ones(size=(num_heads,), dtype=torch.int32, device=query.device) + + assert type(update_steps_eps) in (float, torch.Tensor) + if type(update_steps_eps) == torch.Tensor: + assert update_steps_eps.ndimension() == 1 and update_steps_eps.shape[0] == num_heads, "only one entry per head." + assert (update_steps_eps <= 0.0).sum() == 0, "only positive thresholds allowed." + update_steps_eps = update_steps_eps.to(device=query.device) + elif type(update_steps_eps) == float: + assert update_steps_eps > 0, "only positive thresholds allowed." + update_steps_eps = torch.tensor([update_steps_eps] * num_heads, dtype=query.dtype, device=query.device) + + # Adapt dimensionality of each each. + if head_dim is None: + head_dim = embed_dim // num_heads + assert head_dim * num_heads == embed_dim, r'embed_dim must be divisible by num_heads.' + hopfield_dim = num_heads * head_dim + + # Adapt dimensionality of each value projection. + if pattern_dim is None: + pattern_dim = head_dim + assert (not value_as_connected) or (pattern_dim == head_dim) + + q, k, v, xi, src_len = None, None, None, None, 0 + update_step, xi_old, xi_difference_norm = 0, None, float(r'+inf') + update_active_heads = torch.tensor([[[True]]] * num_heads * bsz, device=query.device) + assert update_active_heads.any(), "at least one head needs to be active." + + #################################################################################################################### + # BEGIN HOPFIELD UPDATE ITERATION # + #################################################################################################################### + + while update_active_heads.any(): + + # The query is already projected into the "Hopfield" space at "update_step" equals 0. + # No more projection necessary if "update_step" greater than 0. + if update_step == 0: + if not use_separate_proj_weight: + + if torch.equal(query, key) and torch.equal(key, value) and not ( + key_as_static or query_as_static or value_as_static): + # self-attention + q, k, v = nn.functional.linear(query, in_proj_weight, in_proj_bias).chunk(3, dim=-1) + + elif torch.equal(key, value) and not (key_as_static or value_as_static): + # encoder-decoder attention + _start, _end = 0, hopfield_dim + if query_as_static: + q = query.repeat(1, num_heads, 1) + else: + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + q = nn.functional.linear(query, _w, _b) + _start = hopfield_dim + _end = None + + if key is None: + assert value is None + k = None + v = None + else: + + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + k, v = nn.functional.linear(key, _w, _b).chunk(2, dim=-1) + + else: + _start, _end = 0, hopfield_dim + if query_as_static: + q = query.repeat(1, num_heads, 1) + else: + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + q = nn.functional.linear(query, _w, _b) + _start += hopfield_dim + _end += hopfield_dim + + if key_as_static: + k = key.repeat(1, num_heads, 1) + else: + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + k = nn.functional.linear(key, _w, _b) + _start += hopfield_dim + _end += hopfield_dim + + if value_as_static: + v = value.repeat(1, num_heads, 1) + else: + # This is inline in_proj function with in_proj_weight and in_proj_bias + _b = in_proj_bias + _w = in_proj_weight[_start:_end, :] + if _b is not None: + _b = _b[_start:_end] + v = nn.functional.linear(value, _w, _b) + else: + _start, _end = 0, hopfield_dim + if query_as_static: + q = query.repeat(1, num_heads, 1) + else: + q_proj_weight_non_opt = torch.jit._unwrap_optional(q_proj_weight) + len1, len2 = q_proj_weight_non_opt.size() + assert len1 == hopfield_dim and len2 == query.size(-1) + if in_proj_bias is not None: + q = nn.functional.linear(query, q_proj_weight_non_opt, in_proj_bias[_start:_end]) + _start += hopfield_dim + _end += hopfield_dim + else: + q = nn.functional.linear(query, q_proj_weight_non_opt, in_proj_bias) + + v = value + if key_as_static: + k = key.repeat(1, num_heads, 1) + else: + k_proj_weight_non_opt = torch.jit._unwrap_optional(k_proj_weight) + len1, len2 = k_proj_weight_non_opt.size() + assert len1 == hopfield_dim and len2 == key.size(-1) + + _bias = None if in_proj_bias is None else in_proj_bias[_start:_end] + k = nn.functional.linear(key, k_proj_weight_non_opt, _bias) + if value_as_connected: + v = nn.functional.linear(v, k_proj_weight_non_opt, _bias) + _start += hopfield_dim + _end += num_heads * pattern_dim + + if value_as_static: + if not (value_as_connected or key_as_static): + v = v.repeat(1, num_heads, 1) + else: + v_proj_weight_non_opt = torch.jit._unwrap_optional(v_proj_weight) + len1, len2 = v_proj_weight_non_opt.size() + assert len1 == (num_heads * pattern_dim) and len2 == v.size(-1) + if in_proj_bias is not None: + v = nn.functional.linear(v, v_proj_weight_non_opt, in_proj_bias[_start:]) + else: + v = nn.functional.linear(v, v_proj_weight_non_opt, in_proj_bias) + + if attn_mask is not None: + assert attn_mask.dtype == torch.float32 or attn_mask.dtype == torch.float64 or \ + attn_mask.dtype == torch.float16 or attn_mask.dtype == torch.uint8 or \ + attn_mask.dtype == torch.bool, \ + 'Only float, byte, and bool types are supported for attn_mask, not {}'.format(attn_mask.dtype) + if attn_mask.dtype == torch.uint8: + warnings.warn( + "Byte tensor for attn_mask in nn.HopfieldCore is deprecated. Use bool tensor instead.") + attn_mask = attn_mask.to(torch.bool) + + if attn_mask.dim() == 2: + attn_mask = attn_mask.unsqueeze(0) + if list(attn_mask.size()) != [1, query.size(0), key.size(0)]: + raise RuntimeError('The size of the 2D attn_mask is not correct.') + elif attn_mask.dim() == 3: + if list(attn_mask.size()) != [bsz * num_heads, query.size(0), key.size(0)]: + raise RuntimeError('The size of the 3D attn_mask is not correct.') + else: + raise RuntimeError("attn_mask's dimension {} is not supported".format(attn_mask.dim())) + # attn_mask's dim is 3 now. + + # Optionally normalize patterns. + if normalize_pattern: + q = torch.nn.functional.layer_norm( + input=q.reshape(shape=(-1, head_dim)), normalized_shape=(head_dim,), + weight=p_norm_weight, bias=p_norm_bias).reshape(shape=q.shape) + k = torch.nn.functional.layer_norm( + input=k.reshape(shape=(-1, head_dim)), normalized_shape=(head_dim,), + weight=p_norm_weight, bias=p_norm_bias).reshape(shape=k.shape) + + else: + active_xi = xi.masked_select(mask=update_active_heads).view(size=(-1, *xi.shape[1:])) + active_k = k.masked_select(mask=update_active_heads).view(size=(-1, *k.shape[1:])) + q = torch.masked_scatter(input=q, mask=update_active_heads, source=torch.bmm(active_xi, active_k)) + + # Optionally scale association heads (each head separately). + if type(scaling) == float: + q = q * scaling + elif type(scaling) == torch.Tensor: + q = q * scaling.view(1, 1, -1).repeat(repeats=(1, 1, q.shape[2] // scaling.shape[0])) + + if update_step == 0: + # convert ByteTensor key_padding_mask to bool + if key_padding_mask is not None and key_padding_mask.dtype == torch.uint8: + warnings.warn( + "Byte tensor for key_padding_mask in nn.HopfieldCore is deprecated. Use bool tensor instead.") + key_padding_mask = key_padding_mask.to(torch.bool) + + if bias_k is not None and bias_v is not None: + if static_k is None and static_v is None and key_as_static is None and value_as_static is None: + k = torch.cat([k, bias_k.repeat(1, bsz, 1)]) + v = torch.cat([v, bias_v.repeat(1, bsz, 1)]) + if attn_mask is not None: + attn_mask = nn.functional.pad(attn_mask, [0, 1]) + if key_padding_mask is not None: + key_padding_mask = nn.functional.pad(key_padding_mask, [0, 1]) + else: + assert static_k is None, "bias cannot be added to static key." + assert static_v is None, "bias cannot be added to static value." + assert not key_as_static, "bias cannot be added to static key." + assert not value_as_static, "bias cannot be added to static value." + else: + assert bias_k is None + assert bias_v is None + + q = q.contiguous().view(tgt_len, -1, head_dim).transpose(0, 1) + if k is not None: + k = k.contiguous().view(-1, bsz * num_heads, head_dim).transpose(0, 1) + if v is not None: + v = v.contiguous().view(v.shape[0], bsz * num_heads, -1).transpose(0, 1) + + if static_k is not None: + assert static_k.size(0) == bsz * num_heads + assert static_k.size(2) == head_dim + k = static_k + + if static_v is not None: + assert static_v.size(0) == bsz * num_heads + assert static_v.size(2) == pattern_dim + v = static_v + + src_len = k.size(1) + + if key_padding_mask is not None: + assert key_padding_mask.size(0) == bsz + assert key_padding_mask.size(1) == src_len + + if add_zero_attn: + src_len += 1 + k = torch.cat([k, torch.zeros((k.size(0), 1) + k.size()[2:], dtype=k.dtype, device=k.device)], dim=1) + v = torch.cat([v, torch.zeros((v.size(0), 1) + v.size()[2:], dtype=v.dtype, device=v.device)], dim=1) + if attn_mask is not None: + attn_mask = nn.functional.pad(attn_mask, [0, 1]) + if key_padding_mask is not None: + key_padding_mask = nn.functional.pad(key_padding_mask, [0, 1]) + + attn_output_weights = torch.bmm(q, k.transpose(1, 2)) + assert list(attn_output_weights.size()) == [bsz * num_heads, tgt_len, src_len] + + if attn_mask is not None: + if attn_mask.dtype == torch.bool: + attn_output_weights.masked_fill_(attn_mask, float('-inf')) + else: + attn_output_weights += attn_mask + + if key_padding_mask is not None: + attn_output_weights = attn_output_weights.view(bsz, num_heads, tgt_len, src_len) + attn_output_weights = attn_output_weights.masked_fill( + key_padding_mask.unsqueeze(1).unsqueeze(2), + float('-inf'), + ) + attn_output_weights = attn_output_weights.view(bsz * num_heads, tgt_len, src_len) + + # Compute new xi for Hopfield retrieve iterations. + if xi is None: + xi = nn.functional.softmax(attn_output_weights, dim=-1) + else: + xi = torch.masked_scatter(input=xi, mask=update_active_heads, source=nn.functional.softmax( + attn_output_weights.masked_select(mask=update_active_heads).view(size=(-1, *xi.shape[1:])), dim=-1)) + + # Compute threshold-based stopping criterion for Hopfield retrieve iterations. + with torch.no_grad(): + xi_active = xi.view(size=(bsz, num_heads, tgt_len, src_len)) + update_active_heads = (update_step < update_steps_max) | (update_steps_max < 0) + if xi_old is not None: + update_active_heads &= ((xi_old - xi_active).norm(p=2, dim=(2, 3)).max(axis=0)[0]) > update_steps_eps + update_active_heads = update_active_heads.unsqueeze(dim=1).unsqueeze(dim=2).repeat(repeats=(bsz, 1, 1)) + xi_old = xi_active + update_step += 1 + + #################################################################################################################### + # END HOPFIELD UPDATE ITERATION # + #################################################################################################################### + + attn_output_weights = nn.functional.dropout(xi, p=dropout_p, training=training) + attn_output = torch.bmm(attn_output_weights, v) + assert list(attn_output.shape[:2]) == [bsz * num_heads, tgt_len] + attn_output = attn_output.transpose(0, 1).contiguous().view(tgt_len, bsz, -1) + if out_proj_weight is not None: + assert attn_output.shape[2] == num_heads * pattern_dim + attn_output = nn.functional.linear(attn_output, out_proj_weight, out_proj_bias) + + xi = xi.view(bsz, num_heads, tgt_len, src_len) if return_raw_associations else None + v = v.view(bsz, num_heads, src_len, -1) if return_projected_patterns else None + if need_weights: + # average attention weights over heads + attn_output_weights = attn_output_weights.view(bsz, num_heads, tgt_len, src_len) + return attn_output, attn_output_weights.sum(dim=1) / num_heads, xi, v + else: + return attn_output, None, xi, v diff --git a/src/mhnfs/hopfield/modules/transformer.py b/src/mhnfs/hopfield/modules/transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..884e0cb4b57610cf1daf8147f2c3d59f17824750 --- /dev/null +++ b/src/mhnfs/hopfield/modules/transformer.py @@ -0,0 +1,209 @@ +import torch +import torch.nn as nn + +from copy import deepcopy +from torch import Tensor +from torch.nn.modules import Module +from typing import Optional, Tuple, Union + +from . import Hopfield + + +class HopfieldEncoderLayer(Module): + """ + Module with underlying Hopfield association to be used as an encoder in transformer-like architectures. + """ + + def __init__(self, + hopfield_association: Hopfield, + dim_feedforward: int = 2048, + dropout: float = 0.1, + activation: str = r'relu' + ): + """ + Initialise a new instance of a Hopfield association-based encoder module. + + :param hopfield_association: instance of Hopfield association module + :param dim_feedforward: depth of the linear projections applied internally + :param activation: activation to be applied on the result of the internal linear projections + :param dropout: dropout probability to be applied internally + """ + super(HopfieldEncoderLayer, self).__init__() + self.hopfield_association = deepcopy(hopfield_association) + + self.linear_residual = nn.Linear(self.hopfield_association.state_pattern_dim, dim_feedforward) + self.dropout_residual = nn.Dropout(dropout) + self.linear_output = nn.Linear(dim_feedforward, self.hopfield_association.state_pattern_dim) + + self.norm_residual = nn.LayerNorm(self.hopfield_association.state_pattern_dim) + self.norm_output = nn.LayerNorm(self.hopfield_association.state_pattern_dim) + self.dropout_hopfield_association = nn.Dropout(dropout) + self.dropout_output = nn.Dropout(dropout) + + self.activation_residual = getattr(torch, activation, None) + assert self.activation_residual is not None, r'invalid activation function supplied.' + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset parameters, including Hopfield association. + + :return: None + """ + for module in (self.hopfield_association, self.linear_residual, + self.linear_output, self.norm_residual, self.norm_output): + if hasattr(module, r'reset_parameters'): + module.reset_parameters() + + def forward(self, src: Tensor, src_mask: Optional[Tensor] = None, + src_key_padding_mask: Optional[Tensor] = None) -> Tensor: + """ + Apply Hopfield encoding on specified data. + + :param src: data to be processed by Hopfield encoder module + :param src_mask: mask to be applied on association matrix + :param src_key_padding_mask: mask to be applied on stored patterns + :return: Hopfield-encoded input data + """ + data_associated = self.hopfield_association( + input=src, stored_pattern_padding_mask=src_key_padding_mask, association_mask=src_mask) + src = src + self.dropout_hopfield_association(input=data_associated) + src = self.norm_residual(input=src) + + result_residual_inner = self.activation_residual(input=self.linear_residual(input=src)) + data_associated = self.linear_output(input=self.dropout_residual(input=result_residual_inner)) + src = src + self.dropout_output(input=data_associated) + + return self.norm_output(input=src) + + def get_association_matrix(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]]) -> Tensor: + """ + Fetch Hopfield association matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :return: association matrix as computed by the Hopfield core module + """ + return self.hopfield_association.get_association_matrix(input=input) + + @property + def batch_first(self) -> int: + return self.hopfield_association.batch_first + + @property + def input_size(self) -> int: + return self.hopfield_association.input_size + + @property + def output_size(self) -> int: + return self.linear_output.out_features + + +class HopfieldDecoderLayer(Module): + + def __init__(self, + hopfield_association_self: Hopfield, + hopfield_association_cross: Hopfield, + dim_feedforward: int = 2048, + dropout: float = 0.1, + activation: str = r'relu' + ): + """ + Initialise a new instance of a Hopfield association-based encoder module. + + :param hopfield_association_self: instance of Hopfield self-association module + :param hopfield_association_cross: instance of Hopfield cross-association module + :param dim_feedforward: depth of the linear projections applied internally + :param dropout: dropout probability to be applied internally + :param activation: activation to be applied on the result of the internal linear projections + """ + super(HopfieldDecoderLayer, self).__init__() + self.hopfield_association_self = deepcopy(hopfield_association_self) + self.hopfield_association_cross = deepcopy(hopfield_association_cross) + + self.linear_residual = nn.Linear(self.hopfield_association_self.state_pattern_dim, dim_feedforward) + self.dropout_residual = nn.Dropout(dropout) + self.linear_output = nn.Linear(dim_feedforward, self.hopfield_association_self.state_pattern_dim) + + self.norm_residual_self = nn.LayerNorm(self.hopfield_association_self.state_pattern_dim) + self.norm_residual_cross = nn.LayerNorm(self.hopfield_association_self.state_pattern_dim) + self.norm_output = nn.LayerNorm(self.hopfield_association_self.state_pattern_dim) + self.dropout_hopfield_association_self = nn.Dropout(dropout) + self.dropout_hopfield_association_cross = nn.Dropout(dropout) + self.dropout_output = nn.Dropout(dropout) + + self.activation_residual = getattr(torch, activation, None) + assert self.activation_residual is not None, r'invalid activation function supplied.' + self.reset_parameters() + + def reset_parameters(self) -> None: + """ + Reset parameters, including Hopfield association. + + :return: None + """ + for module in (self.hopfield_association_self, self.hopfield_association_cross, + self.linear_residual, self.linear_output, self.norm_residual_self, + self.norm_residual_cross, self.norm_output): + if hasattr(module, r'reset_parameters'): + module.reset_parameters() + + def forward(self, tgt: Tensor, memory: Tensor, tgt_mask: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, tgt_key_padding_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None) -> Tensor: + """ + Apply Hopfield decoding on specified data. + + :param tgt: data to be processed by Hopfield decoder module (self-association) + :param memory: data to be processed by Hopfield encoder module (cross-association) + :param tgt_mask: mask to be applied on self-association matrix + :param memory_mask: mask to be applied on cross-association matrix + :param tgt_key_padding_mask: mask to be applied on stored patterns + :param memory_key_padding_mask: mask to be applied on state patterns as well as pattern projection + :return: Hopfield-decoded input + """ + data_associated = self.hopfield_association_self( + input=tgt, stored_pattern_padding_mask=tgt_key_padding_mask, + association_mask=tgt_mask) + tgt = tgt + self.dropout_hopfield_association_self(input=data_associated) + tgt = self.norm_residual_self(input=tgt) + + data_associated = self.hopfield_association_cross( + input=(memory, tgt, memory), stored_pattern_padding_mask=memory_key_padding_mask, + association_mask=memory_mask) + tgt = tgt + self.dropout_hopfield_association_cross(input=data_associated) + tgt = self.norm_residual_cross(input=tgt) + + result_residual_inner = self.activation_residual(input=self.linear_residual(input=tgt)) + data_associated = self.linear_output(input=self.dropout_residual(input=result_residual_inner)) + tgt = tgt + self.dropout_output(input=data_associated) + return self.norm_output(input=tgt) + + def get_association_matrix_self(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]]) -> Tensor: + """ + Fetch Hopfield self-association matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :return: association matrix as computed by the Hopfield core module + """ + return self.hopfield_association_self.get_association_matrix(input=input) + + def get_association_matrix_cross(self, input: Union[Tensor, Tuple[Tensor, Tensor, Tensor]]) -> Tensor: + """ + Fetch Hopfield cross-association matrix gathered by passing through the specified data. + + :param input: data to be passed through the Hopfield association + :return: association matrix as computed by the Hopfield core module + """ + return self.hopfield_association_cross.get_association_matrix(input=input) + + @property + def batch_first(self) -> int: + return self.hopfield_association_self.batch_first + + @property + def input_size(self) -> int: + return self.hopfield_association_self.input_size + + @property + def output_size(self) -> int: + return self.linear_output_self.out_features diff --git a/src/mhnfs/initialization.py b/src/mhnfs/initialization.py new file mode 100644 index 0000000000000000000000000000000000000000..103f29553a76a21b97bb1f4824c62dbfaad0221a --- /dev/null +++ b/src/mhnfs/initialization.py @@ -0,0 +1,29 @@ +from torch import nn +import torch + + +def init_lecun(m): + nn.init.normal_( + m.weight, + mean=0.0, + std=torch.sqrt(torch.tensor([1.0]) / m.in_features).numpy()[0], + ) + nn.init.zeros_(m.bias) + + +def init_kaiming(m, nonlinearity): + nn.init.kaiming_normal_(m.weight, mode="fan_in", nonlinearity=nonlinearity) + nn.init.zeros_(m.bias) + + +@torch.no_grad() +def init_weights(m, activation_function="linear"): + if activation_function == "relu": + if type(m) == nn.Linear: + init_kaiming(m, nonlinearity="relu") + elif activation_function == "selu": + if type(m) == nn.Linear: + init_lecun(m) + elif activation_function == "linear": + if type(m) == nn.Linear: + init_lecun(m) diff --git a/src/mhnfs/model.py b/src/mhnfs/model.py new file mode 100644 index 0000000000000000000000000000000000000000..0fd46def671434367cb939bf69494a46177fc070 --- /dev/null +++ b/src/mhnfs/model.py @@ -0,0 +1,199 @@ +import pytorch_lightning as pl +import numpy as np +import torch + +from src.mhnfs.modules import ( + EncoderBlock, + ContextModule, + LayerNormalizingBlock, + CrossAttentionModule, + SimilarityModule, +) + +class MHNfs(pl.LightningModule): + """ + The MHNfs is a few-shot drug-discovery model for activity prediction. + + For a requested query molecule, MHNfs predicts activity, while known knowledge from + the support set is used. + + MHNfs can be seen as an embedding-based few-shot method since the prediction is + based on similarities of molecule representations in a learned "representation + space". Being able to build rich, expressive molecule representations is the key for + a predictive model. + + MHNfs consists of + three consecutive modules: + - the context module, + - the cross attention module, and + - the similarity module. + + The context module associates the query and support set molecules with context - + i.e., a large set of training molecules. + + The cross-attention module allows for information sharing between query and support + set molecules. + + The similirity modules computes pair-wise similarity values between query and sup- + port set molecules and uses these similarity values to build a prediction from a + weighted sum over the support set labels. + """ + + def __init__(self, cfg): + super(MHNfs, self).__init__() + + # Config + self.cfg = cfg + + # Load context set + current_loc = __file__.rsplit("/",3)[0] + self.context = ( + torch.unsqueeze( + torch.from_numpy( + np.load(current_loc + "/assets/mhnfs_data/full_context_set.npy") + ), + 0, + ) + .float() + ) + + self.context_embedding = torch.ones(1, 512, 1024) + + self.layerNorm_context = torch.nn.LayerNorm( + cfg.model.associationSpace_dim, + elementwise_affine=cfg.model.layerNormBlock.affine, + ) + + # Encoder + self.encoder = EncoderBlock(cfg) + + # Context module + self.contextModule = ContextModule(self.cfg) + + # Layernormalizing-block + self.layerNormBlock = LayerNormalizingBlock(cfg) + + # Cross-attention module + self.crossAttentionModule = CrossAttentionModule(self.cfg) + + # Similarity module + self.similarity_function = SimilarityModule + + # Output function + self.sigmoid = torch.nn.Sigmoid() + self.prediction_scaling = cfg.model.prediction_scaling + + def forward( + self, + query_molecules: torch.Tensor, + support_molecules_active: torch.Tensor, + support_molecules_inactive: torch.Tensor, + support_set_actives_size: torch.Tensor, + support_set_inactives_size: torch.Tensor, + ) -> torch.Tensor: + # Get embeddings from molecule encoder + query_embedding = self.encoder(query_molecules) + support_actives_embedding = self.encoder(support_molecules_active) + support_inactives_embedding = self.encoder(support_molecules_inactive) + + # Retrieve updated representations from the context module + # - Layernorm + ( + query_embedding, + support_actives_embedding, + support_inactives_embedding, + ) = self.layerNormBlock( + query_embedding, support_actives_embedding, support_inactives_embedding + ) + + # - Expand support set related tensors + support_actives_embedding = support_actives_embedding.expand( + query_embedding.shape[0], -1, -1) + support_inactives_embedding = support_inactives_embedding.expand( + query_embedding.shape[0], -1, -1) + support_set_actives_size = support_set_actives_size.expand( + query_embedding.shape[0]) + support_set_inactives_size = support_set_inactives_size.expand( + query_embedding.shape[0]) + + # - Context module + ( + query_embedding, + support_actives_embedding, + support_inactives_embedding, + ) = self.contextModule( + query_embedding, + support_actives_embedding, + support_inactives_embedding, + self.context_embedding, + ) + + # Allow for information sharing between query and support set + # - Layernorm + ( + query_embedding, + support_actives_embedding, + support_inactives_embedding, + ) = self.layerNormBlock( + query_embedding, support_actives_embedding, support_inactives_embedding + ) + + # - Cross-attention module + ( + query_embedding, + support_actives_embedding, + support_inactives_embedding, + ) = self.crossAttentionModule( + query_embedding, + support_actives_embedding, + support_inactives_embedding, + ) + + # Build predictions from a weighted sum over support set labels + # - Layernorm: + if self.cfg.model.layerNormBlock.usage: + ( + query_embedding, + support_actives_embedding, + support_inactives_embedding, + ) = self.layerNormBlock( + query_embedding, support_actives_embedding, support_inactives_embedding + ) + + # - Similarity module: + predictions_support_actives = self.similarity_function( + query_embedding, + support_actives_embedding, + support_set_actives_size, + self.cfg, + ) + + predictions_support_inactives = self.similarity_function( + query_embedding, + support_inactives_embedding, + support_set_inactives_size, + self.cfg, + ) + + predictions = predictions_support_actives - predictions_support_inactives + + predictions = self.sigmoid(self.prediction_scaling * predictions) + + return predictions + + @torch.no_grad() + def _update_context_set_embedding(self): + """ + This function randomly samples the context set as a subset of all available + training molecules + """ + max_rows = self.context.shape[1] + number_requested_rows = int( + np.rint(self.cfg.model.context.ratio_training_molecules * max_rows) + ) + + sampled_rows = torch.randperm(max_rows)[:number_requested_rows] + + self.context_embedding = self.layerNorm_context( + self.encoder(self.context[:, sampled_rows, :]) + ) diff --git a/src/mhnfs/modules.py b/src/mhnfs/modules.py new file mode 100644 index 0000000000000000000000000000000000000000..6767205f780c9d6d9f4b471e4171cfd063a1f812 --- /dev/null +++ b/src/mhnfs/modules.py @@ -0,0 +1,574 @@ +import torch +import torch.nn as nn +#import hydra +from omegaconf import OmegaConf +from functools import partial +import math +from torch.nn import functional as F + +from src.mhnfs.hopfield.modules import Hopfield +from src.mhnfs.initialization import init_weights + + +# Mappings +activation_function_mapping = { + "relu": nn.ReLU(), + "selu": nn.SELU(), + "sigmoid": nn.Sigmoid(), +} + +dropout_mapping = {"relu": nn.Dropout, "selu": nn.AlphaDropout} + + +# Modules +class EncoderBlock(nn.Module): + """ + Fully connected molecule encoder block. + - Takes molecular descriptors, e.g., ECFPs and RDKit fps as inputs + - returns a molecular representation + """ + + def __init__(self, cfg: OmegaConf): + super(EncoderBlock, self).__init__() + + # Input layer + self.dropout = dropout_mapping[cfg.model.encoder.activation]( + cfg.model.encoder.regularization.input_dropout + ) + self.fc = nn.Linear( + cfg.model.encoder.input_dim, cfg.model.encoder.number_hidden_neurons + ) + self.act = activation_function_mapping[cfg.model.encoder.activation] + + # Hidden layer + self.hidden_linear_layers = nn.ModuleList([]) + self.hidden_dropout_layers = nn.ModuleList([]) + self.hidden_activations = nn.ModuleList([]) + + for _ in range(cfg.model.encoder.number_hidden_layers): + self.hidden_dropout_layers.append( + dropout_mapping[cfg.model.encoder.activation]( + cfg.model.encoder.regularization.dropout + ) + ) + self.hidden_linear_layers.append( + nn.Linear( + cfg.model.encoder.number_hidden_neurons, + cfg.model.encoder.number_hidden_neurons, + ) + ) + self.hidden_activations.append( + activation_function_mapping[cfg.model.encoder.activation] + ) + + # Output layer + self.dropout_o = dropout_mapping[cfg.model.encoder.activation]( + cfg.model.encoder.regularization.dropout + ) + self.fc_o = nn.Linear( + cfg.model.encoder.number_hidden_neurons, + cfg.model.associationSpace_dim, + ) + self.act_o = activation_function_mapping[cfg.model.encoder.activation] + + # Initialization + encoder_initialization = partial(init_weights, cfg.model.encoder.activation) + self.apply(encoder_initialization) + + def forward(self, molecule_representation: torch.Tensor) -> torch.Tensor: + # Input layer + x = self.dropout(molecule_representation) + x = self.fc(x) + x = self.act(x) + + # Hidden layer + for hidden_dropout, hidden_layer, hidden_activation_function in zip( + self.hidden_dropout_layers, + self.hidden_linear_layers, + self.hidden_activations, + ): + x = hidden_dropout(x) + x = hidden_layer(x) + x = hidden_activation_function(x) + + # Output layer + x = self.dropout_o(x) + x = self.fc_o(x) + x = self.act_o(x) + + return x + + +class ContextModule(nn.Module): + """ + Allows for mutual information sharing. + Enriches the query and support set embeddings with context by associating a query or + support set molecule with the context set, i.e., large set of training molecules: + - The context set can be seen as an external memory + - For a given molecule embedding, a Modern Hopfield Network retrieves a representa- + tion from the external memory + + Since we have to retrieve representations for all query and support set molecules we + stack all embeddings together and perform a "batch-retrieval". + """ + + def __init__(self, cfg: OmegaConf): + super(ContextModule, self).__init__() + + self.cfg = cfg + + self.hopfield = Hopfield( + input_size=self.cfg.model.associationSpace_dim, + hidden_size=cfg.model.hopfield.dim_QK, + stored_pattern_size=self.cfg.model.associationSpace_dim, + pattern_projection_size=self.cfg.model.associationSpace_dim, + output_size=self.cfg.model.associationSpace_dim, + num_heads=self.cfg.model.hopfield.heads, + scaling=self.cfg.model.hopfield.beta, + dropout=self.cfg.model.hopfield.dropout, + ) + + # Initialization + hopfield_initialization = partial(init_weights, "linear") + self.hopfield.apply(hopfield_initialization) + + def forward( + self, + query_embedding: torch.Tensor, + support_actives_embedding: torch.Tensor, + support_inactives_embedding: torch.Tensor, + context_set_embedding: torch.Tensor, + ) -> tuple: + """ + inputs: + - query; torch.tensor; + dim: [batch-size, 1, initial-embedding-dimension] + * e.g.: [512, 1, 1024] + * initial-embedding-dimension: defined by molecule encoder block + - active support set molecules; torch.tensor; + dim: [batch-size, active-padding-dim, initial-embedding-dimension] + * e.g.: [512, 9, 1024] + - inactive support set molecules; torch.tensor; + dim: [batch-size, inactive-padding-dim, initial-embedding-dimension] + * e.g.: [512, 11, 1024] + - context set molecules; torch.tensor; + dim: [1, number-of-context-molecules, initial-embedding-dimension] + * e.g.: [1, 512, 1024] + + return: + tuple which includes the updated representations for query, active, and inactive + support set molecules: + (query, active support set molecules, inactive support set molecules) + """ + # Stack embeddings together to perform a "batch-retrieval" + s = torch.cat( + (query_embedding, support_actives_embedding, support_inactives_embedding), + dim=1, + ) + s_flattend = s.reshape(1, s.shape[0] * s.shape[1], s.shape[2]) + + # Retrieval + s_h = self.hopfield((context_set_embedding, s_flattend, context_set_embedding)) + + # Combine retrieval with skip connection + s_updated = s_flattend + s_h + s_updated_inputShape = s_updated.reshape( + s.shape[0], s.shape[1], s.shape[2] + ) # reshape tensor back to input shape + + query_embedding = s_updated_inputShape[:, 0, :] + query_embedding = torch.unsqueeze(query_embedding, 1) + + # Split query, active and inactive support set embeddings + padding_size_actives = support_actives_embedding.shape[1] + + support_actives_embedding = s_updated_inputShape[ + :, 1 : (padding_size_actives + 1), : + ] + support_inactives_embedding = s_updated_inputShape[ + :, (padding_size_actives + 1) :, : + ] + + return query_embedding, support_actives_embedding, support_inactives_embedding + + +class LayerNormalizingBlock(nn.Module): + """ + Layernorm-block which scales/transforms the representations for query, ac- + tive, and inactive support set molecules. + """ + + def __init__(self, cfg: OmegaConf): + super(LayerNormalizingBlock, self).__init__() + + self.cfg = cfg + + if cfg.model.layerNormBlock.usage: + self.layernorm_query = nn.LayerNorm( + cfg.model.associationSpace_dim, + elementwise_affine=cfg.model.layerNormBlock.affine, + ) + self.layernorm_support_actives = nn.LayerNorm( + cfg.model.associationSpace_dim, + elementwise_affine=cfg.model.layerNormBlock.affine, + ) + self.layernorm_support_inactives = nn.LayerNorm( + cfg.model.associationSpace_dim, + elementwise_affine=cfg.model.layerNormBlock.affine, + ) + + def forward( + self, + query_embedding: torch.Tensor, + support_actives_embedding: torch.Tensor, + support_inactives_embedding: torch.Tensor, + ) -> tuple: + """ + inputs: + - query; torch.tensor; + dim: [batch-size, 1, embedding-dim] + * e.g.: [512, 1, 1024] + - active support set molecules; torch.tensor; + dim: [batch-size, active-padding-dim, embedding-dim] + * e.g.: [512, 9, 1024] + - inactive support set molecules; torch.tensor; + dim: [batch-size, inactive-padding-dim, initial-embedding-dim] + * e.g.: [512, 11, 1024] + + return: + tuple which includes the updated representations for query, active, and inactive + support set molecules: + (query, active support set molecules, inactive support set molecules) + """ + + # Layer normalization + # Since the layernorm operations are optional the module just updates represen- + # tations if the the referring option is set in the config. + if self.cfg.model.layerNormBlock.usage: + query_embedding = self.layernorm_query(query_embedding) + support_actives_embedding = self.layernorm_support_actives( + support_actives_embedding + ) + if support_inactives_embedding is not None: + support_inactives_embedding = self.layernorm_support_inactives( + support_inactives_embedding + ) + return query_embedding, support_actives_embedding, support_inactives_embedding + + +class CrossAttentionModule(nn.Module): + """ + The cross-attention module allows for information sharing between query and support + set molecules. + + Altae-Tran et al. [1] showed that representations can be enriched by making the + query molecule aware of the support set molecules and making the support set mole- + cules aware of each other and of the query molecule. We enable information sharing + with a transformer. + + Overview of the cross-attention module: + 1) The query and support set molecules are concatenated such that one joint matrix + emerges which includes both query and support set molecules. + 2) The joint matrix is fed into a transformer + - Self-attention enables information sharing between query and support set mole- + cules + + [1] Altae-Tran, H., Ramsundar, B., Pappu, A. S., & Pande, V. (2017). Low data drug + discovery with one-shot learning. ACS central science, 3(4), 283-293. + """ + + def __init__(self, cfg: OmegaConf): + + super(CrossAttentionModule, self).__init__() + + self.cfg = cfg + + cfg_gpt = self.GPTConfig() + self.transformer_block = self.TranformerBlock(cfg_gpt) + + # Initialization + encoder_initialization = partial(init_weights, 'relu') + self.apply(encoder_initialization) + + def forward( + self, + query_embedding: torch.Tensor, + support_actives_embedding: torch.Tensor, + support_inactives_embedding: torch.Tensor, + ) -> tuple: + """ + inputs: + - query; torch.tensor; + dim: [batch-size, 1, embedding-dim] + * e.g.: [512, 1, 1024] + - active support set molecules; torch.tensor; + dim: [batch-size, active-padding-dim, embedding-dim] + * e.g.: [512, 9, 1024] + - inactive support set molecules; torch.tensor; + dim: [batch-size, inactive-padding-dim, initial-embedding-dim] + * e.g.: [512, 11, 1024] + - number of active molecules in support set; torch.tensor; + dim: [batch-size] + - number of inactive molecules in support set; torch.tensor; + dim: [batch-size] + + return: + tuple which includes the updated representations for query, active, and inactive + support set molecules: + (query, active support set molecules, inactive support set molecules) + query_embedding, support_actives_embedding, support_inactives_embedding + """ + + # Embedding dim of query and support set molecules + embedding_dim = support_actives_embedding.shape[2] + + # Add activity encoding to representations + # Activity encoding: + # - active: 1 + # - inactive: -1 + # - unknown (query): 0 + query_embedding = torch.cat( + [ + query_embedding, + torch.zeros_like( + query_embedding[ + :, :, : self.cfg.model.transformer.activity_embedding_dim + ] + ), + ], + dim=2, + ) + + support_actives_embedding = torch.cat( + [ + support_actives_embedding, + torch.ones_like( + support_actives_embedding[ + :, :, : self.cfg.model.transformer.activity_embedding_dim + ] + ), + ], + dim=2, + ) + + support_inactives_embedding = torch.cat( + [ + support_inactives_embedding, + (-1.0) + * torch.ones_like( + support_inactives_embedding[ + :, :, : self.cfg.model.transformer.activity_embedding_dim + ] + ), + ], + dim=2, + ) + + # Concatenate query and support set molecules + s = torch.cat( + [query_embedding, support_actives_embedding, support_inactives_embedding], + dim=1, + ) + + # Run transformer and update representations + s_h = self.transformer_block(s) + s_updated = s + s_h + + # Split representations into query, active, and inactive support set molecules + query_embedding = s_updated[:, 0, :embedding_dim] + query_embedding = torch.unsqueeze(query_embedding, 1) + support_actives_embedding = s_updated[ + :, 1 : (support_actives_embedding.shape[1] + 1), :embedding_dim + ] + support_inactives_embedding = s_updated[ + :, (support_actives_embedding.shape[1] + 1) :, :embedding_dim + ] + + return query_embedding, support_actives_embedding, support_inactives_embedding + + #----------------------------------------------------------------------------------- + # Sub-modules + class TranformerBlock(nn.Module): + + def __init__(self, config): + super().__init__() + self.ln_1 = self.LayerNorm(config.n_embd, bias=config.bias) + self.attn = self.SelfAttention(config) + self.ln_2 = self.LayerNorm(config.n_embd, bias=config.bias) + self.mlp = self.MLP(config) + + def forward(self, x): + x = x + self.attn(self.ln_1(x)) + x = x + self.mlp(self.ln_2(x)) + return x + + class LayerNorm(nn.Module): + """ + LayerNorm but with an optional bias. PyTorch doesn't support simply + bias=False + """ + + def __init__(self, ndim, bias): + super().__init__() + self.weight = nn.Parameter(torch.ones(ndim)) + self.bias = nn.Parameter(torch.zeros(ndim)) if bias else None + + def forward(self, input): + return F.layer_norm(input, self.weight.shape, self.weight, self.bias, + 1e-5) + + class SelfAttention(nn.Module): + """ + Self Attention Block + """ + + def __init__(self, config): + super().__init__() + + self.cfg = config + + # query, key, value projections + self.q_proj = nn.Linear(config.n_embd, config.n_qk_proj*config.n_head, + bias=config.bias) + self.k_proj = nn.Linear(config.n_embd, config.n_qk_proj*config.n_head, + bias=config.bias) + self.v_proj = nn.Linear(config.n_embd, config.n_v_proj*config.n_head, + bias=config.bias) + + # output projection + self.c_proj = nn.Linear(config.n_v_proj*config.n_head, config.n_embd, + bias=config.bias) + + # regularization + self.attn_dropout = nn.Dropout(config.dropout) + self.resid_dropout = nn.Dropout(config.dropout) + self.n_head = config.n_head + self.n_embd = config.n_embd + self.dropout = config.dropout + + def forward(self, x): + B, T, C = x.size() # batch size, sequence length, embedding dim (n_embd) + + # Calculate queries, keys, and values + q = self.q_proj(x).view(B, T, self.n_head, self.cfg.n_qk_proj + ).transpose(1, 2) # (B, nh, T, hs) + k = self.k_proj(x).view(B, T, self.n_head, self.cfg.n_qk_proj + ).transpose(1, 2) # (B, nh, T, hs) + v = self.v_proj(x).view(B, T, self.n_head, self.cfg.n_v_proj + ).transpose(1, 2) # (B, nh, T, hs) + + # Calculate self-attentions + att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1))) + + # Activations + att = F.softmax(att, dim=-1) + att = self.attn_dropout(att) + y = att @ v # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs) + + # Re-assemble all head outputs side by side + y = y.transpose(1, 2).contiguous().view(y.shape[0], + y.shape[2], + -1) + + # output projection + y = self.resid_dropout(self.c_proj(y)) + return y + + class MLP(nn.Module): + + def __init__(self, config): + super().__init__() + self.c_fc = nn.Linear(config.n_embd, 567, bias=config.bias) + self.relu = nn.ReLU() + self.c_proj = nn.Linear(567, config.n_embd, bias=config.bias) + self.dropout = nn.Dropout(config.dropout) + + def forward(self, x): + x = self.c_fc(x) + x = self.relu(x) + x = self.c_proj(x) + x = self.dropout(x) + return x + + class GPTConfig: + n_head: int = 8 + n_embd: int = 1088 + dropout: float = 0. + bias: bool = True + n_qk_proj: int = 136 + n_v_proj: int = 136 + + +def SimilarityModule( + query_embedding: torch.Tensor, + support_set_embeddings: torch.Tensor, + support_set_size: torch.Tensor, + cfg: OmegaConf, +) -> torch.Tensor: + """ + The similarity module builds the activity prediction for the query molecule from a + weighted sum over the support set labels. Pair-wise similarity values between query + and support set molecules are used as weights for the weighted sum. + + Since the similarity module is applied twice within the MHNfs model - once for the + active and once for the inactive support set molecules, the support_set_embeddings + here mean ether active or inactive support set molecule embeddings. + + inputs: + - query; torch.tensor; + dim: [batch-size, 1, embedding-dimension] + * e.g.: [512, 1, 1024] + - support set molecules; torch.tensor; + dim: [batch-size, padding-dim, embedding-dimension] + * e.g.: [512, 9, 1024] + - padding mask; torch.tensor; boolean + dim: [batch-size, padding-dim] + * e.g.: [512, 9] + - support set size; torch.tensor; + dim: [batch-size] + * e.g.: [512] + """ + + # Optional L2-norm + if cfg.model.similarityModule.l2Norm: + query_embedding_div = torch.unsqueeze( + query_embedding.pow(2).sum(dim=2).sqrt(), 2 + ) + query_embedding_div[query_embedding_div == 0] = 1 + support_set_embeddings_div = torch.unsqueeze( + support_set_embeddings.pow(2).sum(dim=2).sqrt(), 2 + ) + support_set_embeddings_div[support_set_embeddings_div == 0] = 1 + + query_embedding = query_embedding / query_embedding_div + support_set_embeddings = support_set_embeddings / support_set_embeddings_div + + # Compute similarity values + similarities = query_embedding @ torch.transpose(support_set_embeddings, 1, 2) + # dim: + # [batch-size, 1, padding-dim] = + # [batch-size, 1, emb-dim] x [batch-size, emb-dim, padding-dim] + + # Compute similarity values + similarities[torch.isnan(similarities)] = 0.0 + similarity_sums = similarities.sum( + dim=2 + ) # For every query molecule: Sum over support set molecules + + # Scaling + if cfg.model.similarityModule.scaling == "1/N": + stabilizer = torch.tensor(1e-8).float() + similarity_sums = ( + 1 / (2.0 * support_set_size.reshape(-1, 1) + stabilizer) * similarity_sums + ) + if cfg.model.similarityModule.scaling == "1/sqrt(N)": + stabilizer = torch.tensor(1e-8).float() + similarity_sums = ( + 1 + / (2.0 * torch.sqrt(support_set_size.reshape(-1, 1).float()) + stabilizer) + * similarity_sums + ) + + return similarity_sums + +# -------------------------------------------------------------------------------------- diff --git a/src/prediction_pipeline.py b/src/prediction_pipeline.py new file mode 100644 index 0000000000000000000000000000000000000000..30b650213a13e562891f442e3b99d619be0cc7c6 --- /dev/null +++ b/src/prediction_pipeline.py @@ -0,0 +1,104 @@ +""" +This module provides a simple predict function for the MHNfs model. +It loads the model from the provided checkpoint, creates necessary helper inputs +and makes predictions for a list of molecules +""" + +#--------------------------------------------------------------------------------------- +# Dependencies +import pandas as pd +import pytorch_lightning as pl +import streamlit as st + +from src.data_preprocessing.create_model_inputs import (create_query_input, + create_support_set_input) +from src.mhnfs.model import MHNfs + +#--------------------------------------------------------------------------------------- +# Define predictor class + +class ActivityPredictor: + + def __init__(self): + + @st.cache_resource # Caching for streamlit + def load_model(): + pl.seed_everything(1234) + current_loc = __file__.rsplit("/",2)[0] + model = MHNfs.load_from_checkpoint(current_loc + + "/assets/mhnfs_data/" + "mhnfs_checkpoint.ckpt") + model._update_context_set_embedding() + model.eval() + + return model + + # Load model + self.model = load_model() + + # Initiate query mol storage + self.query_molecules = None + + def predict(self, query_smiles, support_activces_smiles, support_inactives_smiles): + + # Create model inputs + # Query input + self.query_molecules = query_smiles + query_input = create_query_input(query_smiles) + + # Active support set input + support_actives_input, support_actives_size = create_support_set_input( + support_activces_smiles + ) + + # Inactive support set input + support_inactives_input, support_inactives_size = create_support_set_input( + support_inactives_smiles + ) + + # Make predictions + predictions = self.model( + query_input, + support_actives_input, + support_inactives_input, + support_actives_size, + support_inactives_size, + ) + + preds_numpy = predictions.detach().numpy().flatten() + + + return preds_numpy + + def _return_query_mols_as_list(self): + if isinstance(self.query_molecules, list): + return self.query_molecules + elif isinstance(self.query_molecules, str): + smiles_list = self.query_molecules.split(",") + smiles_list_cleaned = [smiles.strip() for smiles in smiles_list] + return smiles_list_cleaned + elif isinstance(self.query_molecules, pd.DataFrame): + return self.query_molecules.smiles.tolist() + elif isinstance(self.query_molecules, type(None)): + raise ValueError("No query molecules have been stored yet." + "Run predict-function first.") + else: + raise TypeError("Type of query molecules not recognized." + "Please check input type.") + +#--------------------------------------------------------------------------------------- +if __name__ == "__main__": + # Create predictor + predictor = ActivityPredictor() + + # Create example inputs + query_smiles = ["C1CCCCC1", "C1CCCCC1", "C1CCCCC1", "C1CCCCC1"] + support_actives_smiles = ["C1CCCCC1", "C1CCCCC1"] + support_inactives_smiles = ["C1CCCCC1", "C1CCCCC1"] + + # Make predictions + predictions = predictor.predict(query_smiles, + support_actives_smiles, + support_inactives_smiles) + + print(predictions) \ No newline at end of file diff --git a/src/tests/__init__.py b/src/tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/src/tests/__pycache__/__init__.cpython-36.pyc b/src/tests/__pycache__/__init__.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..51b83385d06b9f52ca156bc8bc90a2c89a063e22 Binary files /dev/null and b/src/tests/__pycache__/__init__.cpython-36.pyc differ diff --git a/src/tests/__pycache__/__init__.cpython-37.pyc b/src/tests/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a365866a2700e17b4118ea7cea62d82526a19960 Binary files /dev/null and b/src/tests/__pycache__/__init__.cpython-37.pyc differ diff --git a/src/tests/__pycache__/conftest.cpython-36-pytest-7.0.1.pyc b/src/tests/__pycache__/conftest.cpython-36-pytest-7.0.1.pyc new file mode 100644 index 0000000000000000000000000000000000000000..92991581878b602e1b74053ba7d44f3ef1eb1de6 Binary files /dev/null and b/src/tests/__pycache__/conftest.cpython-36-pytest-7.0.1.pyc differ diff --git a/src/tests/__pycache__/conftest.cpython-37-pytest-7.1.2.pyc b/src/tests/__pycache__/conftest.cpython-37-pytest-7.1.2.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f6e2a0fa9c1682595dc7bc00d5f0aecbc34ccc7d Binary files /dev/null and b/src/tests/__pycache__/conftest.cpython-37-pytest-7.1.2.pyc differ diff --git a/src/tests/__pycache__/test_data_preprocessing.cpython-36-pytest-7.0.1.pyc b/src/tests/__pycache__/test_data_preprocessing.cpython-36-pytest-7.0.1.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c23c0b8683506876a4c833bbc626b35bce3d644b Binary files /dev/null and b/src/tests/__pycache__/test_data_preprocessing.cpython-36-pytest-7.0.1.pyc differ diff --git a/src/tests/__pycache__/test_data_preprocessing.cpython-37-pytest-7.1.2.pyc b/src/tests/__pycache__/test_data_preprocessing.cpython-37-pytest-7.1.2.pyc new file mode 100644 index 0000000000000000000000000000000000000000..68e709e1abd86012ba3af7696cd2abc6b68ab942 Binary files /dev/null and b/src/tests/__pycache__/test_data_preprocessing.cpython-37-pytest-7.1.2.pyc differ diff --git a/src/tests/__pycache__/test_prediction_pipeline_model_preds.cpython-37-pytest-7.1.2.pyc b/src/tests/__pycache__/test_prediction_pipeline_model_preds.cpython-37-pytest-7.1.2.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ad965de65f1e148f09275382c2d88fe6958c154 Binary files /dev/null and b/src/tests/__pycache__/test_prediction_pipeline_model_preds.cpython-37-pytest-7.1.2.pyc differ diff --git a/src/tests/conftest.py b/src/tests/conftest.py new file mode 100644 index 0000000000000000000000000000000000000000..856af48f074ef6ee8d18c9cd7a92c82445680f8d --- /dev/null +++ b/src/tests/conftest.py @@ -0,0 +1,100 @@ +""" +Needed objects for tests +""" + +#--------------------------------------------------------------------------------------- +# Dependencies +import pytest +import pandas as pd +import pickle +import numpy as np +import torch + +from data_preprocessing.create_descriptors import create_cleaned_mol_objects + +#--------------------------------------------------------------------------------------- +# Define fixtures + +#--------------------------------------------------------------------------------------- +# Data preprocessing +@pytest.fixture(scope="session") +def input_molecule_formats(): + class Formats: + smiles = "CCO" + smiles_coma = "CCO, CCN" + smiles_list = ["CCO", "CCN"] + smiles_df = pd.DataFrame({"smiLES": ["CCO", "CCN"]}) + smiles_df_wrong_key = pd.DataFrame({"notSMILES": ["CCO", "CCN"]}) + return Formats() + +@pytest.fixture(scope="session") +def input_smiles(): + current_loc = __file__.rsplit("/",3)[0] + with open(current_loc + "/assets/test_reference_data/smiles.pkl", "rb") as fl: + input_smiles = pickle.load(fl) + return input_smiles + +@pytest.fixture(scope="session") +def input_mols_from_smiles(): + current_loc = __file__.rsplit("/",3)[0] + with open(current_loc + "/assets/test_reference_data/smiles.pkl", "rb") as fl: + input_smiles = pickle.load(fl) + + input_molecules = create_cleaned_mol_objects(input_smiles) + return input_molecules + +@pytest.fixture(scope="session") +def ecfps_from_smiles(): + current_loc = __file__.rsplit("/",3)[0] + ecfps = np.load(current_loc + "/assets/test_reference_data/ecfps.npy") + return ecfps + +@pytest.fixture(scope="session") +def rdkit_descrs_from_smiles(): + current_loc = __file__.rsplit("/",3)[0] + rdkit_descrs = np.load(current_loc + "/assets/test_reference_data/rdkit_descrs.npy") + return rdkit_descrs + +@pytest.fixture(scope="session") +def rdkit_descr_quantils(): + current_loc = __file__.rsplit("/",3)[0] + rdkit_descr_quantils = np.load( + current_loc + "/assets/test_reference_data/rdkit_descr_quantils.npy") + return rdkit_descr_quantils + +@pytest.fixture(scope="session") +def preprocessed_features(): + current_loc = __file__.rsplit("/",3)[0] + preprocessed_features = np.load( + current_loc + "/assets/test_reference_data/preprocessed_features.npy") + return preprocessed_features + +#--------------------------------------------------------------------------------------- +# Model +@pytest.fixture(scope="session") +def model_input_query(): + current_loc = __file__.rsplit("/",3)[0] + model_input_query = torch.load( + current_loc + "/assets/test_reference_data/model_input_query.pt") + return model_input_query + +@pytest.fixture(scope="session") +def model_input_support_actives(): + current_loc = __file__.rsplit("/",3)[0] + model_input_support_actives = torch.load( + current_loc + "/assets/test_reference_data/model_input_support_actives.pt") + return model_input_support_actives + +@pytest.fixture(scope="session") +def model_input_support_inactives(): + current_loc = __file__.rsplit("/",3)[0] + model_input_support_inactives = torch.load( + current_loc + "/assets/test_reference_data/model_input_support_inactives.pt") + return model_input_support_inactives + +@pytest.fixture(scope="session") +def model_predictions(): + current_loc = __file__.rsplit("/",3)[0] + model_predictions = torch.load( + current_loc + "/assets/test_reference_data/model_predictions.pt") + return model_predictions \ No newline at end of file diff --git a/src/tests/test_data_preprocessing.py b/src/tests/test_data_preprocessing.py new file mode 100644 index 0000000000000000000000000000000000000000..eaf747764cfb9c7aa4ec4a51f79d5b6d8f000b34 --- /dev/null +++ b/src/tests/test_data_preprocessing.py @@ -0,0 +1,113 @@ +""" +This file includes all tests for the data_preprocessing module. +""" + +import pytest +import numpy as np +import pickle +from data_preprocessing.create_descriptors import (handle_inputs, + create_ecfp_fps, + create_rdkit_descriptors, + create_quantils, + preprocess_molecules) + +class TestPreprocessMolecules: + + def test_handle_inputs(self, input_molecule_formats): + """ + This functions check whether all 3 possible input formats are correctly + transformed into list. + """ + + # Check 1: Smiles + output_smiles = handle_inputs(input_molecule_formats.smiles) + assert isinstance(output_smiles, list) + + # Check 2: Smiles coma + output_smiles_coma = handle_inputs(input_molecule_formats.smiles_coma) + assert isinstance(output_smiles_coma, list) + assert output_smiles_coma == input_molecule_formats.smiles_list + + # Check 3: Smiles list + output_smiles_list = handle_inputs(input_molecule_formats.smiles_list) + assert isinstance(output_smiles_list, list) + + # Check 4.1: Correct DataFrame + output_smiles_df = handle_inputs(input_molecule_formats.smiles_df) + assert isinstance(output_smiles_df, list) + + # Check 4.2: Wrong DataFrame + with pytest.raises(ValueError): + handle_inputs(input_molecule_formats.smiles_df_wrong_key) + + def test_create_ecfps_fps(self, input_mols_from_smiles, ecfps_from_smiles): + """ + This function tests whether the ECFP fingerprints are correctly created. + """ + + # Check 1: Correct output type + output_ecfps = create_ecfp_fps(input_mols_from_smiles) + assert isinstance(output_ecfps, np.ndarray) + + # Check 2: Correct output shape + assert output_ecfps.shape == ecfps_from_smiles.shape + + # Check 3: Correct output values + assert np.allclose(output_ecfps, ecfps_from_smiles, 0, 0) + + def test_create_rdkit_descriptors(self, input_mols_from_smiles, + rdkit_descrs_from_smiles): + """ + This function tests whether the RDKit descriptors are correctly created. + """ + + # Check 1: Correct output type + output_rdkit_descrs = create_rdkit_descriptors(input_mols_from_smiles) + assert isinstance(output_rdkit_descrs, np.ndarray) + + # Check 2: Correct output shape + assert output_rdkit_descrs.shape == rdkit_descrs_from_smiles.shape + + # Check 3: Correct output values + assert np.allclose(output_rdkit_descrs, rdkit_descrs_from_smiles) + + def test_create_quantils(self, input_mols_from_smiles, rdkit_descr_quantils): + """ + This function tests whether the quantils are correctly created. + """ + current_loc = __file__.rsplit("/",3)[0] + with open(current_loc + "/assets/data_preprocessing_objects/ecdfs.pkl", + "rb") as fl: + ecdfs = pickle.load(fl) + + rdkit_descrs = create_rdkit_descriptors(input_mols_from_smiles) + output_quantils = create_quantils(rdkit_descrs, ecdfs) + + # Check 1: Correct output type + assert isinstance(output_quantils, np.ndarray) + + # Check 2: Correct output shape + assert output_quantils.shape == rdkit_descr_quantils.shape + + # Check 3: Correct output values + assert np.allclose(output_quantils, rdkit_descr_quantils) + + def test_preprocess_molecules(self, input_smiles, + preprocessed_features): + """ + This function tests whether the preprocessing of molecules is correctly + done. + """ + + # Check 1: Correct output type + output_preprocessed_features = preprocess_molecules(input_smiles) + assert isinstance(output_preprocessed_features, np.ndarray) + + # Check 2: Correct output shape + assert output_preprocessed_features.shape == preprocessed_features.shape + + # Check 3: Correct output values + assert np.allclose(output_preprocessed_features, preprocessed_features) + + + \ No newline at end of file diff --git a/src/tests/test_prediction_pipeline_model_preds.py b/src/tests/test_prediction_pipeline_model_preds.py new file mode 100644 index 0000000000000000000000000000000000000000..36bb640f6cc55565ae7f75a717869ea15800138c --- /dev/null +++ b/src/tests/test_prediction_pipeline_model_preds.py @@ -0,0 +1,88 @@ +""" +This file tests whether the model predictions for MHNfs match the predictions made on +the JKU development server (varified model, server conda env with spec. packages ...) +""" + +#--------------------------------------------------------------------------------------- +# Dependencies +import pytest +import torch +import pandas as pd +from prediction_pipeline import ActivityPredictor + +#--------------------------------------------------------------------------------------- +# Define tests + +class TestActivityPredictor: + + def test_mhnfs_prediction(self, model_input_query, model_input_support_actives, + model_input_support_inactives, model_predictions): + + # Load model + predictor = ActivityPredictor() + + # Define additional inputs to model - i.e. support set sizes + support_actives_size = torch.tensor(model_input_support_actives.shape[1]) + support_inactives_size = torch.tensor(model_input_support_inactives.shape[1]) + + # Make predictions + predictions = predictor.model( + model_input_query, + model_input_support_actives, + model_input_support_inactives, + support_actives_size, + support_inactives_size + ).detach() + + # Compare predictions + assert torch.allclose(predictions, model_predictions, atol=0.01, rtol=0.) + + def test_query_mol_return(self): + + # Support set + support_actives_smiles = ["CCCCCCCCNC(C)C(O)c1ccc(SC(C)C)cc1"] + support_inactives_smiles = ["CCN(CC)C(=S)SSC(=S)N(CC)CCCCC"] + + # Load activity predictor + predictor = ActivityPredictor() + + # Check 1: Query mols given as a list + query_smiles = ["CCCCCCCCNC(C)C(O)c1ccc(SC(C)C)cc1", + "CCN(CC)C(=S)SSC(=S)N(CC)CC"] + + _ = predictor.predict(query_smiles, support_actives_smiles, + support_inactives_smiles) + query_output = predictor._return_query_mols_as_list() + assert query_output == query_smiles + + # Check 2: Query mols given as a string + query_smiles_str = ("CCCCCCCCNC(C)C(O)c1ccc(SC(C)C)cc1," + "CCN(CC)C(=S)SSC(=S)N(CC)CC") + _ = predictor.predict(query_smiles_str, support_actives_smiles, + support_inactives_smiles) + query_output = predictor._return_query_mols_as_list() + assert query_output == query_smiles + + # Check 3: Query mols given as a pd.Series + query_smiles_series = pd.DataFrame({"smiles": + ["CCCCCCCCNC(C)C(O)c1ccc(SC(C)C)cc1", "CCN(CC)C(=S)SSC(=S)N(CC)CC"]}) + _ = predictor.predict(query_smiles_series, support_actives_smiles, + support_inactives_smiles) + query_output = predictor._return_query_mols_as_list() + assert query_output == query_smiles + + # Check 4: Query molecules storage is None + predictor.query_molecules = None + with pytest.raises(ValueError): + predictor._return_query_mols_as_list() + + # Check 5: Other data types + predictor.query_molecules = 123 # any other data type + with pytest.raises(TypeError): + predictor._return_query_mols_as_list() + + + + + +